Rust by Example - страница 15
>
>let my_string = String::from(my_str);
>}
We can do similar for defining a conversion for our own type.
>use std::convert::From;
>#[derive(Debug)]
>struct Number {
>value: i32,
>}
>impl From
>fn from(item: i32) -> Self {
>Number { value: item }
>}
>}
>fn main() {
>let num = Number::from(30);
>println!("My number is {:?}", num);
>}
>הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
>XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
The Into trait is simply the reciprocal of the From trait. That is, if you have implemented the From trait for your type, Into will call it when necessary.
Using the Into trait will typically require specification of the type to convert into as the compiler is unable to determine this most of the time. However this is a small trade-off considering we get the functionality for free.
>use std::convert::From;
>#[derive(Debug)]
>struct Number {
>value: i32,
>}
>impl From
>fn from(item: i32) -> Self {
>Number { value: item }
>}
>}
>fn main() {
>let int = 5;
>// Try removing the type declaration
>let num: Number = int.into();
>println!("My number is {:?}", num);
>}
>הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
>XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
Similar to FromandInto, TryFrom and TryInto are generic traits for converting between types. Unlike From/Into, the TryFrom/TryInto traits are used for fallible conversions, and as such, return Results.
>use std::convert::TryFrom;
>use std::convert::TryInto;
>#[derive(Debug, PartialEq)]
>struct EvenNumber(i32);
>impl TryFrom
>type Error = ();
>fn try_from(value: i32) -> Result
>if value % 2 == 0 {
>Ok(EvenNumber(value))
>} else {
>Err(())
>}
>}
>}
>fn main() {
>// TryFrom
>assert_eq!(EvenNumber::try_from(8), Ok(EvenNumber(8)));
>assert_eq!(EvenNumber::try_from(5), Err(()));
>// TryInto
>let result: Result
>assert_eq!(result, Ok(EvenNumber(8)));
>let result: Result
>assert_eq!(result, Err(()));
>}
>הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
>XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
To convert any type to a String is as simple as implementing the ToString trait for the type. Rather than doing so directly, you should implement the fmt::Display trait which automagically provides ToString and also allows printing the type as discussed in the section on print!.
>use std::fmt;
>struct Circle {
>radius: i32
>}
>impl fmt::Display for Circle {
>fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
>write!(f, "Circle of radius {}", self.radius)
>}
>}
>fn main() {
>let circle = Circle { radius: 6 };
>println!("{}", circle.to_string());
>}
>הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה