Trait signature_core::lib::From

1.0.0 · source · [−]
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. The From trait is intended for perfect conversions. If the conversion can fail or is not perfect, use TryFrom.

Generic Implementations

  • From<T> for U implies Into<U> for T
  • From is reflexive, which means that From<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

Converts to this type from the input type.

Implementations on Foreign Types

Converts u32 to f64 losslessly.

source

impl From<__m512d> for Simd<f64, 8_usize>

Converts u8 to i64 losslessly.

Converts a bool to a isize. The resulting value is 0 for false and 1 for true values.

Examples
assert_eq!(isize::from(true), 1);
assert_eq!(isize::from(false), 0);

Converts u32 to i64 losslessly.

Converts i16 to f64 losslessly.

source

impl From<Simd<i32, 4_usize>> for __m128i

Converts a *mut T into an AtomicPtr<T>.

Converts u16 to usize losslessly.

Converts u16 to i64 losslessly.

source

impl From<Simd<isize, 8_usize>> for __m256i

Converts a char into a u32.

Examples
use std::mem;

let c = 'c';
let u = u32::from(c);
assert!(4 == mem::size_of_val(&u))
source

impl From<Simd<i16, 16_usize>> for __m256i

source

impl From<__m512i> for Simd<u16, 32_usize>

Converts u16 to u128 losslessly.

Converts a bool to a i128. The resulting value is 0 for false and 1 for true values.

Examples
assert_eq!(i128::from(true), 1);
assert_eq!(i128::from(false), 0);

Converts an i64 into an AtomicI64.

Converts an i16 into an AtomicI16.

source

impl From<__m256i> for Simd<u64, 4_usize>

Creates a new OnceCell<T> which already contains the given value.

source

impl From<Simd<u16, 16_usize>> for __m256i

source

impl From<Simd<f32, 16_usize>> for __m512

source

impl From<__m512> for Simd<f32, 16_usize>

Converts f32 to f64 losslessly.

Converts u8 to u16 losslessly.

Converts u16 to u32 losslessly.

source

impl From<Simd<i32, 16_usize>> for __m512i

source

impl From<__m512i> for Simd<u8, 64_usize>

source

impl From<__m512i> for Simd<i32, 16_usize>

source

impl From<Simd<f32, 4_usize>> for __m128

Converts a NonZeroU64 into an u64

source

impl From<__m256i> for Simd<u8, 32_usize>

Converts u8 to i128 losslessly.

Converts a bool to a u8. The resulting value is 0 for false and 1 for true values.

Examples
assert_eq!(u8::from(true), 1);
assert_eq!(u8::from(false), 0);
source

impl From<__m256i> for Simd<i16, 16_usize>

Converts i8 to f32 losslessly.

Converts i8 to f64 losslessly.

Converts u16 to f32 losslessly.

source

impl From<Simd<i16, 8_usize>> for __m128i

source

impl From<__m512i> for Simd<i64, 8_usize>

Converts i8 to i16 losslessly.

source

impl From<Simd<u16, 32_usize>> for __m512i

source

impl From<Simd<usize, 4_usize>> for __m128i

Creates a new UnsafeCell<T> containing the given value.

Converts i8 to isize losslessly.

source

impl From<Simd<u8, 32_usize>> for __m256i

Converts a bool to a usize. The resulting value is 0 for false and 1 for true values.

Examples
assert_eq!(usize::from(true), 1);
assert_eq!(usize::from(false), 0);
source

impl From<__m128i> for Simd<i32, 4_usize>

source

impl From<__m256i> for Simd<i32, 8_usize>

source

impl From<Simd<usize, 8_usize>> for __m256i

source

impl From<__m128i> for Simd<u32, 4_usize>

Converts a &mut T to a NonNull<T>.

This conversion is safe and infallible since references cannot be null.

Converts a char into a u128.

Examples
use std::mem;

let c = '⚙';
let u = u128::from(c);
assert!(16 == mem::size_of_val(&u))
source

impl From<__m512i> for Simd<isize, 16_usize>

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 an u16 into an AtomicU16.

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 a u8 into a char.

Examples
use std::mem;

let u = 32 as u8;
let c = char::from(u);
assert!(4 == mem::size_of_val(&c))

Converts i16 to f32 losslessly.

Converts u16 to u64 losslessly.

Converts an i8 into an AtomicI8.

source

impl From<__m512i> for Simd<u64, 8_usize>

