Used to do value-to-value conversions while consuming the input value. It is the reciprocal ofInto.

One should always prefer implementingFrom overIntobecause implementingFrom automatically provides one with an implementation ofIntothanks to the blanket implementation in the standard library.

Only implementInto when targeting a version prior to Rust 1.41 and converting to a typeoutside the current crate.From was not able to do these types of conversions in earlier versions because of Rust’sorphaning rules.SeeInto for more details.

Prefer usingInto overFrom when specifying trait bounds on a generic functionto ensure that types that only implementInto can be used as well.

TheFrom trait is also very useful when performing error handling. When constructing a functionthat is capable of failing, the return type will generally be of the formResult<T, E>.From simplifies error handling by allowing a function to return a single error typethat encapsulates multiple error types. See the “Examples” section andthe book for moredetails.

Note: This trait must not fail. TheFrom trait is intended for perfect conversions.If the conversion can fail or is not perfect, useTryFrom.

§Generic Implementations

• From<T> for U impliesInto<U> for T
• From is reflexive, which means thatFrom<T> for T is implemented

§When to implementFrom

While there’s no technical restrictions on which conversions can be done usingaFrom implementation, the general expectation is that the conversionsshould typically be restricted as follows:

• The conversion isinfallible: if the conversion can fail, useTryFrominstead; don’t provide aFrom impl that panics.

• The conversion islossless: semantically, it should not lose or discardinformation. For example,i32: From<u16> exists, where the originalvalue can be recovered usingu16: TryFrom<i32>. AndString: From<&str>exists, where you can get something equivalent to the original value viaDeref. ButFrom cannot be used to convert fromu32 tou16, sincethat cannot succeed in a lossless way. (There’s some wiggle room here forinformation not considered semantically relevant. For example,Box<[T]>: From<Vec<T>> exists even though it might not preserve capacity,like how two vectors can be equal despite differing capacities.)

• The conversion isvalue-preserving: the conceptual kind and meaning ofthe resulting value is the same, even though the Rust type and technicalrepresentation might be different. For example-1_i8 as u8 islossless,sinceas casting back can recover the original value, but that conversionisnot available viaFrom because-1 and255 are different conceptualvalues (despite being identical bit patterns technically). Butf32: From<i16>is available because1_i16 and1.0_f32 are conceptuallythe same real number (despite having very different bit patterns technically).String: From<char> is available because they’re bothtext, butString: From<u32> isnot available, since1 (a number) and"1"(text) are too different. (Converting values to text is instead coveredby theDisplay trait.)

• The conversion isobvious: it’s the only reasonable conversion betweenthe two types. Otherwise it’s better to have it be a named method orconstructor, like howstr::as_bytes is a method and how integers havemethods likeu32::from_ne_bytes,u32::from_le_bytes, andu32::from_be_bytes, none of which areFrom implementations. Whereasthere’s only one reasonable way to wrap anIpv6Addrinto anIpAddr, thusIpAddr: From<Ipv6Addr> exists.

§Examples

String implementsFrom<&str>:

An explicit conversion from a&str to a String is done as follows:

letstring ="hello".to_string();letother_string = String::from("hello");assert_eq!(string, other_string);

While performing error handling it is often useful to implementFrom for your own error type.By converting underlying error types to our own custom error type that encapsulates theunderlying error type, we can return a single error type without losing information on theunderlying cause. The ‘?’ operator automatically converts the underlying error type to ourcustom error type withFrom::from.

usestd::fs;usestd::io;usestd::num;enumCliError {    IoError(io::Error),    ParseError(num::ParseIntError),}implFrom<io::Error>forCliError {fnfrom(error: io::Error) ->Self{        CliError::IoError(error)    }}implFrom<num::ParseIntError>forCliError {fnfrom(error: num::ParseIntError) ->Self{        CliError::ParseError(error)    }}fnopen_and_parse_file(file_name:&str) ->Result<i32, CliError> {letmutcontents = fs::read_to_string(&file_name)?;letnum: i32 = contents.trim().parse()?;Ok(num)}