Trait signature_core::lib::From 1.0.0[−][src]
pub trait From<T> { fn from(T) -> Self; }
Expand description
Used to do value-to-value conversions while consuming the input value. It is the reciprocal of
Into
.
One should always prefer implementing From
over Into
because implementing From
automatically provides one with an implementation of Into
thanks to the blanket implementation in the standard library.
Only implement Into
when targeting a version prior to Rust 1.41 and converting to a type
outside the current crate.
From
was not able to do these types of conversions in earlier versions because of Rust’s
orphaning rules.
See Into
for more details.
Prefer using Into
over using From
when specifying trait bounds on a generic function.
This way, types that directly implement Into
can be used as arguments as well.
The From
is also very useful when performing error handling. When constructing a function
that is capable of failing, the return type will generally be of the form Result<T, E>
.
The From
trait simplifies error handling by allowing a function to return a single error type
that encapsulate multiple error types. See the “Examples” section and the book for more
details.
Note: This trait must not fail. If the conversion can fail, use TryFrom
.
Generic Implementations
From<T> for U
impliesInto
<U> for T
From
is reflexive, which means thatFrom<T> for T
is implemented
Examples
String
implements From<&str>
:
An explicit conversion from a &str
to a String is done as follows:
let string = "hello".to_string(); let other_string = String::from("hello"); assert_eq!(string, other_string);
While performing error handling it is often useful to implement From
for your own error type.
By converting underlying error types to our own custom error type that encapsulates the
underlying error type, we can return a single error type without losing information on the
underlying cause. The ‘?’ operator automatically converts the underlying error type to our
custom error type by calling Into<CliError>::into
which is automatically provided when
implementing From
. The compiler then infers which implementation of Into
should be used.
use std::fs; use std::io; use std::num; enum CliError { IoError(io::Error), ParseError(num::ParseIntError), } impl From<io::Error> for CliError { fn from(error: io::Error) -> Self { CliError::IoError(error) } } impl From<num::ParseIntError> for CliError { fn from(error: num::ParseIntError) -> Self { CliError::ParseError(error) } } fn open_and_parse_file(file_name: &str) -> Result<i32, CliError> { let mut contents = fs::read_to_string(&file_name)?; let num: i32 = contents.trim().parse()?; Ok(num) }
Required methods
Implementations on Foreign Types
Converts a NonZeroIsize
into an isize
Converts a NonZeroI16
into an i16
Converts a bool
into an AtomicBool
.
Examples
use std::sync::atomic::AtomicBool; let atomic_bool = AtomicBool::from(true); assert_eq!(format!("{:?}", atomic_bool), "true")
Converts a NonZeroU32
into an u32
Maps a byte in 0x00..=0xFF to a char
whose code point has the same value, in U+0000..=U+00FF.
Unicode is designed such that this effectively decodes bytes with the character encoding that IANA calls ISO-8859-1. This encoding is compatible with ASCII.
Note that this is different from ISO/IEC 8859-1 a.k.a. ISO 8859-1 (with one less hyphen), which leaves some “blanks”, byte values that are not assigned to any character. ISO-8859-1 (the IANA one) assigns them to the C0 and C1 control codes.
Note that this is also different from Windows-1252 a.k.a. code page 1252, which is a superset ISO/IEC 8859-1 that assigns some (not all!) blanks to punctuation and various Latin characters.
To confuse things further, on the Web
ascii
, iso-8859-1
, and windows-1252
are all aliases
for a superset of Windows-1252 that fills the remaining blanks with corresponding
C0 and C1 control codes.
Converts an usize
into an AtomicUsize
.
Converts a NonZeroU128
into an u128
Converts a NonZeroU16
into an u16
Converts a NonZeroU64
into an u64
Converts a NonZeroI32
into an i32
Converts an isize
into an AtomicIsize
.
Converts a NonZeroI64
into an i64
Converts a NonZeroI128
into an i128
Converts a NonZeroUsize
into an usize
Converts a SocketAddrV4
into a SocketAddr::V4
.
Converts a SendError<T>
into a TrySendError<T>
.
This conversion always returns a TrySendError::Disconnected
containing the data in the SendError<T>
.
No data is allocated on the heap.
Creates a new instance of an RwLock<T>
which is unlocked.
This is equivalent to RwLock::new
.
Converts a [String
] into a box of dyn Error
+ Send
+ Sync
.
Examples
use std::error::Error; use std::mem; let a_string_error = "a string error".to_string(); let a_boxed_error = Box::<dyn Error + Send + Sync>::from(a_string_error); assert!( mem::size_of::<Box<dyn Error + Send + Sync>>() == mem::size_of_val(&a_boxed_error))
Converts a ChildStdin
into a Stdio
Examples
ChildStdin
will be converted to Stdio
using Stdio::from
under the hood.
use std::process::{Command, Stdio}; let reverse = Command::new("rev") .stdin(Stdio::piped()) .spawn() .expect("failed reverse command"); let _echo = Command::new("echo") .arg("Hello, world!") .stdout(reverse.stdin.unwrap()) // Converted into a Stdio here .output() .expect("failed echo command"); // "!dlrow ,olleH" echoed to console
Creates an Ipv6Addr
from an eight element 16-bit array.
Examples
use std::net::Ipv6Addr; let addr = Ipv6Addr::from([ 525u16, 524u16, 523u16, 522u16, 521u16, 520u16, 519u16, 518u16, ]); assert_eq!( Ipv6Addr::new( 0x20d, 0x20c, 0x20b, 0x20a, 0x209, 0x208, 0x207, 0x206 ), addr );
Converts a File
into a Stdio
Examples
File
will be converted to Stdio
using Stdio::from
under the hood.
use std::fs::File; use std::process::Command; // With the `foo.txt` file containing `Hello, world!" let file = File::open("foo.txt").unwrap(); let reverse = Command::new("rev") .stdin(file) // Implicit File conversion into a Stdio .output() .expect("failed reverse command"); assert_eq!(reverse.stdout, b"!dlrow ,olleH");
Creates an IpAddr::V6
from an eight element 16-bit array.
Examples
use std::net::{IpAddr, Ipv6Addr}; let addr = IpAddr::from([ 525u16, 524u16, 523u16, 522u16, 521u16, 520u16, 519u16, 518u16, ]); assert_eq!( IpAddr::V6(Ipv6Addr::new( 0x20d, 0x20c, 0x20b, 0x20a, 0x209, 0x208, 0x207, 0x206 )), addr );
Creates a boxed Path
from a clone-on-write pointer.
Converting from a Cow::Owned
does not clone or allocate.
Converts a PathBuf
into a Box<Path>
This conversion currently should not allocate memory, but this behavior is not guaranteed on all platforms or in all future versions.
Converts a Cow
into a box of dyn Error
+ Send
+ Sync
.
Examples
use std::error::Error; use std::mem; use std::borrow::Cow; let a_cow_str_error = Cow::from("a str error"); let a_boxed_error = Box::<dyn Error + Send + Sync>::from(a_cow_str_error); assert!( mem::size_of::<Box<dyn Error + Send + Sync>>() == mem::size_of_val(&a_boxed_error))
Converts a RecvError
into a RecvTimeoutError
.
This conversion always returns RecvTimeoutError::Disconnected
.
No data is allocated on the heap.
Converts a RecvError
into a TryRecvError
.
This conversion always returns TryRecvError::Disconnected
.
No data is allocated on the heap.
Converts a type of Error
+ Send
+ Sync
into a box of
dyn Error
+ Send
+ Sync
.
Examples
use std::error::Error; use std::fmt; use std::mem; #[derive(Debug)] struct AnError; impl fmt::Display for AnError { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f , "An error") } } impl Error for AnError {} unsafe impl Send for AnError {} unsafe impl Sync for AnError {} let an_error = AnError; assert!(0 == mem::size_of_val(&an_error)); let a_boxed_error = Box::<dyn Error + Send + Sync>::from(an_error); assert!( mem::size_of::<Box<dyn Error + Send + Sync>>() == mem::size_of_val(&a_boxed_error))
Converts a ChildStdout
into a Stdio
Examples
ChildStdout
will be converted to Stdio
using Stdio::from
under the hood.
use std::process::{Command, Stdio}; let hello = Command::new("echo") .arg("Hello, world!") .stdout(Stdio::piped()) .spawn() .expect("failed echo command"); let reverse = Command::new("rev") .stdin(hello.stdout.unwrap()) // Converted into a Stdio here .output() .expect("failed reverse command"); assert_eq!(reverse.stdout, b"!dlrow ,olleH\n");
Converts a type of Error
into a box of dyn Error
.
Examples
use std::error::Error; use std::fmt; use std::mem; #[derive(Debug)] struct AnError; impl fmt::Display for AnError { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f , "An error") } } impl Error for AnError {} let an_error = AnError; assert!(0 == mem::size_of_val(&an_error)); let a_boxed_error = Box::<dyn Error>::from(an_error); assert!(mem::size_of::<Box<dyn Error>>() == mem::size_of_val(&a_boxed_error))
Converts a ChildStderr
into a Stdio
Examples
use std::process::{Command, Stdio}; let reverse = Command::new("rev") .arg("non_existing_file.txt") .stderr(Stdio::piped()) .spawn() .expect("failed reverse command"); let cat = Command::new("cat") .arg("-") .stdin(reverse.stderr.unwrap()) // Converted into a Stdio here .output() .expect("failed echo command"); assert_eq!( String::from_utf8_lossy(&cat.stdout), "rev: cannot open non_existing_file.txt: No such file or directory\n" );
Creates an IpAddr::V6
from a sixteen element byte array.
Examples
use std::net::{IpAddr, Ipv6Addr}; let addr = IpAddr::from([ 25u8, 24u8, 23u8, 22u8, 21u8, 20u8, 19u8, 18u8, 17u8, 16u8, 15u8, 14u8, 13u8, 12u8, 11u8, 10u8, ]); assert_eq!( IpAddr::V6(Ipv6Addr::new( 0x1918, 0x1716, 0x1514, 0x1312, 0x1110, 0x0f0e, 0x0d0c, 0x0b0a )), addr );
Converts a tuple struct (Into<IpAddr
>, u16
) into a SocketAddr
.
This conversion creates a SocketAddr::V4
for a IpAddr::V4
and creates a SocketAddr::V6
for a IpAddr::V6
.
u16
is treated as port of the newly created SocketAddr
.
Converts a SocketAddrV6
into a SocketAddr::V6
.
Creates an Ipv6Addr
from a sixteen element byte array.
Examples
use std::net::Ipv6Addr; let addr = Ipv6Addr::from([ 25u8, 24u8, 23u8, 22u8, 21u8, 20u8, 19u8, 18u8, 17u8, 16u8, 15u8, 14u8, 13u8, 12u8, 11u8, 10u8, ]); assert_eq!( Ipv6Addr::new( 0x1918, 0x1716, 0x1514, 0x1312, 0x1110, 0x0f0e, 0x0d0c, 0x0b0a ), addr );
Intended for use for errors not exposed to the user, where allocating onto the heap (for normal construction via Error::new) is too costly.
Creates a new mutex in an unlocked state ready for use.
This is equivalent to Mutex::new
.
Always evaluates to TryReserveError::CapacityOverflow
.
Converts a clone-on-write string to an owned
instance of String
.
This extracts the owned string, clones the string if it is not already owned.
Example
// If the string is not owned... let cow: Cow<str> = Cow::Borrowed("eggplant"); // It will allocate on the heap and copy the string. let owned: String = String::from(cow); assert_eq!(&owned[..], "eggplant");
Convert a clone-on-write slice into a vector.
If s
already owns a Vec<T>
, it will be returned directly.
If s
is borrowing a slice, a new Vec<T>
will be allocated and
filled by cloning s
’s items into it.
Examples
let o: Cow<[i32]> = Cow::Owned(vec![1, 2, 3]); let b: Cow<[i32]> = Cow::Borrowed(&[1, 2, 3]); assert_eq!(Vec::from(o), Vec::from(b));
Converts a &str
into a Box<str>
This conversion allocates on the heap
and performs a copy of s
.
Examples
let boxed: Box<str> = Box::from("hello"); println!("{}", boxed);
Turn a VecDeque<T>
into a Vec<T>
.
This never needs to re-allocate, but does need to do O(n) data movement if the circular buffer doesn’t happen to be at the beginning of the allocation.
Examples
use std::collections::VecDeque; // This one is *O*(1). let deque: VecDeque<_> = (1..5).collect(); let ptr = deque.as_slices().0.as_ptr(); let vec = Vec::from(deque); assert_eq!(vec, [1, 2, 3, 4]); assert_eq!(vec.as_ptr(), ptr); // This one needs data rearranging. let mut deque: VecDeque<_> = (1..5).collect(); deque.push_front(9); deque.push_front(8); let ptr = deque.as_slices().1.as_ptr(); let vec = Vec::from(deque); assert_eq!(vec, [8, 9, 1, 2, 3, 4]); assert_eq!(vec.as_ptr(), ptr);
Converts a &[T]
into a Box<[T]>
This conversion allocates on the heap
and performs a copy of slice
.
Examples
// create a &[u8] which will be used to create a Box<[u8]> let slice: &[u8] = &[104, 101, 108, 108, 111]; let boxed_slice: Box<[u8]> = Box::from(slice); println!("{:?}", boxed_slice);
Converts a [T; N]
into a Box<[T]>
This conversion moves the array to newly heap-allocated memory.
Examples
let boxed: Box<[u8]> = Box::from([4, 2]); println!("{:?}", boxed);
Converts a Box<str>
into a Box<[u8]>
This conversion does not allocate on the heap and happens in place.
Examples
// create a Box<str> which will be used to create a Box<[u8]> let boxed: Box<str> = Box::from("hello"); let boxed_str: Box<[u8]> = Box::from(boxed); // create a &[u8] which will be used to create a Box<[u8]> let slice: &[u8] = &[104, 101, 108, 108, 111]; let boxed_slice = Box::from(slice); assert_eq!(boxed_slice, boxed_str);
Converts a Vec<T>
into a BinaryHeap<T>
.
This conversion happens in-place, and has O(n) time complexity.
Converts a BinaryHeap<T>
into a Vec<T>
.
This conversion requires no data movement or allocation, and has constant time complexity.
Convert a vector into a boxed slice.
If v
has excess capacity, its items will be moved into a
newly-allocated buffer with exactly the right capacity.
Examples
assert_eq!(Box::from(vec![1, 2, 3]), vec![1, 2, 3].into_boxed_slice());
Converts a T
into a Box<T>
The conversion allocates on the heap and moves t
from the stack into it.
Examples
let x = 5; let boxed = Box::new(5); assert_eq!(Box::from(x), boxed);
impl<'a, T, N> From<&'a mut [T]> for &'a mut GenericArray<T, N> where
N: ArrayLength<T>,
impl<'a, T, N> From<&'a mut [T]> for &'a mut GenericArray<T, N> where
N: ArrayLength<T>,
Convert the Choice
wrapper into a bool
, depending on whether
the underlying u8
was a 0
or a 1
.
Note
This function exists to avoid having higher-level cryptographic protocol implementations duplicating this pattern.
The intended use case for this conversion is at the end of a
higher-level primitive implementation: for example, in checking a keyed
MAC, where the verification should happen in constant-time (and thus use
a Choice
) but it is safe to return a bool
at the end of the
verification.
impl<T> From<BitIdxError<<T as BitStore>::Mem>> for BitPtrError<T> where
T: BitStore,
impl<T> From<BitIdxError<<T as BitStore>::Mem>> for BitPtrError<T> where
T: BitStore,
pub fn from(err: BitIdxError<<T as BitStore>::Mem>) -> BitPtrError<T>
impl<T> From<NullPtrError> for BitPtrError<T> where
T: BitStore,
impl<T> From<NullPtrError> for BitPtrError<T> where
T: BitStore,
pub fn from(err: NullPtrError) -> BitPtrError<T>
impl<T> From<Infallible> for BitPtrError<T> where
T: BitStore,
impl<T> From<Infallible> for BitPtrError<T> where
T: BitStore,
pub fn from(Infallible) -> BitPtrError<T>
impl<O, V> From<V> for BitArray<O, V> where
V: BitViewSized,
O: BitOrder,
impl<O, V> From<V> for BitArray<O, V> where
V: BitViewSized,
O: BitOrder,
pub fn from(data: V) -> BitArray<O, V>
impl<T> From<Infallible> for BitSpanError<T> where
T: BitStore,
impl<T> From<Infallible> for BitSpanError<T> where
T: BitStore,
pub fn from(Infallible) -> BitSpanError<T>
impl<T> From<BitPtrError<T>> for BitSpanError<T> where
T: BitStore,
impl<T> From<BitPtrError<T>> for BitSpanError<T> where
T: BitStore,
pub fn from(err: BitPtrError<T>) -> BitSpanError<T>
impl<T> From<MisalignError<T>> for BitPtrError<T> where
T: BitStore,
impl<T> From<MisalignError<T>> for BitPtrError<T> where
T: BitStore,
pub fn from(err: MisalignError<T>) -> BitPtrError<T>