🎬 Error Handling in Rust Option, Result, the ? operator, and combinators.

📝 Text version (for readers / accessibility)

• Option represents a value that may or may not exist — Some(value) or None

• Result represents success (Ok) or failure (Err) — no exceptions needed

• The ? operator propagates errors up the call stack concisely

• Combinators like .map(), .and_then(), .unwrap_or() chain fallible operations

• The compiler forces you to handle every error case — no silent failures

047: Result Bind

Difficulty: 1 Level: Foundations Chain multiple fallible operations cleanly — stop at the first failure, with zero boilerplate.

The Problem This Solves

Real programs rarely do one thing. You parse input, divide it, check a range, verify a constraint — four steps, any of which can fail. In Python you'd write four `try/except` blocks or deeply nested `if err != None` checks. The signal (your actual business logic) gets buried in the noise (error handling). In JavaScript, Promise chaining solves this for async code: `.then().then().then()` with a single `.catch()` at the end. Each step gets the previous step's value; if any step rejects, the rest are skipped. It's clean. `and_then` (also called `bind` or `flatMap` in functional programming) brings that same clarity to synchronous Rust code. Each step in the chain only runs if the previous step succeeded. The first `Err` short-circuits everything. Your business logic reads top-to-bottom without nesting.

The Intuition

`and_then` is the answer to: "what if the next operation can also fail?" Compare:

`map(f)` — f is `T → U`, cannot fail
`and_then(f)` — f is `T → Result<U, E>`, can fail

Think of `and_then` as "if Ok, try this next thing." If it also succeeds, keep going. If it fails, stop and return that error. The chain collapses the moment anything goes wrong — no nested match, no intermediate variable checking. The `?` operator is syntactic sugar for `and_then` + early return. Both styles produce identical behavior; `?` just reads more like imperative code.

How It Works in Rust

fn parse_int(s: &str) -> Result<i64, Error> { ... }
fn safe_div(a: i64, b: i64) -> Result<i64, Error> { ... }
fn check_positive(x: i64) -> Result<i64, Error> { ... }
fn check_small(x: i64) -> Result<i64, Error> { ... }

// Style 1: and_then chain
// Each step only runs if the previous returned Ok
fn pipeline(input: &str, divisor: i64) -> Result<i64, Error> {
 parse_int(input)
     .and_then(|x| safe_div(x, divisor))  // only runs if parse succeeded
     .and_then(check_positive)              // only runs if div succeeded
     .and_then(check_small)                 // only runs if positive check passed
}

// Style 2: ? operator — equivalent, reads like normal imperative code
fn pipeline_question(input: &str, divisor: i64) -> Result<i64, Error> {
 let x = parse_int(input)?;    // if Err: return that Err immediately
 let y = safe_div(x, divisor)?;
 let z = check_positive(y)?;
 check_small(z)                 // last step: return its Result directly
}

// Both styles produce IDENTICAL results:
pipeline("100", 5)    // Ok(20) — 100/5=20, positive, small
pipeline("100", 0)    // Err(DivByZero) — stops at step 2
pipeline("-100", 5)   // Err(Negative) — stops at step 3
pipeline("5000", 1)   // Err(TooLarge) — stops at step 4
pipeline("abc", 2)    // Err(Parse(...)) — stops at step 1

What This Unlocks

Validation pipelines: Chain parse → sanitize → validate → save, all as a linear flow. The first failure wins; no need to track error state manually.
Database lookup chains: Look up a user, then their department, then their manager — each lookup can fail with "not found," and `and_then` chains them cleanly.
Protocol parsing: Read a header, then a body, then verify a checksum — structured sequential work where order matters and any step can fail.

Key Differences

Concept	OCaml	Rust
Bind operator	`>>=` (infix: `r >>= f`)	`.and_then(f)` (method)
? equivalent	`let x = r in ...` (OCaml 4.08+)	`let x = r?;`
Early exit	`match` or `let`	`?` returns from current function
Error threading	Same error type throughout	Same error type, or use `From` for conversion
Function signature	`'a result -> ('a -> 'b result) -> 'b result`	`Result<T,E>` + closure `T -> Result<U,E>`
Method vs function	`Result.bind r f`	`r.and_then(f)`

// Result Bind — 99 Problems #47
// Chain fallible computations with and_then (bind / flatMap).

#[derive(Debug, PartialEq)]
enum Error {
    Parse(String),
    DivByZero,
    Negative,
    TooLarge,
}

impl std::fmt::Display for Error {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Error::Parse(s) => write!(f, "parse error: {}", s),
            Error::DivByZero => write!(f, "division by zero"),
            Error::Negative => write!(f, "negative value"),
            Error::TooLarge => write!(f, "value too large"),
        }
    }
}

fn parse_int(s: &str) -> Result<i64, Error> {
    s.trim().parse::<i64>().map_err(|_| Error::Parse(s.to_string()))
}

fn safe_div(a: i64, b: i64) -> Result<i64, Error> {
    if b == 0 { Err(Error::DivByZero) } else { Ok(a / b) }
}

fn check_positive(x: i64) -> Result<i64, Error> {
    if x > 0 { Ok(x) } else { Err(Error::Negative) }
}

fn check_small(x: i64) -> Result<i64, Error> {
    if x < 1000 { Ok(x) } else { Err(Error::TooLarge) }
}

/// Full pipeline using and_then.
fn pipeline(input: &str, divisor: i64) -> Result<i64, Error> {
    parse_int(input)
        .and_then(|x| safe_div(x, divisor))
        .and_then(check_positive)
        .and_then(check_small)
}

/// Same using the ? operator.
fn pipeline_question(input: &str, divisor: i64) -> Result<i64, Error> {
    let x = parse_int(input)?;
    let y = safe_div(x, divisor)?;
    let z = check_positive(y)?;
    check_small(z)
}

fn main() {
    let cases = [
        ("100", 5),
        ("100", 0),
        ("-100", 5),
        ("5000", 1),
        ("abc", 2),
    ];

    for (s, d) in &cases {
        let r = pipeline(s, *d);
        println!("pipeline({:?}, {}) = {:?}", s, d, r);
    }

    println!("\n? operator version:");
    for (s, d) in &cases {
        let r = pipeline_question(s, *d);
        println!("pipeline_q({:?}, {}) = {:?}", s, d, r);
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_success() {
        assert_eq!(pipeline("100", 5), Ok(20));
    }

    #[test]
    fn test_div_zero() {
        assert_eq!(pipeline("100", 0), Err(Error::DivByZero));
    }

    #[test]
    fn test_negative_result() {
        assert_eq!(pipeline("-100", 5), Err(Error::Negative));
    }

    #[test]
    fn test_too_large() {
        assert_eq!(pipeline("5000", 1), Err(Error::TooLarge));
    }

    #[test]
    fn test_question_matches_and_then() {
        for (s, d) in [("100", 5), ("abc", 1), ("-10", 2)] {
            assert_eq!(pipeline(s, d), pipeline_question(s, d));
        }
    }
}

(* Result Bind *)
(* OCaml 99 Problems #47 *)

(* Implementation for example 47 *)

(* Tests *)
let () =
  (* Add tests *)
  print_endline "✓ OCaml tests passed"