Converts an u32 into an AtomicU32.

Converts a NonZeroU128 into an u128

Converts a NonZeroI32 into an i32

source

impl From<Simd<u8, 16_usize>> for __m128i

source

impl From<Simd<u32, 8_usize>> for __m256i

source

impl From<__m128d> for Simd<f64, 2_usize>

Converts a NonZeroI128 into an i128

Converts an i32 into an AtomicI32.

Converts a bool to a u128. The resulting value is 0 for false and 1 for true values.

Examples
assert_eq!(u128::from(true), 1);
assert_eq!(u128::from(false), 0);
source

impl From<Simd<u8, 64_usize>> for __m512i

Converts i8 to i128 losslessly.

source

impl From<Simd<i64, 2_usize>> for __m128i

source

impl From<Simd<f64, 8_usize>> for __m512d

Converts u16 to i128 losslessly.

Converts a NonZeroU16 into an u16

source

impl From<__m512i> for Simd<usize, 16_usize>

source

impl From<__m256i> for Simd<u32, 8_usize>

Converts i32 to f64 losslessly.

Converts u8 to u32 losslessly.

source

impl From<__m128i> for Simd<u8, 16_usize>

Converts u16 to f64 losslessly.

Converts i8 to i64 losslessly.

source

impl From<Simd<i32, 8_usize>> for __m256i

Converts a bool to a u32. The resulting value is 0 for false and 1 for true values.

Examples
assert_eq!(u32::from(true), 1);
assert_eq!(u32::from(false), 0);

Converts an usize into an AtomicUsize.

Converts a NonZeroUsize into an usize

Converts a NonZeroU32 into an u32

Converts u64 to u128 losslessly.

source

impl From<__m256> for Simd<f32, 8_usize>

Converts u8 to f32 losslessly.

Converts an u64 into an AtomicU64.

Converts i32 to i64 losslessly.

source

impl From<__m128> for Simd<f32, 4_usize>

source

impl From<__m512i> for Simd<i16, 32_usize>

source

impl From<Simd<i8, 16_usize>> for __m128i

Converts a bool to a i32. The resulting value is 0 for false and 1 for true values.

Examples
assert_eq!(i32::from(true), 1);
assert_eq!(i32::from(false), 0);
source

impl From<Simd<u64, 8_usize>> for __m512i

Converts an u8 into an AtomicU8.

Converts a NonZeroIsize into an isize

Moves the value into a Poll::Ready to make a Poll<T>.

Example
assert_eq!(Poll::from(true), Poll::Ready(true));
source

impl From<__m128i> for Simd<i16, 8_usize>

Converts i16 to i64 losslessly.

source

impl From<__m128i> for Simd<u16, 8_usize>

source

impl From<Simd<u64, 4_usize>> for __m256i

source

impl From<Simd<i8, 64_usize>> for __m512i

Converts i16 to i32 losslessly.

Converts a NonZeroI8 into an i8

Converts i8 to i32 losslessly.

source

impl From<__m256i> for Simd<usize, 8_usize>

Converts a NonZeroI64 into an i64

Converts i16 to isize losslessly.

source

impl From<Simd<u32, 16_usize>> for __m512i

Converts a bool to a i16. The resulting value is 0 for false and 1 for true values.

Examples
assert_eq!(i16::from(true), 1);
assert_eq!(i16::from(false), 0);

Converts u8 to u64 losslessly.

source

impl From<__m128i> for Simd<u64, 2_usize>

Converts u8 to i16 losslessly.

Converts u32 to i128 losslessly.

Converts a bool to a i8. The resulting value is 0 for false and 1 for true values.

Examples
assert_eq!(i8::from(true), 1);
assert_eq!(i8::from(false), 0);
source

impl From<__m128i> for Simd<usize, 4_usize>

Converts i64 to i128 losslessly.

source

impl From<Simd<f32, 8_usize>> for __m256

Converts u32 to u128 losslessly.

source

impl From<__m256i> for Simd<isize, 8_usize>

source

impl From<Simd<u16, 8_usize>> for __m128i

source

impl From<Simd<f64, 4_usize>> for __m256d

source

impl From<__m256i> for Simd<i8, 32_usize>

Converts i32 to i128 losslessly.

Converts u16 to i32 losslessly.

Converts an isize into an AtomicIsize.

source

impl From<Simd<isize, 16_usize>> for __m512i

Converts i16 to i128 losslessly.

