Option, Result & Combinators

enum OptionLike<T> { None, Some(T) }        // std::option::Option
enum ResultLike<T, E> { Ok(T), Err(E) }     // std::result::Result

use std::collections::HashMap;

fn find_year(catalog: &HashMap<&str, u16>, title: &str) -> Option<u16> {
    catalog.get(title).copied()
}

fn parse_year(text: &str) -> Result<u16, std::num::ParseIntError> {
    text.trim().parse()
}

fn main() {
    let catalog = HashMap::from([("Dune", 1965), ("Emma", 1815)]);
    match find_year(&catalog, "Dune") {
        Some(y) => println!("Dune: {y}"),
        None => println!("not in catalog"),
    }
    match parse_year("19x5") {
        Ok(y) => println!("{y}"),
        Err(e) => println!("bad year: {e}"), // bad year: invalid digit found in string
    }
    println!("{} {}", find_year(&catalog, "Ulysses").is_none(), parse_year("1965").is_ok());
    println!("{}", find_year(&catalog, "Emma").is_some_and(|y| y < 1900)); // true
}

use std::collections::HashMap;

#[derive(Debug)]
struct Book {
    title: String,
    author_id: u32,
}

fn author_of(books: &HashMap<String, Book>, authors: &HashMap<u32, String>, isbn: &str) -> Option<String> {
    let book = books.get(isbn)?;               // None -> return None
    let name = authors.get(&book.author_id)?;
    Some(format!("{} by {name}", book.title))
}

fn total_pages(lines: &[&str]) -> Result<u32, std::num::ParseIntError> {
    let mut total = 0;
    for line in lines {
        total += line.trim().parse::<u32>()?;  // Err -> return Err
    }
    Ok(total)
}

fn main() {
    let books = HashMap::from([("978".to_string(), Book { title: "Dune".into(), author_id: 1 })]);
    let authors = HashMap::from([(1, "Frank Herbert".to_string())]);
    println!("{:?}", author_of(&books, &authors, "978"));  // Some("Dune by Frank Herbert")
    println!("{:?}", author_of(&books, &authors, "000"));  // None
    println!("{:?}", total_pages(&["412", "180"]));         // Ok(592)
    println!("{:?}", total_pages(&["412", "many"]));        // Err(ParseIntError { kind: InvalidDigit })
}

#[derive(Debug)]
struct Member {
    name: String,
    nickname: Option<String>,
    max_loans: Option<u8>,
}

fn display_name(m: &Member) -> &str {
    m.nickname.as_deref().filter(|n| !n.is_empty()).unwrap_or(&m.name)
}

fn parse_rating(input: &str) -> Result<u8, String> {
    input
        .trim()
        .parse::<u8>()
        .map_err(|e| format!("{input:?} is not a number: {e}"))
        .and_then(|n| if (1..=5).contains(&n) { Ok(n) } else { Err(format!("{n} is out of range")) })
}

fn main() {
    let alice = Member { name: "Alice".into(), nickname: Some(String::new()), max_loans: None };
    let bob = Member { name: "Robert".into(), nickname: Some("Bob".into()), max_loans: Some(8) };
    println!("{} {}", display_name(&alice), display_name(&bob));       // Alice Bob

    let limit = alice.max_loans.unwrap_or(5);                            // fallback value
    let label = bob.max_loans.map_or("default".to_string(), |n| format!("{n} loans"));
    println!("{limit} {label}");

    println!("{:?} {:?} {:?}", parse_rating("4"), parse_rating("7"), parse_rating("x"));

    let first = Some("Dune");
    let year = Some(1965);
    println!("{:?}", first.zip(year));                                   // Some(("Dune", 1965))

    let mut reserved: Option<String> = Some("Emma".into());
    let taken = reserved.take();                                         // leaves None behind
    println!("{taken:?} {reserved:?}");

    let in_stock = 3 > 0;
    let checked: Result<(), &str> = in_stock.ok_or("out of stock");     // bool::ok_or, 1.98
    println!("{checked:?} {:?}", (2 > 3).then_some("never"));
}

use std::num::ParseIntError;

/// An optional `year` field that must be a valid number if it is present.
fn parse_optional_year(field: Option<&str>) -> Result<Option<u16>, ParseIntError> {
    field.map(|s| s.parse::<u16>()).transpose()
}

fn main() -> Result<(), ParseIntError> {
    println!("{:?}", parse_optional_year(Some("1965"))?); // Some(1965)
    println!("{:?}", parse_optional_year(None)?);         // None
    println!("{:?}", parse_optional_year(Some("x")));     // Err(ParseIntError { kind: InvalidDigit })
    Ok(())
}

fn main() {
    let good = ["1965", "1815", "1987"];
    let bad = ["1965", "oops", "1987"];

    let years: Result<Vec<u16>, _> = good.iter().map(|s| s.parse::<u16>()).collect();
    println!("{years:?}");                    // Ok([1965, 1815, 1987])
    let years: Result<Vec<u16>, _> = bad.iter().map(|s| s.parse::<u16>()).collect();
    println!("{years:?}");                    // Err(ParseIntError { kind: InvalidDigit })

    // Keep the successes and collect the errors separately:
    let (ok, errors): (Vec<_>, Vec<_>) = bad.iter().map(|s| s.parse::<u16>()).partition(Result::is_ok);
    let ok: Vec<u16> = ok.into_iter().map(Result::unwrap).collect();
    println!("{ok:?}, {} errors", errors.len());

    // Just skip the failures:
    let parsed: Vec<u16> = bad.iter().filter_map(|s| s.parse().ok()).collect();
    println!("{parsed:?}");

    let total: Option<u32> = [Some(3), Some(4)].into_iter().sum();
    println!("{total:?}");                    // Some(7)
}