1007 Intermediate

1007-result-combinators — Result Combinators

Functional Programming

Tutorial

The Problem

Chaining fallible operations without deeply nested pattern matches is a core challenge in error-handling design. In C, every call site checks a return code, creating pyramids of conditionals. Haskell's Either monad and OCaml's Result type both solve this by providing combinators that thread success values through a pipeline while propagating errors automatically.

Rust's Result<T, E> ships with a rich set of combinators: map, and_then, map_err, or_else, and unwrap_or_else. These methods let you compose fallible computations as cleanly as iterator chains, desugaring to the same match logic you would write by hand.

🎯 Learning Outcomes

• Understand how and_then implements monadic bind (flatmap) for Result

• Apply map to transform success values without unwrapping

• Use map_err to convert or annotate error types

• Chain or_else to substitute a fallback Result on failure

• Replace explicit match blocks with expressive combinator pipelines

Code Example

#![allow(clippy::all)]
// 1007: Result Combinators
// and_then, or_else, map, map_err, unwrap_or_else

fn parse_int(s: &str) -> Result<i64, String> {
    s.parse::<i64>()
        .map_err(|e| format!("not an int: {} ({})", s, e))
}

fn double_if_positive(n: i64) -> Result<i64, String> {
    if n > 0 {
        Ok(n * 2)
    } else {
        Err("must be positive".into())
    }
}

// Approach 1: Chaining with and_then (flatmap/bind)
fn process_chain(s: &str) -> Result<String, String> {
    parse_int(s)
        .and_then(double_if_positive)
        .map(|n| n.to_string())
}

// Approach 2: Using map, map_err, or_else, unwrap_or_else
fn process_with_fallback(s: &str) -> String {
    parse_int(s)
        .and_then(double_if_positive)
        .map(|n| n.to_string())
        .map_err(|e| format!("FALLBACK: {}", e))
        .unwrap_or_else(|e| e)
}

fn process_or_else(s: &str) -> Result<i64, String> {
    parse_int(s).and_then(double_if_positive).or_else(|_| Ok(0)) // fallback to 0 on any error
}

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

    #[test]
    fn test_and_then_success() {
        assert_eq!(process_chain("5"), Ok("10".to_string()));
    }

    #[test]
    fn test_and_then_negative() {
        assert_eq!(process_chain("-3"), Err("must be positive".to_string()));
    }

    #[test]
    fn test_and_then_parse_fail() {
        assert!(process_chain("abc").is_err());
    }

    #[test]
    fn test_map() {
        let result: Result<i64, String> = Ok(5);
        assert_eq!(result.map(|n| n * 2), Ok(10));
    }

    #[test]
    fn test_map_err() {
        let result: Result<i64, &str> = Err("low");
        assert_eq!(result.map_err(|e| e.to_uppercase()), Err("LOW".to_string()));
    }

    #[test]
    fn test_or_else() {
        assert_eq!(process_or_else("-1"), Ok(0));
        assert_eq!(process_or_else("5"), Ok(10));
    }

    #[test]
    fn test_unwrap_or_else() {
        let result: Result<i64, String> = Err("fail".into());
        assert_eq!(result.unwrap_or_else(|_| 99), 99);

        let result: Result<i64, String> = Ok(42);
        assert_eq!(result.unwrap_or_else(|_| 99), 42);
    }

    #[test]
    fn test_fallback_string() {
        assert_eq!(process_with_fallback("5"), "10");
        assert!(process_with_fallback("abc").starts_with("FALLBACK"));
    }
}

(* 1007: Result Combinators *)
(* Functional transforms on Result values *)

(* OCaml Result module combinators *)
let map f = function Ok v -> Ok (f v) | Error e -> Error e
let map_error f = function Ok v -> Ok v | Error e -> Error (f e)
let bind f = function Ok v -> f v | Error e -> Error e  (* and_then *)

(* Approach 1: Manual pattern matching *)
let parse_int s =
  match int_of_string_opt s with
  | Some n -> Ok n
  | None -> Error (Printf.sprintf "not an int: %s" s)

let double_if_positive n =
  if n > 0 then Ok (n * 2)
  else Error "must be positive"

let process_manual s =
  match parse_int s with
  | Error e -> Error e
  | Ok n ->
    match double_if_positive n with
    | Error e -> Error e
    | Ok v -> Ok (string_of_int v)

(* Approach 2: Using combinators *)
let process_combinators s =
  parse_int s
  |> bind double_if_positive
  |> map string_of_int

(* or_else equivalent *)
let or_else f = function
  | Ok v -> Ok v
  | Error e -> f e

let with_default default = function
  | Ok v -> v
  | Error _ -> default

