[Idioms/Constructors] use From to implement constructors

[wookietreiber]

In Rust we have the std::convert::From trait. This trait can be used to effectively write constructors, while additionally having the benefit of having a From implementation, as well as the corresponding Into blanket implementation.

struct Foo {
    a: i64,
}

impl From<i64> for Foo {
    fn from(a: i64) -> Self {
        Self { a }
    }
}

fn main() {
    let foo = Foo::from(42);
}

What do you think, should this be added to the constructors section?

---

Same reasoning with std::convert::TryFrom for fallible constructors.

[neithernut]

Imo, implementing From for a type only makes sense if it's a conversion, semantically. That's not necessarily the case for some struct with a single element.

On that note, I often find myself implementing From for enums which serve as a variation point for different item types, e.g.:

Value {
    Int(i64),
    Float(f64),
    String(String),
}

impl From<i64> for Var {
    fn from(v: i64) -> Self {
        Self::Int(v)
    }
}

impl From<f64> for Var {
    fn from(v: f64) -> Self {
        Self::Float(v)
    }
}

impl From<String> for Var {
    fn from(v: String) -> Self {
        Self::String(v)
    }
}