084 Intermediate

084 — From and Into Traits

Functional Programming

Tutorial

The Problem

Implement Rust's From and TryFrom traits for type conversions: bidirectional temperature conversion between Celsius and Fahrenheit, parsing a Color from &str with TryFrom, and validating a raw user record into a typed User. Compare with OCaml's explicit named conversion functions.

🎯 Learning Outcomes

• Implement From<A> for B and gain Into<B> for A automatically

• Use TryFrom<&str> when conversion can fail, returning Result<Self, Self::Error>

• Chain map_err and ? in TryFrom implementations

• Understand the blanket impl: impl<T, U: From<T>> Into<T> for U

• Use .into() at call sites for ergonomic type conversion

• Map Rust's trait-based conversion system to OCaml's explicit function naming

Code Example

#![allow(clippy::all)]
// 084: From and Into Traits

// Approach 1: Temperature conversion
#[derive(Debug, Clone, Copy)]
struct Celsius(f64);

#[derive(Debug, Clone, Copy)]
struct Fahrenheit(f64);

impl From<Celsius> for Fahrenheit {
    fn from(c: Celsius) -> Self {
        Fahrenheit(c.0 * 9.0 / 5.0 + 32.0)
    }
}

impl From<Fahrenheit> for Celsius {
    fn from(f: Fahrenheit) -> Self {
        Celsius((f.0 - 32.0) * 5.0 / 9.0)
    }
}

// Approach 2: Enum from string (TryFrom)
#[derive(Debug, PartialEq)]
enum Color {
    Red,
    Green,
    Blue,
}

impl TryFrom<&str> for Color {
    type Error = String;
    fn try_from(s: &str) -> Result<Self, Self::Error> {
        match s {
            "red" => Ok(Color::Red),
            "green" => Ok(Color::Green),
            "blue" => Ok(Color::Blue),
            _ => Err(format!("Unknown color: {}", s)),
        }
    }
}

impl From<Color> for &str {
    fn from(c: Color) -> Self {
        match c {
            Color::Red => "red",
            Color::Green => "green",
            Color::Blue => "blue",
        }
    }
}

// Approach 3: From for complex types
struct RawUser {
    name: String,
    age: String,
    email: String,
}

#[derive(Debug, PartialEq)]
struct User {
    name: String,
    age: u32,
    email: String,
}

impl TryFrom<RawUser> for User {
    type Error = String;
    fn try_from(raw: RawUser) -> Result<Self, Self::Error> {
        let age = raw.age.parse().map_err(|_| "Invalid age".to_string())?;
        Ok(User {
            name: raw.name,
            age,
            email: raw.email,
        })
    }
}

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

    #[test]
    fn test_celsius_to_fahrenheit() {
        let f: Fahrenheit = Celsius(100.0).into();
        assert!((f.0 - 212.0).abs() < 0.001);
    }

    #[test]
    fn test_fahrenheit_to_celsius() {
        let c: Celsius = Fahrenheit(32.0).into();
        assert!(c.0.abs() < 0.001);
    }

    #[test]
    fn test_color_try_from() {
        assert_eq!(Color::try_from("red"), Ok(Color::Red));
        assert!(Color::try_from("purple").is_err());
    }

    #[test]
    fn test_user_try_from() {
        let raw = RawUser {
            name: "Alice".into(),
            age: "30".into(),
            email: "a@b.com".into(),
        };
        let user = User::try_from(raw).unwrap();
        assert_eq!(user.age, 30);
    }

    #[test]
    fn test_user_invalid() {
        let raw = RawUser {
            name: "Bob".into(),
            age: "xyz".into(),
            email: "b@c.com".into(),
        };
        assert!(User::try_from(raw).is_err());
    }
}

(* 084: From/Into — OCaml conversion functions *)

(* Approach 1: Simple conversions *)
type celsius = Celsius of float
type fahrenheit = Fahrenheit of float

let fahrenheit_of_celsius (Celsius c) = Fahrenheit (c *. 9.0 /. 5.0 +. 32.0)
let celsius_of_fahrenheit (Fahrenheit f) = Celsius ((f -. 32.0) *. 5.0 /. 9.0)

(* Approach 2: String conversions *)
type color = Red | Green | Blue

let color_of_string = function
  | "red" -> Ok Red
  | "green" -> Ok Green
  | "blue" -> Ok Blue
  | s -> Error (Printf.sprintf "Unknown color: %s" s)

let string_of_color = function
  | Red -> "red"
  | Green -> "green"
  | Blue -> "blue"

(* Approach 3: Complex record conversion *)
type raw_user = { raw_name: string; raw_age: string; raw_email: string }
type user = { name: string; age: int; email: string }

let user_of_raw raw =
  match int_of_string_opt raw.raw_age with
  | None -> Error "Invalid age"
  | Some age -> Ok { name = raw.raw_name; age; email = raw.raw_email }

