Trait std::convert::From1.0.0[−][src]

pub trait From<T> {
    fn from(T) -> Self;
}
Expand description

用于在消耗输入值的同时进行值到值的转换。它是 Into 的倒数。

与标准 Into 相比，人们应该总是更喜欢实现 From，因为由于标准库中的全面实现，实现 From 会自动为 Into 提供一个 Into 的实现。

仅当针对 Rust 1.41 之前的版本并将其转换为当前 crate 以外的类型时，才实现 Into。 From 由于 Rust 的孤儿规则，无法在较早版本中进行这些类型的转换。 有关更多详细信息，请参见 Into。

在泛型函数上指定 trait bounds 时，优先使用 Into。 这样，直接实现 Into 的类型也可以用作参数。

From 在执行错误处理时也非常有用。当创建一个能够失败的函数时，返回类型通常为 Result<T, E> 形式。 From trait 通过允许函数返回封装了多种错误类型的单个错误类型，简化了错误处理。有关更多详细信息，请参见 “示例” 部分和这本 书。

注意: 此 trait 一定不能失败。如果转换失败，请使用 TryFrom。

泛型实现

  • From<T> for U 暗示 Into<U> for T
  • From 是自反的，这意味着 From<T> for T 已实现

Examples

String 实现 From<&str>:

从 &str 到字符串的显式转换如下:

let string = "hello".to_string();
let other_string = String::from("hello");

assert_eq!(string, other_string);
Run

在执行错误处理时，通常对于您自己的错误类型实现 From 很有用。 通过将基础错误类型转换为封装了基础错误类型的我们自己的自定义错误类型，我们可以返回单个错误类型，而不会丢失有关基础原因的信息。 ‘?’ 运算符通过调用 Into<CliError>::into 自动将基础错误类型转换为我们的自定义错误类型，该 Into<CliError>::into 是在实现 From 时自动提供的。 然后，编译器会推断应使用 Into 的哪种实现。

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)
}
Run

Required methods

执行转换。

Implementors

将 str 转换为 dyn Error 的 box。

Examples

use std::error::Error;
use std::mem;

let a_str_error = "a str error";
let a_boxed_error = Box::<dyn Error>::from(a_str_error);
assert!(mem::size_of::<Box<dyn Error>>() == mem::size_of_val(&a_boxed_error))
Run

从引用创建一个 boxed Path。

这将为它分配和克隆 path。

通过将 Path 数据复制到新的 Rc 缓冲区，将 Path 转换为 Rc。

通过将 Path 数据复制到新的 Arc 缓冲区，将 Path 转换为 Arc。

从写时克隆指针创建一个 boxed Path。

从 Cow::Owned 转换不会克隆或分配。

旨在用于未暴露给用户的错误，因为分配到堆上 (通过 Error::new 进行常规构建) 的代价太高了。

将 ErrorKind 转换为 Error。

此转换使用错误类型的简单表示来分配新错误。

Examples

use std::io::{Error, ErrorKind};

let not_found = ErrorKind::NotFound;
let error = Error::from(not_found);
assert_eq!("entity not found", format!("{}", error));
Run

从一个四元素字节数组创建一个 IpAddr::V4。

Examples

use std::net::{IpAddr, Ipv4Addr};

let addr = IpAddr::from([13u8, 12u8, 11u8, 10u8]);
assert_eq!(IpAddr::V4(Ipv4Addr::new(13, 12, 11, 10)), addr);
Run

从一个四元素字节数组创建一个 Ipv4Addr。

Examples

use std::net::Ipv4Addr;

let addr = Ipv4Addr::from([13u8, 12u8, 11u8, 10u8]);
assert_eq!(Ipv4Addr::new(13, 12, 11, 10), addr);
Run

从 16 个元素的字节数组创建 IpAddr::V6。

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

从 16 个元素的字节数组创建 Ipv6Addr。

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

从 8 个元素的 16 位数组创建 IpAddr::V6。

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

从 8 个元素的 16 位数组创建 Ipv6Addr。

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

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

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

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

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

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

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

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

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

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

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

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

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

将 bool 转换为 AtomicBool。

Examples

use std::sync::atomic::AtomicBool;
let atomic_bool = AtomicBool::from(true);
assert_eq!(format!("{:?}", atomic_bool), "true")
Run