let test_manual () =
  assert (process_manual "5" = Ok "10");
  assert (process_manual "-3" = Error "must be positive");
  assert (process_manual "abc" = Error "not an int: abc");
  Printf.printf "  Approach 1 (manual matching): passed\n"

let test_combinators () =
  assert (process_combinators "5" = Ok "10");
  assert (process_combinators "-3" = Error "must be positive");
  (* map_error *)
  let r = map_error String.uppercase_ascii (Error "low") in
  assert (r = Error "LOW");
  (* or_else *)
  let r = or_else (fun _ -> Ok 0) (Error "fail") in
  assert (r = Ok 0);
  (* unwrap_or / with_default *)
  assert (with_default 99 (Error "fail") = 99);
  assert (with_default 99 (Ok 42) = 42);
  Printf.printf "  Approach 2 (combinators): passed\n"

let () =
  Printf.printf "Testing result combinators:\n";
  test_manual ();
  test_combinators ();
  Printf.printf "✓ All tests passed\n"

Key Differences

Method vs function syntax: Rust uses result.and_then(f) method chaining; OCaml uses Result.bind f result piped with |>.

Error type unification: Rust requires both branches of and_then to share the same E type; OCaml is structurally typed and more flexible.

**From conversion**: Rust's ? auto-converts error types via From; OCaml combinators require explicit Result.map_error for type adaptation.

Ownership: Rust combinators consume the Result value by move; OCaml passes values through the GC with no ownership concern.

OCaml Approach

OCaml's Result module provides Result.map, Result.bind (equivalent to and_then), and Result.map_error. The |> pipeline operator makes chaining natural:

let process s =
  parse_int s
  |> Result.bind double_if_positive
  |> Result.map string_of_int

OCaml expresses combinators as regular functions passed via |>, while Rust uses method chaining on the Result value.

Full Source

#![allow(clippy::all)]
// 1007: Result Combinators
// and_then, or_else, map, map_err, unwrap_or_else

fn parse_int(s: &str) -> Result<i64, String> {
    s.parse::<i64>()
        .map_err(|e| format!("not an int: {} ({})", s, e))
}

fn double_if_positive(n: i64) -> Result<i64, String> {
    if n > 0 {
        Ok(n * 2)
    } else {
        Err("must be positive".into())
    }
}

// Approach 1: Chaining with and_then (flatmap/bind)
fn process_chain(s: &str) -> Result<String, String> {
    parse_int(s)
        .and_then(double_if_positive)
        .map(|n| n.to_string())
}

// Approach 2: Using map, map_err, or_else, unwrap_or_else
fn process_with_fallback(s: &str) -> String {
    parse_int(s)
        .and_then(double_if_positive)
        .map(|n| n.to_string())
        .map_err(|e| format!("FALLBACK: {}", e))
        .unwrap_or_else(|e| e)
}

fn process_or_else(s: &str) -> Result<i64, String> {
    parse_int(s).and_then(double_if_positive).or_else(|_| Ok(0)) // fallback to 0 on any error
}

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

    #[test]
    fn test_and_then_success() {
        assert_eq!(process_chain("5"), Ok("10".to_string()));
    }

    #[test]
    fn test_and_then_negative() {
        assert_eq!(process_chain("-3"), Err("must be positive".to_string()));
    }

    #[test]
    fn test_and_then_parse_fail() {
        assert!(process_chain("abc").is_err());
    }

    #[test]
    fn test_map() {
        let result: Result<i64, String> = Ok(5);
        assert_eq!(result.map(|n| n * 2), Ok(10));
    }

    #[test]
    fn test_map_err() {
        let result: Result<i64, &str> = Err("low");
        assert_eq!(result.map_err(|e| e.to_uppercase()), Err("LOW".to_string()));
    }

    #[test]
    fn test_or_else() {
        assert_eq!(process_or_else("-1"), Ok(0));
        assert_eq!(process_or_else("5"), Ok(10));
    }

    #[test]
    fn test_unwrap_or_else() {
        let result: Result<i64, String> = Err("fail".into());
        assert_eq!(result.unwrap_or_else(|_| 99), 99);

        let result: Result<i64, String> = Ok(42);
        assert_eq!(result.unwrap_or_else(|_| 99), 42);
    }

    #[test]
    fn test_fallback_string() {
        assert_eq!(process_with_fallback("5"), "10");
        assert!(process_with_fallback("abc").starts_with("FALLBACK"));
    }
}

(* 1007: Result Combinators *)
(* Functional transforms on Result values *)

(* OCaml Result module combinators *)
let map f = function Ok v -> Ok (f v) | Error e -> Error e
let map_error f = function Ok v -> Ok v | Error e -> Error (f e)
let bind f = function Ok v -> f v | Error e -> Error e  (* and_then *)