(* Tests *)
let () =
  let (Fahrenheit f) = fahrenheit_of_celsius (Celsius 100.0) in
  assert (abs_float (f -. 212.0) < 0.001);
  let (Celsius c) = celsius_of_fahrenheit (Fahrenheit 32.0) in
  assert (abs_float c < 0.001);
  assert (color_of_string "red" = Ok Red);
  assert (Result.is_error (color_of_string "purple"));
  assert (string_of_color Blue = "blue");
  let raw = { raw_name = "Alice"; raw_age = "30"; raw_email = "a@b.com" } in
  assert (user_of_raw raw = Ok { name = "Alice"; age = 30; email = "a@b.com" });
  let bad = { raw_name = "Bob"; raw_age = "xyz"; raw_email = "b@c.com" } in
  assert (Result.is_error (user_of_raw bad));
  Printf.printf "✓ All tests passed\n"

Key Differences

Aspect	Rust	OCaml
Infallible	`impl From<A> for B`	`b_of_a : a -> b` function
Fallible	`impl TryFrom<A> for B`	`b_of_a : a -> ('b, err) result`
Ergonomics	`.into()` call	Explicit function call
Generic over conversion	Trait bound `From<A>`	Higher-order function parameter
Auto-blanket	`Into` from `From`	Manual
Code reuse	One `From` impl for all call sites	One function, explicit at each call

The From/Into system is one of Rust's most pervasive patterns. Standard library types extensively use it: String::from("hello"), Vec::from([1, 2, 3]), error propagation with ?. Implementing From for your types integrates them into this ecosystem.

OCaml Approach

OCaml uses plain functions: fahrenheit_of_celsius, celsius_of_fahrenheit, color_of_string, user_of_raw. There is no trait system to unify these under a single interface. Code that needs to be generic over conversions must take the conversion function as a parameter. The result type mirrors Rust: Ok and Error are standard OCaml result constructors, making Result.bind chains natural.

Full Source

#![allow(clippy::all)]
// 084: From and Into Traits

// Approach 1: Temperature conversion
#[derive(Debug, Clone, Copy)]
struct Celsius(f64);

#[derive(Debug, Clone, Copy)]
struct Fahrenheit(f64);

impl From<Celsius> for Fahrenheit {
    fn from(c: Celsius) -> Self {
        Fahrenheit(c.0 * 9.0 / 5.0 + 32.0)
    }
}

impl From<Fahrenheit> for Celsius {
    fn from(f: Fahrenheit) -> Self {
        Celsius((f.0 - 32.0) * 5.0 / 9.0)
    }
}

// Approach 2: Enum from string (TryFrom)
#[derive(Debug, PartialEq)]
enum Color {
    Red,
    Green,
    Blue,
}

impl TryFrom<&str> for Color {
    type Error = String;
    fn try_from(s: &str) -> Result<Self, Self::Error> {
        match s {
            "red" => Ok(Color::Red),
            "green" => Ok(Color::Green),
            "blue" => Ok(Color::Blue),
            _ => Err(format!("Unknown color: {}", s)),
        }
    }
}

impl From<Color> for &str {
    fn from(c: Color) -> Self {
        match c {
            Color::Red => "red",
            Color::Green => "green",
            Color::Blue => "blue",
        }
    }
}

// Approach 3: From for complex types
struct RawUser {
    name: String,
    age: String,
    email: String,
}

#[derive(Debug, PartialEq)]
struct User {
    name: String,
    age: u32,
    email: String,
}

impl TryFrom<RawUser> for User {
    type Error = String;
    fn try_from(raw: RawUser) -> Result<Self, Self::Error> {
        let age = raw.age.parse().map_err(|_| "Invalid age".to_string())?;
        Ok(User {
            name: raw.name,
            age,
            email: raw.email,
        })
    }
}

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

    #[test]
    fn test_celsius_to_fahrenheit() {
        let f: Fahrenheit = Celsius(100.0).into();
        assert!((f.0 - 212.0).abs() < 0.001);
    }

    #[test]
    fn test_fahrenheit_to_celsius() {
        let c: Celsius = Fahrenheit(32.0).into();
        assert!(c.0.abs() < 0.001);
    }

    #[test]
    fn test_color_try_from() {
        assert_eq!(Color::try_from("red"), Ok(Color::Red));
        assert!(Color::try_from("purple").is_err());
    }

    #[test]
    fn test_user_try_from() {
        let raw = RawUser {
            name: "Alice".into(),
            age: "30".into(),
            email: "a@b.com".into(),
        };
        let user = User::try_from(raw).unwrap();
        assert_eq!(user.age, 30);
    }

    #[test]
    fn test_user_invalid() {
        let raw = RawUser {
            name: "Bob".into(),
            age: "xyz".into(),
            email: "b@c.com".into(),
        };
        assert!(User::try_from(raw).is_err());
    }
}