将 char 转换为 u32。

Examples

use std::mem;

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

将 char 转换为 u64。

Examples

use std::mem;

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

将 char 转换为 u128。

Examples

use std::mem;

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

从单个字符分配一个拥有所有权的 String。

Example

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

Converts f32 to f64 losslessly.

Converts i8 to f32 losslessly.

Converts i8 to f64 losslessly.

Converts i8 to i16 losslessly.

Converts i8 to i32 losslessly.

Converts i8 to i64 losslessly.

Converts i8 to i128 losslessly.

Converts i8 to isize losslessly.

Converts an i8 into an AtomicI8.

Converts i16 to f32 losslessly.

Converts i16 to f64 losslessly.

Converts i16 to i32 losslessly.

Converts i16 to i64 losslessly.

Converts i16 to i128 losslessly.

Converts i16 to isize losslessly.

Converts an i16 into an AtomicI16.

Converts i32 to f64 losslessly.

Converts i32 to i64 losslessly.

Converts i32 to i128 losslessly.

Converts an i32 into an AtomicI32.

Converts i64 to i128 losslessly.

Converts an i64 into an AtomicI64.

Converts an isize into an AtomicIsize.

将 0x00..=0xFF 中的字节映射到 char，该 char 的代码点具有相同的值，即 U+0000..=U+00FF。

Unicode 的设计使其可以使用 IANA 称为 ISO-8859-1 的字符编码有效地解码字节。 此编码与 ASCII 兼容。

请注意，这与 ISO/IEC 8859-1 又名不同 ISO 8859-1 (连字符少一个)，它留下了一些 “blanks” 字节值，这些值未分配给任何字符。 ISO-8859-1 (属于 IANA) 将它们分配给 C0 和 C1 控制代码。

请注意，这也与 Windows-1252 也不同 代码页 1252，它是 ISO/IEC 8859-1 的超集，它为标点符号和各种拉丁字符分配了一些 (不是全部) 空格。

为了进一步混淆，在 Web 上 ascii，iso-8859-1 和 windows-1252 都是 Windows-1252 超集的别名，该超集用相应的 C0 和 C1 控制代码填充了其余的空白。

将 u8 转换为 char。

Examples

use std::mem;

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

Converts u8 to f32 losslessly.

Converts u8 to f64 losslessly.

Converts u8 to i16 losslessly.

Converts u8 to i32 losslessly.

Converts u8 to i64 losslessly.

Converts u8 to i128 losslessly.

Converts u8 to isize losslessly.

Converts u8 to u16 losslessly.

Converts u8 to u32 losslessly.

Converts u8 to u64 losslessly.

Converts u8 to u128 losslessly.

Converts u8 to usize losslessly.

Converts an u8 into an AtomicU8.

Converts u16 to f32 losslessly.

Converts u16 to f64 losslessly.

Converts u16 to i32 losslessly.

Converts u16 to i64 losslessly.

Converts u16 to i128 losslessly.

Converts u16 to u32 losslessly.

Converts u16 to u64 losslessly.

Converts u16 to u128 losslessly.

Converts u16 to usize losslessly.

Converts an u16 into an AtomicU16.

Converts u32 to f64 losslessly.

Converts u32 to i64 losslessly.

Converts u32 to i128 losslessly.

Converts u32 to u64 losslessly.

Converts u32 to u128 losslessly.

将主机字节顺序 u32 转换为 Ipv4Addr。

Examples

use std::net::Ipv4Addr;

let addr = Ipv4Addr::from(0xcafebabe);
assert_eq!(Ipv4Addr::new(0xca, 0xfe, 0xba, 0xbe), addr);
Run

Converts an u32 into an AtomicU32.

Converts u64 to i128 losslessly.

Converts u64 to u128 losslessly.

Converts an u64 into an AtomicU64.

将主机字节顺序 u128 转换为 Ipv6Addr。

Examples

use std::net::Ipv6Addr;

let addr = Ipv6Addr::from(0x102030405060708090A0B0C0D0E0F00D_u128);
assert_eq!(
    Ipv6Addr::new(
        0x1020, 0x3040, 0x5060, 0x7080,
        0x90A0, 0xB0C0, 0xD0E0, 0xF00D,
    ),
    addr);
Run

Converts an usize into an AtomicUsize.