(* Approach 1: Manual pattern matching *)
let parse_int s =
  match int_of_string_opt s with
  | Some n -> Ok n
  | None -> Error (Printf.sprintf "not an int: %s" s)

let double_if_positive n =
  if n > 0 then Ok (n * 2)
  else Error "must be positive"

let process_manual s =
  match parse_int s with
  | Error e -> Error e
  | Ok n ->
    match double_if_positive n with
    | Error e -> Error e
    | Ok v -> Ok (string_of_int v)

(* Approach 2: Using combinators *)
let process_combinators s =
  parse_int s
  |> bind double_if_positive
  |> map string_of_int

(* or_else equivalent *)
let or_else f = function
  | Ok v -> Ok v
  | Error e -> f e

let with_default default = function
  | Ok v -> v
  | Error _ -> default

let test_manual () =
  assert (process_manual "5" = Ok "10");
  assert (process_manual "-3" = Error "must be positive");
  assert (process_manual "abc" = Error "not an int: abc");
  Printf.printf "  Approach 1 (manual matching): passed\n"

let test_combinators () =
  assert (process_combinators "5" = Ok "10");
  assert (process_combinators "-3" = Error "must be positive");
  (* map_error *)
  let r = map_error String.uppercase_ascii (Error "low") in
  assert (r = Error "LOW");
  (* or_else *)
  let r = or_else (fun _ -> Ok 0) (Error "fail") in
  assert (r = Ok 0);
  (* unwrap_or / with_default *)
  assert (with_default 99 (Error "fail") = 99);
  assert (with_default 99 (Ok 42) = 42);
  Printf.printf "  Approach 2 (combinators): passed\n"

let () =
  Printf.printf "Testing result combinators:\n";
  test_manual ();
  test_combinators ();
  Printf.printf "✓ All tests passed\n"

✓ Tests Rust test suite

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

    #[test]
    fn test_and_then_success() {
        assert_eq!(process_chain("5"), Ok("10".to_string()));
    }

    #[test]
    fn test_and_then_negative() {
        assert_eq!(process_chain("-3"), Err("must be positive".to_string()));
    }

    #[test]
    fn test_and_then_parse_fail() {
        assert!(process_chain("abc").is_err());
    }

    #[test]
    fn test_map() {
        let result: Result<i64, String> = Ok(5);
        assert_eq!(result.map(|n| n * 2), Ok(10));
    }

    #[test]
    fn test_map_err() {
        let result: Result<i64, &str> = Err("low");
        assert_eq!(result.map_err(|e| e.to_uppercase()), Err("LOW".to_string()));
    }

    #[test]
    fn test_or_else() {
        assert_eq!(process_or_else("-1"), Ok(0));
        assert_eq!(process_or_else("5"), Ok(10));
    }

    #[test]
    fn test_unwrap_or_else() {
        let result: Result<i64, String> = Err("fail".into());
        assert_eq!(result.unwrap_or_else(|_| 99), 99);

        let result: Result<i64, String> = Ok(42);
        assert_eq!(result.unwrap_or_else(|_| 99), 42);
    }

    #[test]
    fn test_fallback_string() {
        assert_eq!(process_with_fallback("5"), "10");
        assert!(process_with_fallback("abc").starts_with("FALLBACK"));
    }
}

Deep Comparison

Result Combinators — Comparison

Core Insight

Both OCaml and Rust treat Result as a monad with map (functor) and bind/and_then (monadic bind). Rust adds more built-in combinators.

OCaml Approach

• Result.map, Result.bind in stdlib (OCaml 4.08+)

• Custom map_error, or_else typically hand-written

• Pipeline via |> operator

• Option.value ~default for unwrap-with-default

Rust Approach

• Rich built-in: map, map_err, and_then, or_else, unwrap_or_else, unwrap_or_default

• Method chaining with . notation

• ? operator as syntactic sugar for and_then + early return

• ok(), err() to convert between Result and Option

Comparison Table

Combinator	OCaml	Rust
map	`Result.map f r`	`r.map(f)`
flatmap/bind	`Result.bind r f`	`r.and_then(f)`
map error	custom `map_error`	`r.map_err(f)`
fallback	custom `or_else`	`r.or_else(f)`
default	`Result.value r ~default`	`r.unwrap_or(v)`
lazy default	custom	`r.unwrap_or_else(f)`

Exercises

Add a clamp_to_range(n: i64, min: i64, max: i64) -> Result<i64, String> function and insert it into process_chain between parsing and doubling.

Rewrite process_with_fallback using the ? operator inside a helper function instead of combinator chaining. Verify all tests still pass.

Implement a map2 function that takes two Result<T, E> values and a combining function, returning Result<U, E>. Use it to add two parsed integers.

Open Source Repos

functional-rust

View the source for this example on GitHub — OCaml and Rust side by side in the repo.

Rust