From/Into & TryFrom

Implement From and TryFrom for explicit, discoverable conversions between types. Prefer these over ad-hoc as casts and constructor naming soup.

Recipe

impl From<u64> for UserId {
    fn from(id: u64) -> Self { UserId(id) }
}
let id: UserId = 42.into();
 
impl TryFrom<String> for Email {
    type Error = ParseError;
    fn try_from(s: String) -> Result<Self, Self::Error> { Email::parse(s) }
}

When to reach for this: Boundary conversions, newtypes, parsing external input.

Working Example

struct Meters(f64);
struct Feet(f64);
 
impl From<Feet> for Meters {
    fn from(f: Feet) -> Self { Meters(f.0 * 0.3048) }
}
 
impl TryFrom<&str> for UserId {
    type Error = std::num::ParseIntError;
    fn try_from(s: &str) -> Result<Self, Self::Error> {
        Ok(UserId(s.parse()?))
    }
}

What this demonstrates:

• Into auto-implemented when From exists
• Fallible parsing uses TryFrom + ?
• Conversions are symmetric and grep-friendly
• API guidelines prefer From over into_foo methods

Deep Dive

Implement From on destination type. Chain with ? in handlers: let id = UserId::try_from(path_segment)?;. Avoid From that can fail; use TryFrom instead.

Gotchas

• Lossy From - silent truncation. Fix: only infallible conversions in From; use TryFrom for validation.
• From recursion - infinite loop. Fix: one direction only or distinct types.
• Orphan rule - cannot impl From<Foreign> for Foreign. Fix: newtype wrapper.
• Ambiguous Into - multiple targets. Fix: use turbofish UserId::from(x).
• as casts for enums - unsafe for values. Fix: TryFrom<u8> for wire formats.

Alternatives

FAQs

Related

• The Newtype Pattern - distinct types
• Rust API Guidelines
• Parsing and Conversion
• Error-Handling Rules

Stack versions: This page was written for Rust 1.97.0 (edition 2024), Tokio 1.x, Axum 0.8, serde 1.0, sqlx 0.8, clap 4, and Polars 0.46+.