始终评估为 TryReserveError::CapacityOverflow。

将给定的 boxed str 切片转换为 String。 值得注意的是，str 切片是拥有的。

Examples

基本用法:

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

无需复制或分配即可将 Box<CStr> 转换为 CString。

无需复制或分配即可将 Box<OsStr> 转换为 OsString。

将 Box<Path> 转换为 PathBuf

此转换不会分配或复制内存。

无需复制或分配即可将 CString 转换为 Box<CStr>。

无需复制或分配即可将 CString 转换为 Rc<CStr>。

无需复制或分配即可将 CString 转换为 Arc<CStr>。

将 CString 转换为 Vec<u8>。

转换消耗 CString，并删除终止的 NUL 字节。

将 NulError 转换为 io::Error。

无需复制或分配即可将 OsString 转换为 Box<OsStr>。

将 OsString 转换为 PathBuf

此转换不会分配或复制内存。

无需复制或分配即可将 OsString 转换为 Rc<OsStr>。

无需复制或分配即可将 OsString 转换为 Arc<OsStr>。

将 File 转换为 Stdio

Examples

File 将在引擎盖下使用 Stdio::from 转换为 Stdio。

use std::fs::File;
use std::process::Command;

// 使用包含 `Hello，world! ` 的 `foo.txt` 文件。
let file = File::open("foo.txt").unwrap();

let reverse = Command::new("rev")
    .stdin(file)  // 隐式文件转换为 Stdio
    .output()
    .expect("failed reverse command");

assert_eq!(reverse.stdout, b"!dlrow ,olleH");
Run

将此地址复制到新的 IpAddr::V4。

Examples

use std::net::{IpAddr, Ipv4Addr};

let addr = Ipv4Addr::new(127, 0, 0, 1);

assert_eq!(
    IpAddr::V4(addr),
    IpAddr::from(addr)
)
Run

将 Ipv4Addr 转换为主机字节顺序 u32。

Examples

use std::net::Ipv4Addr;

let addr = Ipv4Addr::new(0xca, 0xfe, 0xba, 0xbe);
assert_eq!(0xcafebabe, u32::from(addr));
Run

将此地址复制到新的 IpAddr::V6。

Examples

use std::net::{IpAddr, Ipv6Addr};

let addr = Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff);

assert_eq!(
    IpAddr::V6(addr),
    IpAddr::from(addr)
);
Run

将 Ipv6Addr 转换为主机字节顺序 u128。

Examples

use std::net::Ipv6Addr;

let addr = Ipv6Addr::new(
    0x1020, 0x3040, 0x5060, 0x7080,
    0x90A0, 0xB0C0, 0xD0E0, 0xF00D,
);
assert_eq!(0x102030405060708090A0B0C0D0E0F00D_u128, u128::from(addr));
Run

将 SocketAddrV4 转换为 SocketAddr::V4。

将 SocketAddrV6 转换为 SocketAddr::V6。

Converts a NonZeroI8 into an i8

Converts NonZeroI8 to NonZeroI16 losslessly.

Converts NonZeroI8 to NonZeroI32 losslessly.

Converts NonZeroI8 to NonZeroI64 losslessly.

Converts NonZeroI8 to NonZeroI128 losslessly.

Converts NonZeroI8 to NonZeroIsize losslessly.

Converts a NonZeroI16 into an i16

Converts NonZeroI16 to NonZeroI32 losslessly.

Converts NonZeroI16 to NonZeroI64 losslessly.

Converts NonZeroI16 to NonZeroI128 losslessly.

Converts NonZeroI16 to NonZeroIsize losslessly.

Converts a NonZeroI32 into an i32

Converts NonZeroI32 to NonZeroI64 losslessly.

Converts NonZeroI32 to NonZeroI128 losslessly.

Converts a NonZeroI64 into an i64

Converts NonZeroI64 to NonZeroI128 losslessly.

Converts a NonZeroI128 into an i128

Converts a NonZeroIsize into an isize

Converts a NonZeroU8 into an u8

Converts NonZeroU8 to NonZeroI16 losslessly.

Converts NonZeroU8 to NonZeroI32 losslessly.

Converts NonZeroU8 to NonZeroI64 losslessly.

Converts NonZeroU8 to NonZeroI128 losslessly.

Converts NonZeroU8 to NonZeroIsize losslessly.

