Error Handling

fn divide(a: i32, b: i32) -> Result<i32, String> {
    if b == 0 {
        return Err(String::from("division by zero"));
    }
    Ok(a / b)
}

fn main() {
    let results = [divide(10, 2), divide(1, 0)];
    for r in &results {
        match r {
            Ok(v) => println!("ok: {v}"),
            Err(e) => println!("error: {e}"),
        }
    }
    println!("{:?}", divide(9, 3));
    println!("{:?}", divide(9, 0));
}

fn main() {
    let port: u16 = "8080".parse().unwrap();            // a literal: cannot fail
    let retries: u32 = "3".parse().expect("retries is a hard-coded number");
    println!("port {port}, retries {retries}");

    // The safe alternatives never panic
    let bad = "eighty".parse::<u16>();
    println!("{}", bad.clone().unwrap_or(80));
    println!("{}", bad.clone().unwrap_or_default());
    println!("{}", bad.is_err());
}

use std::num::ParseIntError;

fn parse_age(s: &str) -> Result<u8, ParseIntError> {
    s.trim().parse::<u8>()
}

fn main() {
    for input in ["42", " 7 ", "300", "abc", ""] {
        match parse_age(input) {
            Ok(age) if age >= 18 => println!("{input:?}: adult ({age})"),
            Ok(age) => println!("{input:?}: minor ({age})"),
            Err(e) => println!("{input:?}: {e}"),
        }
    }

    let doubled = parse_age("21").map(|a| a as u32 * 2);      // change the Ok value
    let labelled = parse_age("x").map_err(|e| format!("bad age: {e}")); // change the Err
    let fallback = parse_age("x").unwrap_or_else(|_| 0);      // compute a default
    println!("{:?} | {:?} | {}", doubled, labelled, fallback);
}

use std::num::ParseIntError;

// Without ?
fn sum_verbose(a: &str, b: &str) -> Result<i32, ParseIntError> {
    let x = match a.parse::<i32>() {
        Ok(v) => v,
        Err(e) => return Err(e),
    };
    let y = match b.parse::<i32>() {
        Ok(v) => v,
        Err(e) => return Err(e),
    };
    Ok(x + y)
}

// With ?: exactly the same behaviour
fn sum(a: &str, b: &str) -> Result<i32, ParseIntError> {
    let x = a.parse::<i32>()?;
    let y = b.parse::<i32>()?;
    Ok(x + y)
}

fn main() {
    println!("{:?}", sum_verbose("2", "3"));
    println!("{:?}", sum("2", "3"));
    println!("{:?}", sum("2", "three"));
    println!("{:?}", "10".parse::<i32>().and_then(|n| sum(&n.to_string(), "5")));
}

use std::collections::HashMap;

fn port_for(config: &HashMap<&str, &str>, service: &str) -> Result<u16, String> {
    let raw = config
        .get(service)
        .ok_or(format!("no entry for {service}"))?;      // Option -> Result
    raw.parse::<u16>()
        .map_err(|e| format!("{service}: {raw:?} is not a port ({e})"))
}

fn first_word_len(s: &str) -> Option<usize> {
    let word = s.split_whitespace().next()?;             // ? on Option
    Some(word.len())
}

fn main() {
    let config = HashMap::from([("web", "8080"), ("db", "fivefour")]);
    for svc in ["web", "db", "cache"] {
        match port_for(&config, svc) {
            Ok(p) => println!("{svc}: {p}"),
            Err(e) => println!("error: {e}"),
        }
    }
    println!("{:?} {:?}", first_word_len("hello world"), first_word_len("   "));
    let as_option: Option<u16> = "9000".parse().ok();    // Result -> Option
    println!("{:?}", as_option);
}

use std::fmt;
use std::num::ParseIntError;

#[derive(Debug)]
enum ConfigError {
    Missing(String),
    BadNumber(ParseIntError),
    OutOfRange { key: String, value: i64 },
}

impl fmt::Display for ConfigError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            ConfigError::Missing(k) => write!(f, "missing key '{k}'"),
            ConfigError::BadNumber(e) => write!(f, "not a number: {e}"),
            ConfigError::OutOfRange { key, value } => write!(f, "{key}={value} is out of range"),
        }
    }
}

impl std::error::Error for ConfigError {}

impl From<ParseIntError> for ConfigError {       // lets ? convert automatically
    fn from(e: ParseIntError) -> Self {
        ConfigError::BadNumber(e)
    }
}

fn workers(line: Option<&str>) -> Result<i64, ConfigError> {
    let raw = line.ok_or(ConfigError::Missing(String::from("workers")))?;
    let n: i64 = raw.trim().parse()?;            // ParseIntError -> ConfigError
    if !(1..=64).contains(&n) {
        return Err(ConfigError::OutOfRange { key: String::from("workers"), value: n });
    }
    Ok(n)
}

fn main() {
    for line in [Some("8"), None, Some("lots"), Some("500")] {
        match workers(line) {
            Ok(n) => println!("workers = {n}"),
            Err(ConfigError::Missing(_)) => println!("using default 4"),
            Err(e) => println!("error: {e}"),
        }
    }
}

use std::error::Error;

fn parse_pair(s: &str) -> Result<(i32, f64), Box<dyn Error>> {
    let (a, b) = s.split_once(',').ok_or("expected two values separated by a comma")?;
    let count: i32 = a.trim().parse()?;       // ParseIntError   -> Box<dyn Error>
    let price: f64 = b.trim().parse()?;       // ParseFloatError -> Box<dyn Error>
    Ok((count, price))
}

fn main() -> Result<(), Box<dyn Error>> {
    for s in ["3, 9.5", "3 9.5", "x, 1.0", "2, cheap"] {
        match parse_pair(s) {
            Ok((c, p)) => println!("{s:?} -> {} items, total {:.2}", c, c as f64 * p),
            Err(e) => println!("{s:?} -> error: {e}"),
        }
    }
    let (c, _) = parse_pair("7, 1.0")?;       // ? works in main now
    println!("done with {c}");
    Ok(())
}

use std::io::{self, BufRead};

fn parse_line(line: &str) -> Result<(String, u32), String> {
    let (name, qty) = line
        .split_once('=')
        .ok_or(format!("missing '=' in {line:?}"))?;
    let name = name.trim();
    if name.is_empty() {
        return Err(String::from("empty name"));
    }
    let qty: u32 = qty
        .trim()
        .parse()
        .map_err(|e| format!("bad quantity for {name}: {e}"))?;
    Ok((name.to_string(), qty))
}

fn main() {
    let mut total = 0;
    let mut errors = 0;
    for (i, line) in io::stdin().lock().lines().enumerate() {
        let line = line.expect("stdin is readable");
        if line.trim().is_empty() {
            continue;
        }
        match parse_line(&line) {
            Ok((name, qty)) => {
                println!("{name}: {qty}");
                total += qty;
            }
            Err(e) => {
                println!("line {}: {e}", i + 1);
                errors += 1;
            }
        }
    }
    println!("total {total}, {errors} bad line(s)");
}