Converts a &T to a NonNull<T>.

This conversion is safe and infallible since references cannot be null.

source

impl From<Simd<i64, 8_usize>> for __m512i

source

impl From<Simd<i16, 32_usize>> for __m512i

Converts u8 to f64 losslessly.

source

impl From<__m256i> for Simd<u16, 16_usize>

Converts a bool to a u64. The resulting value is 0 for false and 1 for true values.

Examples
assert_eq!(u64::from(true), 1);
assert_eq!(u64::from(false), 0);
source

impl From<__m512i> for Simd<u32, 16_usize>

source

impl From<__m512i> for Simd<i8, 64_usize>

source

impl From<Simd<u32, 4_usize>> for __m128i

source

impl From<__m128i> for Simd<isize, 4_usize>

source

impl From<Simd<i64, 4_usize>> for __m256i

source

impl From<Simd<usize, 16_usize>> for __m512i

Converts a char into a u64.

Examples
use std::mem;

let c = '👤';
let u = u64::from(c);
assert!(8 == mem::size_of_val(&u))
source

impl From<__m256i> for Simd<i64, 4_usize>

Converts u64 to i128 losslessly.

Converts a bool to a u16. The resulting value is 0 for false and 1 for true values.

Examples
assert_eq!(u16::from(true), 1);
assert_eq!(u16::from(false), 0);
source

impl From<__m128i> for Simd<i64, 2_usize>

source

impl From<Simd<f64, 2_usize>> for __m128d

Converts u8 to usize losslessly.

source

impl From<__m128i> for Simd<i8, 16_usize>

source

impl From<__m256d> for Simd<f64, 4_usize>

source

impl From<Simd<i8, 32_usize>> for __m256i

Converts a bool to a i64. The resulting value is 0 for false and 1 for true values.

Examples
assert_eq!(i64::from(true), 1);
assert_eq!(i64::from(false), 0);

Converts a NonZeroI16 into an i16

Converts a NonZeroU8 into an u8

Converts u8 to i32 losslessly.

Converts u32 to u64 losslessly.

source

impl From<Simd<u64, 2_usize>> for __m128i

Creates a new SyncUnsafeCell<T> containing the given value.

source

impl From<Simd<isize, 4_usize>> for __m128i

Converts u8 to u128 losslessly.

Converts u8 to isize losslessly.

Converts mutable slice to a mutable generic array reference

Length of the slice must be equal to the length of the array.

Converts slice to a generic array reference with inferred length;

Length of the slice must be equal to the length of the array.

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.

Converts a Cow<'a, CStr> into a CString, by copying the contents if they are borrowed.

Turn a Vec<T> into a VecDeque<T>.

This avoids reallocating where possible, but the conditions for that are strict, and subject to change, and so shouldn’t be relied upon unless the Vec<T> came from From<VecDeque<T>> and hasn’t been reallocated.

Converts a Cow<'_, [T]> into a Box<[T]>

When cow is the Cow::Borrowed variant, this conversion allocates on the heap and copies the underlying slice. Otherwise, it will try to reuse the owned Vec’s allocation.

Create an atomically reference-counted pointer from a clone-on-write pointer by copying its content.

Example
let cow: Cow<str> = Cow::Borrowed("eggplant");
let shared: Arc<str> = Arc::from(cow);
assert_eq!("eggplant", &shared[..]);

Allocate a Vec<u8> and fill it with a UTF-8 string.

Examples
assert_eq!(Vec::from("123"), vec![b'1', b'2', b'3']);

Converts a [T; N] into a BTreeSet<T>.

use std::collections::BTreeSet;

let set1 = BTreeSet::from([1, 2, 3, 4]);
let set2: BTreeSet<_> = [1, 2, 3, 4].into();
assert_eq!(set1, set2);

Converts a CString into an Arc<CStr> by moving the CString data into a new Arc buffer.

Allocate a Vec<T> and fill it by cloning s’s items.

Examples
assert_eq!(Vec::from(&mut [1, 2, 3][..]), vec![1, 2, 3]);

Converts a Box<CStr> into a CString without copying or allocating.

Converts a CString into a Box<CStr> without copying or allocating.

Create a reference-counted pointer from a clone-on-write pointer by copying its content.

Example
let cow: Cow<str> = Cow::Borrowed("eggplant");
let shared: Rc<str> = Rc::from(cow);
assert_eq!("eggplant", &shared[..]);
use std::collections::BinaryHeap;