Converts NonZeroU8 to NonZeroU16 losslessly.

Converts NonZeroU8 to NonZeroU32 losslessly.

Converts NonZeroU8 to NonZeroU64 losslessly.

Converts NonZeroU8 to NonZeroU128 losslessly.

Converts NonZeroU8 to NonZeroUsize losslessly.

Converts a NonZeroU16 into an u16

Converts NonZeroU16 to NonZeroI32 losslessly.

Converts NonZeroU16 to NonZeroI64 losslessly.

Converts NonZeroU16 to NonZeroI128 losslessly.

Converts NonZeroU16 to NonZeroU32 losslessly.

Converts NonZeroU16 to NonZeroU64 losslessly.

Converts NonZeroU16 to NonZeroU128 losslessly.

Converts NonZeroU16 to NonZeroUsize losslessly.

Converts a NonZeroU32 into an u32

Converts NonZeroU32 to NonZeroI64 losslessly.

Converts NonZeroU32 to NonZeroI128 losslessly.

Converts NonZeroU32 to NonZeroU64 losslessly.

Converts NonZeroU32 to NonZeroU128 losslessly.

Converts a NonZeroU64 into an u64

Converts NonZeroU64 to NonZeroI128 losslessly.

Converts NonZeroU64 to NonZeroU128 losslessly.

Converts a NonZeroU128 into an u128

Converts a NonZeroUsize into an usize

将 PathBuf 转换为 Box<Path>

此转换当前不应该分配内存，但是不能在所有平台上或所有 future 版本中都保证此行为。

将 PathBuf 转换为 OsString

此转换不会分配或复制内存。

通过将 PathBuf 数据移动到新的 Rc 缓冲区，将 PathBuf 转换为 Rc。

通过将 PathBuf 数据移动到新的 Arc 缓冲区，将 PathBuf 转换为 Arc。

将 ChildStderr 转换为 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()) // 在此处转换为 Stdio
    .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"
);
Run

将 ChildStdin 转换为 Stdio

Examples

ChildStdin 将在引擎盖下使用 Stdio::from 转换为 Stdio。

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()) // 在此处转换为 Stdio
    .output()
    .expect("failed echo command");

// "!dlrow ,olleH" 回显到控制台
Run

将 ChildStdout 转换为 Stdio

Examples

ChildStdout 将在引擎盖下使用 Stdio::from 转换为 Stdio。

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())  // 在此处转换为 Stdio
    .output()
    .expect("failed reverse command");

assert_eq!(reverse.stdout, b"!dlrow ,olleH\n");
Run

将给定的 String 转换为拥有所有权的 boxed str 切片。

Examples

基本用法:

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

将 String 转换为 Dyn Error + Send + Sync 的 box。

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

将 String 转换为 dyn Error 的 box。

Examples

use std::error::Error;
use std::mem;

let a_string_error = "a string error".to_string();
let a_boxed_error = Box::<dyn Error>::from(a_string_error);
assert!(mem::size_of::<Box<dyn Error>>() == mem::size_of_val(&a_boxed_error))
Run

将 String 转换为 OsString。

此转换不会分配或复制内存。

将 String 转换为 PathBuf

此转换不会分配或复制内存。

分配一个引用计数的字符串切片并将 v 复制到其中。

Example

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

分配一个引用计数的 str 并将 v 复制到其中。

Example

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

将给定的 String 转换为包含 u8 类型值的 vector Vec。

Examples

基本用法:

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

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

将 RecvError 转换为 RecvTimeoutError。

此转换始终返回 RecvTimeoutError::Disconnected。

没有在堆上分配数据。

将 RecvError 转换为 TryRecvError。

此转换始终返回 TryRecvError::Disconnected。

没有在堆上分配数据。

将 Vec<NonZeroU8> 转换为 CString，而无需复制或检查内部空字节。

将 &str 转换为 Box<str>

此转换在堆上分配并执行 s 的副本。

Examples

let boxed: Box<str> = Box::from("hello");
println!("{}", boxed);
Run

分配一个引用计数的字符串切片并将 v 复制到其中。

Example

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

将 &str 转换为 String。

结果分配在堆上。

分配一个引用计数的 str 并将 v 复制到其中。

Example

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

分配一个 Vec<u8> 并用 UTF-8 字符串填充它。