(* 084: From/Into — OCaml conversion functions *)

(* Approach 1: Simple conversions *)
type celsius = Celsius of float
type fahrenheit = Fahrenheit of float

let fahrenheit_of_celsius (Celsius c) = Fahrenheit (c *. 9.0 /. 5.0 +. 32.0)
let celsius_of_fahrenheit (Fahrenheit f) = Celsius ((f -. 32.0) *. 5.0 /. 9.0)

(* Approach 2: String conversions *)
type color = Red | Green | Blue

let color_of_string = function
  | "red" -> Ok Red
  | "green" -> Ok Green
  | "blue" -> Ok Blue
  | s -> Error (Printf.sprintf "Unknown color: %s" s)

let string_of_color = function
  | Red -> "red"
  | Green -> "green"
  | Blue -> "blue"

(* Approach 3: Complex record conversion *)
type raw_user = { raw_name: string; raw_age: string; raw_email: string }
type user = { name: string; age: int; email: string }

let user_of_raw raw =
  match int_of_string_opt raw.raw_age with
  | None -> Error "Invalid age"
  | Some age -> Ok { name = raw.raw_name; age; email = raw.raw_email }

(* Tests *)
let () =
  let (Fahrenheit f) = fahrenheit_of_celsius (Celsius 100.0) in
  assert (abs_float (f -. 212.0) < 0.001);
  let (Celsius c) = celsius_of_fahrenheit (Fahrenheit 32.0) in
  assert (abs_float c < 0.001);
  assert (color_of_string "red" = Ok Red);
  assert (Result.is_error (color_of_string "purple"));
  assert (string_of_color Blue = "blue");
  let raw = { raw_name = "Alice"; raw_age = "30"; raw_email = "a@b.com" } in
  assert (user_of_raw raw = Ok { name = "Alice"; age = 30; email = "a@b.com" });
  let bad = { raw_name = "Bob"; raw_age = "xyz"; raw_email = "b@c.com" } in
  assert (Result.is_error (user_of_raw bad));
  Printf.printf "✓ All tests passed\n"

✓ Tests Rust test suite

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

    #[test]
    fn test_celsius_to_fahrenheit() {
        let f: Fahrenheit = Celsius(100.0).into();
        assert!((f.0 - 212.0).abs() < 0.001);
    }

    #[test]
    fn test_fahrenheit_to_celsius() {
        let c: Celsius = Fahrenheit(32.0).into();
        assert!(c.0.abs() < 0.001);
    }

    #[test]
    fn test_color_try_from() {
        assert_eq!(Color::try_from("red"), Ok(Color::Red));
        assert!(Color::try_from("purple").is_err());
    }

    #[test]
    fn test_user_try_from() {
        let raw = RawUser {
            name: "Alice".into(),
            age: "30".into(),
            email: "a@b.com".into(),
        };
        let user = User::try_from(raw).unwrap();
        assert_eq!(user.age, 30);
    }

    #[test]
    fn test_user_invalid() {
        let raw = RawUser {
            name: "Bob".into(),
            age: "xyz".into(),
            email: "b@c.com".into(),
        };
        assert!(User::try_from(raw).is_err());
    }
}

Deep Comparison

Core Insight

From<T> defines how to create a type from T. Into<T> is the reverse view. Implementing From auto-provides Into. This replaces ad-hoc conversion functions with a unified protocol.

OCaml Approach

• Manual conversion functions: int_of_float, string_of_int

• No unified conversion trait

• Module-level of_* / to_* conventions

Rust Approach

• impl From<Source> for Target

• Into comes free via blanket impl

• .into() for ergonomic conversion

• TryFrom/TryInto for fallible conversions

Comparison Table

Feature	OCaml	Rust
Conversion	`of_string`, `to_int` functions	`From`/`Into` traits
Infallible	Manual function	`From`/`Into`
Fallible	Return `option`/`result`	`TryFrom`/`TryInto`
Auto	No	`Into` from `From`

Exercises

Add impl From<i32> for Color that maps 0 → Red, 1 → Green, 2 → Blue and panics otherwise. Then add TryFrom<i32> that returns Err instead of panicking.

Implement From<Vec<(String, i32)>> for a HashMap<String, i32>.

Write a Validated<T> newtype that wraps T and implement TryFrom<String> for Validated<Email> where Email is another newtype.

Create a conversion chain: RawConfig → ParsedConfig → ValidatedConfig, each step using TryFrom.

In OCaml, write a convert functor Convert(S : sig type t end)(D : sig type t val of_s : S.t -> D.t end) and show how it compares to Rust's impl From<S> for D.

Open Source Repos

functional-rust

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

Rust