let mut h1 = BinaryHeap::from([1, 4, 2, 3]);
let mut h2: BinaryHeap<_> = [1, 4, 2, 3].into();
while let Some((a, b)) = h1.pop().zip(h2.pop()) {
    assert_eq!(a, b);
}

Move a boxed object to a new, reference-counted allocation.

Example
let unique: Box<str> = Box::from("eggplant");
let shared: Arc<str> = Arc::from(unique);
assert_eq!("eggplant", &shared[..]);

Converts a CString into an Rc<CStr> by moving the CString data into a new Arc buffer.

Creates an Owned variant of Cow from an owned instance of Vec.

This conversion does not allocate or clone the data.

Move a boxed object to a new, reference counted, allocation.

Example
let original: Box<i32> = Box::new(1);
let shared: Rc<i32> = Rc::from(original);
assert_eq!(1, *shared);

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 CString into a Vec<u8>.

The conversion consumes the CString, and removes the terminating NUL byte.

Converts a &mut str into a String.

The result is allocated on the heap.

Converts an atomically reference-counted string slice into a byte slice.

Example
let string: Arc<str> = Arc::from("eggplant");
let bytes: Arc<[u8]> = Arc::from(string);
assert_eq!("eggplant".as_bytes(), bytes.as_ref());

Allocates an owned String from a single character.

Example
let c: char = 'a';
let s: String = String::from(c);
assert_eq!("a", &s[..]);

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:?}");

Allocate a reference-counted slice and fill it by cloning v’s items.

Example
let original: &[i32] = &[1, 2, 3];
let shared: Rc<[i32]> = Rc::from(original);
assert_eq!(&[1, 2, 3], &shared[..]);

Converts a [(K, V); N] into a BTreeMap<(K, V)>.

use std::collections::BTreeMap;

let map1 = BTreeMap::from([(1, 2), (3, 4)]);
let map2: BTreeMap<_, _> = [(1, 2), (3, 4)].into();
assert_eq!(map1, map2);

Converts a &String into a String.

This clones s and returns the clone.

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);

Creates a Borrowed variant of Cow from a slice.

This conversion does not allocate or clone the data.

Use a Wake-able type as a RawWaker.

No heap allocations or atomic operations are used for this conversion.

Converts a String into an Owned variant. No heap allocation is performed, and the string is not copied.

Example
let s = "eggplant".to_string();
let s2 = "eggplant".to_string();
assert_eq!(Cow::from(s), Cow::<'static, str>::Owned(s2));

Converts a Vec<T> into a BinaryHeap<T>.

This conversion happens in-place, and has O(n) time complexity.

Use a Wake-able type as a Waker.

No heap allocations or atomic operations are used for this conversion.

Converts a &CStr into a Rc<CStr>, by copying the contents into a newly allocated Rc.

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 [T; N] into a VecDeque<T>.

use std::collections::VecDeque;

let deq1 = VecDeque::from([1, 2, 3, 4]);
let deq2: VecDeque<_> = [1, 2, 3, 4].into();
assert_eq!(deq1, deq2);

Allocate a reference-counted slice and fill it by cloning v’s items.

Example
let original: &[i32] = &[1, 2, 3];
let shared: Arc<[i32]> = Arc::from(original);
assert_eq!(&[1, 2, 3], &shared[..]);

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 Cow<'_, str> into a Box<str>

When cow is the Cow::Borrowed variant, this conversion allocates on the heap and copies the underlying str. Otherwise, it will try to reuse the owned String’s allocation.

Examples
use std::borrow::Cow;

let unboxed = Cow::Borrowed("hello");
let boxed: Box<str> = Box::from(unboxed);
println!("{boxed}");
let unboxed = Cow::Owned("hello".to_string());
let boxed: Box<str> = Box::from(unboxed);
println!("{boxed}");

Convert a boxed slice into a vector by transferring ownership of the existing heap allocation.

Examples
let b: Box<[i32]> = vec![1, 2, 3].into_boxed_slice();
assert_eq!(Vec::from(b), vec![1, 2, 3]);

Allocate a reference-counted string slice and copy v into it.

Example
let original: String = "statue".to_owned();
let shared: Rc<str> = Rc::from(original);
assert_eq!("statue", &shared[..]);

Converts the given String to a vector Vec that holds values of type u8.

Examples

Basic usage:

let s1 = String::from("hello world");
let v1 = Vec::from(s1);

for b in v1 {
    println!("{b}");
}

Always evaluates to TryReserveErrorKind::CapacityOverflow.

Converts a Box<T> into a Pin<Box<T>>

This conversion does not allocate on the heap and happens in place.

Converts a &str into a String.

The result is allocated on the heap.

Converts a CString into an owned Cow without copying or allocating.

Converts a reference-counted string slice into a byte slice.

Example
let string: Rc<str> = Rc::from("eggplant");
let bytes: Rc<[u8]> = Rc::from(string);
assert_eq!("eggplant".as_bytes(), bytes.as_ref());

Converts a String reference into a Borrowed variant. No heap allocation is performed, and the string is not copied.

Example
let s = "eggplant".to_string();
assert_eq!(Cow::from(&s), Cow::Borrowed("eggplant"));

Converts a &CString into a borrowed Cow without copying or allocating.

Converts a CStr into a borrowed Cow without copying or allocating.

Creates a Borrowed variant of Cow from a reference to Vec.

This conversion does not allocate or clone the data.

Converts a Vec<NonZeroU8> into a CString without copying nor checking for inner null bytes.

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());