Examples

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

将 &String 转换为 String。

这将克隆 s 并返回该克隆。

将 &mut str 转换为 String。

结果分配在堆上。

将 &[T] 转换为 Box<[T]>

此转换在堆上分配并执行 slice 的副本。

Examples

// 创建 &[u8] which 将用于创建 Box<[u8]>
let slice: &[u8] = &[104, 101, 108, 108, 111];
let boxed_slice: Box<[u8]> = Box::from(slice);

println!("{:?}", boxed_slice);
Run

分配一个引用计数的切片，并通过克隆 v 的项来填充它。

Example

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

分配一个引用计数的切片，并通过克隆 v 的项来填充它。

Example

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

分配一个 Vec<T> 并通过克隆 s 的项来填充它。

Examples

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

分配一个 Vec<T> 并通过克隆 s 的项来填充它。

Examples

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

将 str 转换为 Dyn Error + Send + Sync 的 box。

Examples

use std::error::Error;
use std::mem;

let a_str_error = "a str error";
let a_boxed_error = Box::<dyn Error + Send + Sync>::from(a_str_error);
assert!(
    mem::size_of::<Box<dyn Error + Send + Sync>>() == mem::size_of_val(&a_boxed_error))
Run

将字符串切片转换为 Borrowed 变体。 不执行堆分配，并且不复制字符串。

Example

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

创建一个从引用到 Path 的写时克隆指针。

此转换不会克隆或分配。

创建一个从引用到 PathBuf 的写时克隆指针。

此转换不会克隆或分配。

将 String 引用转换为 Borrowed 变体。 不执行堆分配，并且不复制字符串。

Example

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

将 Cow 转换为 dyn Error 的 box。

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>::from(a_cow_str_error);
assert!(mem::size_of::<Box<dyn Error>>() == mem::size_of_val(&a_boxed_error))
Run

将写时克隆字符串转换为 String 的拥有实例。

这将提取拥有所有权的字符串，如果尚未拥有，则克隆该字符串。

Example

// 如果该字符串不被拥有...
let cow: Cow<str> = Cow::Borrowed("eggplant");
// 它将在堆上分配并复制字符串。
let owned: String = String::from(cow);
assert_eq!(&owned[..], "eggplant");
Run

将写时克隆指针转换为拥有所有权的路径。

从 Cow::Owned 转换不会克隆或分配。

从 PathBuf 的拥有实例创建一个写时克隆指针。

此转换不会克隆或分配。

将 String 转换为 Owned 变体。 不执行堆分配，并且不复制字符串。

Example

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

将 Cow 转换为 Dyn Error + Send + Sync 的 box。

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

通过复制其内容，从写时克隆指针创建一个引用计数指针。

Example

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

通过复制其内容，从写时克隆指针创建一个原子引用计数指针。

Example

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

将 Error 的类型转换为 dyn Error 的 box。

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

将 Error + Send + Sync 的类型转换为 Dyn Error + Send + Sync 的 box。

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

从 &Option<T> 转换为 Option<&T>。

Examples

将 Option<String> 转换为 Option<usize>，并保留原始格式。 map 方法按值取 self 参数，消耗原始值，因此该技术使用 from 首先取 Option 到原始值内部值的引用。

let s: Option<String> = Some(String::from("Hello, Rustaceans!"));
let o: Option<usize> = Option::from(&s).map(|ss: &String| ss.len());

println!("Can still print s: {:?}", s);

assert_eq!(o, Some(18));
Run

从 Vec 的引用创建 Cow 的 Borrowed 变体。

此转换不会分配或克隆数据。

从 &mut Option<T> 转换为 Option<&mut T>

Examples

let mut s = Some(String::from("Hello"));
let o: Option<&mut String> = Option::from(&mut s);

match o {
    Some(t) => *t = String::from("Hello, Rustaceans!"),
    None => (),
}

assert_eq!(s, Some(String::from("Hello, Rustaceans!")));
Run

将写时克隆切片转换为 vector。

如果 s 已经拥有 Vec<T>，则直接返回。 如果 s 是借用了一个切片，将通过克隆 s 的项来分配和填充一个新的 Vec。

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

从一个切片创建一个 Cow 的 Borrowed 变体。

此转换不会分配或克隆数据。

从拥有所有权的 Vec 实例创建 Cow 的 Owned 变体。

此转换不会分配或克隆数据。

将 Box<str> 转换为 Box<[u8]>

这种转换不会在堆上分配，而是就地进行。

Examples

// 创建一个 Box<str>，该 Box<str> 将用于创建 Box<[u8]>
let boxed: Box<str> = Box::from("hello");
let boxed_str: Box<[u8]> = Box::from(boxed);

// 创建 &[u8] which 将用于创建 Box<[u8]>
let slice: &[u8] = &[104, 101, 108, 108, 111];
let boxed_slice = Box::from(slice);

assert_eq!(boxed_slice, boxed_str);
Run

将元组结构体 (Into <IpAddr>，u16) 转换为 SocketAddr。

此转换为 IpAddr::V4 创建 SocketAddr::V4，为 IpAddr::V6 创建 SocketAddr::V6。

u16 被视为新创建的 SocketAddr 的端口。

稳定性注意事项: 该暗示尚不存在，但我们 “reserving space” 会将其添加到 future 中。 有关详细信息，请参见 rust-lang/rust#64715。

将 boxed 对象移动到引用计数的新分配。

Example

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

将 boxed 对象移动到新的引用计数分配。

Example

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

将 BinaryHeap<T> 转换为 Vec<T>。

这种转换不需要数据移动或分配，并且具有恒定的时间复杂度。

将 VecDeque<T> 变成 Vec<T>。

这永远不需要重新分配，但是如果循环缓冲区恰好不在分配开始时，则确实需要进行 O(n) 数据移动。

Examples

use std::collections::VecDeque;

// 这是 *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);

// 这一项需要重新整理数据。
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);
Run

将 SendError<T> 转换为 TrySendError<T>。

这种转换总是返回一个包含 SendError<T> 中数据的 TrySendError::Disconnected。

没有在堆上分配数据。

将 Vec<T> 转换为 BinaryHeap<T>。

此转换发生在原地，并且具有 O(n) 时间复杂度。

将 Vec<T> 变成 VecDeque<T>。

这样可以避免在可能的情况下进行重新分配，但是这样做的条件很严格，并且随时可能更改，因此除非 Vec<T> 来自 From<VecDeque<T>> 并且尚未重新分配，否则不应依赖它。

分配一个引用计数的切片，并将 v 的项移入其中。

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

分配一个引用计数的切片，并将 v 的项移入其中。

Example

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

将 val 复制到新的 Some 中。

Examples

let o: Option<u8> = Option::from(67);

assert_eq!(Some(67), o);
Run

转换为 Ready 成员。

Example

assert_eq!(Poll::from(true), Poll::Ready(true));
Run

将 T 转换为 Box<T>

转换在堆上分配，并将 t 从栈移到堆中。

Examples

let x = 5;
let boxed = Box::new(5);

assert_eq!(Box::from(x), boxed);
Run

将泛型 T 转换为 Rc<T>

转换在堆上分配，并将 t 从栈移到堆中。

Example

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

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

将 T 转换为 Arc<T>

转换将值移动到新分配的 Arc 中。 相当于调用 Arc::new(t)。

Example

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

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

在解锁状态下创建一个新的互斥锁，以备使用。 这等效于 Mutex::new。

创建一个已解锁的 RwLock<T> 的新实例。 这等效于 RwLock::new。

通过转移现有堆分配的所有权，将 boxed 切片转换为 vector。

Examples

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

将 Box<T> 转换为 Pin<Box<T>>

这种转换不会在堆上分配，而是就地进行。

将 vector 转换为 boxed。

如果 v 有多余的容量，它的项将被移动到新分配的缓冲区中，缓冲区的容量恰好是正确的。

Examples

assert_eq!(Box::from(vec![1, 2, 3]), vec![1, 2, 3].into_boxed_slice());
Run

将 [T; N] 转换为 Box<[T]>

此转换将数组移动到新的堆分配的内存中。

Examples

let boxed: Box<[u8]> = Box::from([4, 2]);
println!("{:?}", boxed);
Run

将借用的 OsStr 转换为 PathBuf。

分配一个 PathBuf 并将数据复制到其中。

使用 Wake 类型作为 RawWaker。

此转换不使用堆分配或原子操作。

使用 Wake 类型作为 Waker。

此转换不使用堆分配或原子操作。