Allocate a reference-counted str and copy v into it.

Example
let shared: Arc<str> = Arc::from("eggplant");
assert_eq!("eggplant", &shared[..]);

Converts a Cow<'a, CStr> into a Box<CStr>, by copying the contents if they are borrowed.

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 generic type T into an Rc<T>

The conversion allocates on the heap and moves t from the stack into it.

Example
let x = 5;
let rc = Rc::new(5);

assert_eq!(Rc::from(x), rc);

Converts a T into an Arc<T>

The conversion moves the value into a newly allocated Arc. It is equivalent to calling Arc::new(t).

Example
let x = 5;
let arc = Arc::new(5);

assert_eq!(Arc::from(x), arc);

Converts a string slice into a Borrowed variant. No heap allocation is performed, and the string is not copied.

Example
assert_eq!(Cow::from("eggplant"), Cow::Borrowed("eggplant"));

Allocate a reference-counted str and copy v into it.

Example
let unique: String = "eggplant".to_owned();
let shared: Arc<str> = Arc::from(unique);
assert_eq!("eggplant", &shared[..]);

Allocate a reference-counted slice and move v’s items into it.

Example
let unique: Vec<i32> = vec![1, 2, 3];
let shared: Arc<[i32]> = Arc::from(unique);
assert_eq!(&[1, 2, 3], &shared[..]);

Converts a BinaryHeap<T> into a Vec<T>.

This conversion requires no data movement or allocation, and has constant time complexity.

Converts a &CStr into a Arc<CStr>, by copying the contents into a newly allocated Arc.

Converts a [T; N] into a LinkedList<T>.

use std::collections::LinkedList;

let list1 = LinkedList::from([1, 2, 3, 4]);
let list2: LinkedList<_> = [1, 2, 3, 4].into();
assert_eq!(list1, list2);

Allocate a Vec<T> and fill it by cloning s’s items.

Examples
assert_eq!(Vec::from(&[1, 2, 3][..]), vec![1, 2, 3]);

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");

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}");

Converts the given String to a boxed str slice that is owned.

Examples

Basic usage:

let s1: String = String::from("hello world");
let s2: Box<str> = Box::from(s1);
let s3: String = String::from(s2);

assert_eq!("hello world", s3)

Allocate a Vec<T> and move s’s items into it.

Examples
assert_eq!(Vec::from([1, 2, 3]), vec![1, 2, 3]);

Allocate a reference-counted string slice and copy v into it.

Example
let shared: Rc<str> = Rc::from("statue");
assert_eq!("statue", &shared[..]);

Converts the given boxed str slice to a String. It is notable that the str slice is owned.

Examples

Basic usage:

let s1: String = String::from("hello world");
let s2: Box<str> = s1.into_boxed_str();
let s3: String = String::from(s2);

assert_eq!("hello world", s3)

Allocate a reference-counted slice and move v’s items into it.

Example
let original: Box<Vec<i32>> = Box::new(vec![1, 2, 3]);
let shared: Rc<Vec<i32>> = Rc::from(original);
assert_eq!(vec![1, 2, 3], *shared);

Converts a &CStr into a Box<CStr>, by copying the contents into a newly allocated Box.

Implementors

Stability note: This impl does not yet exist, but we are “reserving space” to add it in the future. See rust-lang/rust#64715 for details.