Rust Standard Library

https://rustwiki.org/zh-CN/std/
Admin
The Rust Standard Library is a collection of portable, battle-tested shared abstractions providing...
Tokens:3,569,697
Snippets:21,645
Trust Score:8.8
Update:9 months ago
Show doc for...
Tokens:
Raw
### Rust Path Starts With

Source: https://rustwiki.org/zh-CN/std/path/struct.Path

This example demonstrates how to check if a path starts with a given prefix using the `starts_with()` method. It checks if the path begins with the specified base path. Only considers whole path components.

```rust
use std::path::Path;

let path = Path::new("/etc/passwd");

assert!(path.starts_with("/etc"));
assert!(path.starts_with("/etc/"));
assert!(path.starts_with("/etc/passwd"));
assert!(path.starts_with("/etc/passwd/")); // 额外的斜线是可以的
assert!(path.starts_with("/etc/passwd///")); // multiple extra slashes are okay

assert!(!path.starts_with("/e"));
assert!(!path.starts_with("/etc/passwd.txt"));

assert!(!Path::new("/etc/foo.rs").starts_with("/etc/foo"));
```

--------------------------------

### Rust RangeFrom Examples: Syntax and Usage

Source: https://rustwiki.org/zh-CN/std/ops/struct.RangeFrom

Demonstrates the usage of the `start..` syntax, which corresponds to `RangeFrom`, in Rust. It shows how to create `RangeFrom` instances, use them with iterators for summation, and apply them for array slicing.

```rust
assert_eq!((2..), std::ops::RangeFrom { start: 2 });
assert_eq!(2 + 3 + 4, (2..).take(3).sum());
```

```rust
let arr = [0, 1, 2, 3, 4];
assert_eq!(arr[ ..  ], [0, 1, 2, 3, 4]);
assert_eq!(arr[ .. 3], [0, 1, 2      ]);
assert_eq!(arr[ ..=3], [0, 1, 2, 3   ]);
assert_eq!(arr[1..  ], [   1, 2, 3, 4]); // 这是 `RangeFrom`
assert_eq!(arr[1.. 3], [   1, 2      ]);
assert_eq!(arr[1..=3], [   1, 2, 3   ]);
```

--------------------------------

### Example: Create and Iterate Over HashMap Keys in Rust

Source: https://rustwiki.org/zh-CN/std/collections/hash_map/struct.Keys

Demonstrates how to create a `HashMap` and obtain an iterator over its keys using the `keys()` method. The example initializes a HashMap with a single key-value pair and then calls `keys()` to get an iterator, which can then be used for further operations.

```rust
use std::collections::HashMap;

let map = HashMap::from([
    ("a", 1),
]);
let iter_keys = map.keys();
```

--------------------------------

### Rust RangeBounds start_bound Method Examples

Source: https://rustwiki.org/zh-CN/std/ops/trait.RangeBounds

Demonstrates the usage of the `start_bound` method for Rust's `RangeBounds` trait. It shows how to retrieve the start bound of different range syntaxes, returning `Unbounded` or `Included`.

```rust
use std::ops::Bound::*;
use std::ops::RangeBounds;

assert_eq!((..10).start_bound(), Unbounded);
assert_eq!((3..10).start_bound(), Included(&3));
```

--------------------------------

### Rust: Range Examples with Array Slicing and Summation

Source: https://rustwiki.org/zh-CN/std/ops/struct.Range

Demonstrates the usage of Rust's `Range` struct, including creating ranges with the `start..end` syntax, using them for array slicing, and calculating sums over ranges.

```rust
assert_eq!((3..5), std::ops::Range { start: 3, end: 5 });
assert_eq!(3 + 4 + 5, (3..6).sum());

let arr = [0, 1, 2, 3, 4];
assert_eq!(arr[ ..  ], [0, 1, 2, 3, 4]);
assert_eq!(arr[ .. 3], [0, 1, 2      ]);
assert_eq!(arr[ ..=3], [0, 1, 2, 3   ]);
assert_eq!(arr[1..  ], [   1, 2, 3, 4]);
assert_eq!(arr[1.. 3], [   1, 2      ]); // 这是 `Range`
assert_eq!(arr[1..=3], [   1, 2, 3   ]);
```

--------------------------------

### Example of Printing a Path in Rust

Source: https://rustwiki.org/zh-CN/std/path/struct.Display

Demonstrates how to use the `display` method to get a `Display` instance for a `Path` and print it using the `println!` macro. This showcases the primary use case of the `Display` struct for path formatting.

```rust
use std::path::Path;

let path = Path::new("/tmp/foo.rs");

println!("{}", path.display());
```

--------------------------------

### Rust: Access RangeInclusive Start and End

Source: https://rustwiki.org/zh-CN/std/ops/struct.RangeInclusive

Illustrates how to get the start and end bounds of a `RangeInclusive` using the `start()` and `end()` methods. Note that these values are unspecified after the iterator is exhausted.

```rust
assert_eq!((3..=5).start(), &3);
assert_eq!((3..=5).end(), &5);
```

--------------------------------

### Create and Use TcpListener for Server

Source: https://rustwiki.org/zh-CN/std/net/struct.TcpListener

Demonstrates how to create a TcpListener, bind it to an address, and accept incoming client connections in a loop. It includes a placeholder for handling individual client connections.

```rust
use std::net::{TcpListener, TcpStream};

fn handle_client(stream: TcpStream) {
    // ...
}

fn main() -> std::io::Result<()> {
    let listener = TcpListener::bind("127.0.0.1:80")?;

    // 接受连接并顺序处理它们
    for stream in listener.incoming() {
        handle_client(stream?);
    }
    Ok(())
}
```

--------------------------------

### Rust RangeTo Example: Slice Indexing

Source: https://rustwiki.org/zh-CN/std/ops/struct.RangeTo

Illustrates how `RangeTo` is used for slicing arrays and strings in Rust. It shows examples of creating slices from the beginning up to a specific index, and also includes comparisons with other range syntaxes like `..=end`, `start..`, and `start..=end`.

```rust
let arr = [0, 1, 2, 3, 4];
assert_eq!(arr[ ..  ], [0, 1, 2, 3, 4]);
assert_eq!(arr[ .. 3], [0, 1, 2      ]); // 这是 `RangeTo`
assert_eq!(arr[ ..=3], [0, 1, 2, 3   ]);
assert_eq!(arr[1..  ], [   1, 2, 3, 4]);
assert_eq!(arr[1.. 3], [   1, 2      ]);
assert_eq!(arr[1..=3], [   1, 2, 3   ]);
```

--------------------------------

### Get Current Instant in Rust

Source: https://rustwiki.org/zh-CN/std/time/struct.Instant

Shows the basic usage of Instant::now() to get the current moment in time. This is the starting point for any duration measurement using Instant.

```rust
use std::time::Instant;

let now = Instant::now();
```

--------------------------------

### Basic Command Spawning (Rust)

Source: https://rustwiki.org/zh-CN/std/process/struct.Command

A simple example of creating and spawning a new process using Command::new and spawn. This demonstrates the most basic usage for executing an external program.

```Rust
use std::process::Command;

Command::new("sh")
        .spawn()
        .expect("sh command failed to start");
```

--------------------------------

### Rust: Example of creating and using slice.windows()

Source: https://rustwiki.org/zh-CN/std/slice/struct.Windows

Demonstrates how to create a `Windows` iterator from a slice in Rust. The example shows initializing a character slice and then obtaining an iterator that yields overlapping sub-slices of length 2.

```rust
let slice = ['r', 'u', 's', 't'];
let iter = slice.windows(2);
```

--------------------------------

### Rust Example: Formatting with format_args! and std::fmt::format

Source: https://rustwiki.org/zh-CN/std/macro.format_args

Shows a basic usage of the `format_args!` macro in conjunction with `std::fmt::format` to create a formatted string. This illustrates how `format_args!` prepares arguments that can then be used by formatting functions.

```rust
use std::fmt;

let s = fmt::format(format_args!("hello {}", "world"));
assert_eq!(s, format!("hello {}", "world"));
```

--------------------------------

### Rust: Get Shared Reference from Pointer (Direct Dereference)

Source: https://rustwiki.org/zh-CN/std/primitive.pointer

This example demonstrates direct dereferencing of a pointer to get a shared reference `&T`. This is an unchecked alternative to `as_ref` and should only be used when it's guaranteed that the pointer is not null.

```rust
let ptr: *mut u8 = &mut 10u8 as *mut u8;

unsafe {
    let val_back = &*ptr;
    println!("We got back the value: {val_back}!");
}
```

--------------------------------

### Rust: Get number of hard links from file metadata (Linux)

Source: https://rustwiki.org/zh-CN/std/os/linux/fs/trait.MetadataExt

This example demonstrates how to get the count of hard links to a file using the `st_nlink` method from the `MetadataExt` trait.

```rust
use std::fs;
use std::io;
use std::os::linux::fs::MetadataExt;

fn main() -> io::Result<()> {
    let meta = fs::metadata("some_file")?;
    println!("{}", meta.st_nlink());
    Ok(())
}
```

--------------------------------

### Rust AtomicBool Example

Source: https://rustwiki.org/zh-CN/std/sync/atomic/struct.AtomicBool

Demonstrates the creation and basic usage of an AtomicBool in Rust. It shows how to initialize an AtomicBool from a boolean value and format it for display.

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

--------------------------------

### Get Pathname from SocketAddr

Source: https://rustwiki.org/zh-CN/std/os/unix/net/struct.SocketAddr

Demonstrates how to retrieve the pathname from a `SocketAddr` if it represents a pathname address. Examples show how to get the path from a bound `UnixListener` and how `None` is returned for an unbound `UnixDatagram`.

```rust
use std::os::unix::net::UnixListener;
use std::path::Path;

fn main() -> std::io::Result<()> {
    let socket = UnixListener::bind("/tmp/sock")?;
    let addr = socket.local_addr().expect("Couldn't get local address");
    assert_eq!(addr.as_pathname(), Some(Path::new("/tmp/sock")));
    Ok(())
}
```

```rust
use std::os::unix::net::UnixDatagram;

fn main() -> std::io::Result<()> {
    let socket = UnixDatagram::unbound()?;
    let addr = socket.local_addr().expect("Couldn't get local address");
    assert_eq!(addr.as_pathname(), None);
    Ok(())
}
```

--------------------------------

### Spinlock Example

Source: https://rustwiki.org/zh-CN/std/sync/atomic/index

Demonstrates the creation and usage of a simple spinlock using `AtomicUsize` and `Arc` for thread synchronization.

```APIDOC
## Example: Simple Spinlock

### Description

This example illustrates how to implement a basic spinlock using `std::sync::atomic::AtomicUsize` and `std::sync::Arc`. The lock is represented by an `AtomicUsize`, where a value of `1` indicates the lock is available and `0` indicates it is held.

### Code

```rust
use std::sync::Arc;
use std::sync::atomic::{AtomicUsize, Ordering};
use std::{hint, thread};

fn main() {
    // Initialize the spinlock with value 1 (available)
    let spinlock = Arc::new(AtomicUsize::new(1));

    let spinlock_clone = Arc::clone(&spinlock);
    let thread = thread::spawn(move|| {
        // Attempt to acquire the lock (set to 0)
        spinlock_clone.store(0, Ordering::SeqCst);
    });

    // Wait for the other thread to release the lock (set to 0)
    while spinlock.load(Ordering::SeqCst) != 0 {
        hint::spin_loop(); // Busy-wait hint
    }

    if let Err(panic) = thread.join() {
        println!("Thread had an error: {:?}", panic);
    }
}
```

### Explanation

1.  An `AtomicUsize` is initialized to `1` and wrapped in an `Arc` for shared ownership across threads.
2.  A new thread is spawned, cloning the `Arc`. This thread immediately attempts to acquire the lock by setting the `AtomicUsize` to `0` using `store` with `Ordering::SeqCst`.
3.  The main thread enters a `while` loop, continuously checking the value of the `AtomicUsize` using `load` with `Ordering::SeqCst`. It uses `hint::spin_loop()` to indicate to the CPU that it's in a busy-wait state.
4.  The loop continues until the `AtomicUsize` becomes `0`, signifying that the spawned thread has acquired the lock.
5.  Finally, the main thread waits for the spawned thread to complete using `thread.join()`.
```

--------------------------------

### BTreeMap: Get Map Length

Source: https://rustwiki.org/zh-CN/std/collections/btree_map/struct.BTreeMap

This example demonstrates how to get the number of elements in a BTreeMap using the `len()` method. It initializes an empty map, asserts that its length is 0, inserts an element, and then asserts that the length is 1.

```Rust
use std::collections::BTreeMap;

let mut a = BTreeMap::new();
assert_eq!(a.len(), 0);
a.insert(1, "a");
assert_eq!(a.len(), 1);
```

--------------------------------

### Rust: Create and Use Arguments with format_args!

Source: https://rustwiki.org/zh-CN/std/fmt/struct.Arguments

Demonstrates how to use the format_args! macro to create an Arguments struct and then format it using Debug and Display traits. The example shows that Debug and Display can produce the same output when the format string is simple.

```rust
let debug = format!("{:?}", format_args!("{} foo {:?}", 1, 2));
let display = format!("{}", format_args!("{} foo {:?}", 1, 2));
assert_eq!("1 foo 2", display);
assert_eq!(display, debug);
```

--------------------------------

### Rust LineWriter: Creating a New LineWriter

Source: https://rustwiki.org/zh-CN/std/io/struct.LineWriter

This example demonstrates the basic creation of a `LineWriter` instance by wrapping an existing `File` writer. It shows how to initialize `LineWriter` with a file handle.

```rust
use std::fs::File;
use std::io::LineWriter;

fn main() -> std::io::Result<()> {
    let file = File::create("poem.txt")?;
    let file = LineWriter::new(file);
    Ok(())
}

```

--------------------------------

### Rust: Get last modification time in nanoseconds from metadata (Linux)

Source: https://rustwiki.org/zh-CN/std/os/linux/fs/trait.MetadataExt

This example demonstrates how to get the nanosecond component of the last modification time, relative to `st_mtime`, using the `st_mtime_nsec` method from the `MetadataExt` trait.

```rust
use std::fs;
use std::io;
use std::os::linux::fs::MetadataExt;

fn main() -> io::Result<()> {
    let meta = fs::metadata("some_file")?;
    println!("{}", meta.st_mtime_nsec());
    Ok(())
}
```

--------------------------------

### Rust: Get last access time in nanoseconds from metadata (Linux)

Source: https://rustwiki.org/zh-CN/std/os/linux/fs/trait.MetadataExt

This example demonstrates how to get the nanosecond component of the last access time, relative to `st_atime`, using the `st_atime_nsec` method from the `MetadataExt` trait.

```rust
use std::fs;
use std::io;
use std::os::linux::fs::MetadataExt;

fn main() -> io::Result<()> {
    let meta = fs::metadata("some_file")?;
    println!("{}", meta.st_atime_nsec());
    Ok(())
}
```

--------------------------------

### Iterate Incoming Connections with UnixListener (Rust)

Source: https://rustwiki.org/zh-CN/std/os/unix/net/struct.UnixListener

Provides an example of using the `incoming()` method to iterate over incoming connections on a `UnixListener`. This is a common pattern for handling multiple clients concurrently.

```rust
use std::thread;
use std::os::unix::net::{UnixStream, UnixListener};

fn handle_client(stream: UnixStream) {
    // ...
}

fn main() -> std::io::Result<()> {
    let listener = UnixListener::bind("/path/to/the/socket")?;

    // 接受连接并处理它们，为每个连接产生一个新线程
    for stream in listener.incoming() {
        match stream {
            Ok(stream) => {
                /* connection succeeded */
                thread::spawn(|| handle_client(stream));
            }
            Err(err) => {
                /* connection failed */
                break;
            }
        }
    }
    Ok(())
}
```

--------------------------------

### Rust: Get file owner's group ID from file metadata (Linux)

Source: https://rustwiki.org/zh-CN/std/os/linux/fs/trait.MetadataExt

This example demonstrates how to get the group ID of the file's owner using the `st_gid` method from the `MetadataExt` trait.

```rust
use std::fs;
use std::io;
use std::os::linux::fs::MetadataExt;

fn main() -> io::Result<()> {
    let meta = fs::metadata("some_file")?;
    println!("{}", meta.st_gid());
    Ok(())
}
```

--------------------------------

### Check if String Starts With a Prefix in Rust

Source: https://rustwiki.org/zh-CN/std/primitive.str

Illustrates how to check if a string slice begins with a specified pattern (substring, character, or closure) using the `starts_with()` method. It returns `true` if the string starts with the pattern and `false` otherwise. The example checks if "bananas" starts with "bana" and "nana".

```rust
let bananas = "bananas";

assert!(bananas.starts_with("bana"));
assert!(!bananas.starts_with("nana"));
```

--------------------------------

### Rust std::mem::take Simple Example

Source: https://rustwiki.org/zh-CN/std/mem/fn.take

A basic example demonstrating the usage of std::mem::take. It shows how to replace a Vec with its default (an empty Vec) and retrieve the original Vec.

```rust
use std::mem;

let mut v: Vec<i32> = vec![1, 2];

let old_v = mem::take(&mut v);
assert_eq!(vec![1, 2], old_v);
assert!(v.is_empty());
```

--------------------------------

### Rust: Get file size in bytes from metadata (Linux)

Source: https://rustwiki.org/zh-CN/std/os/linux/fs/trait.MetadataExt

This example demonstrates how to get the size of a file in bytes using the `st_size` method from the `MetadataExt` trait. For symbolic links, it returns the length of the path name.

```rust
use std::fs;
use std::io;
use std::os::linux::fs::MetadataExt;

fn main() -> io::Result<()> {
    let meta = fs::metadata("some_file")?;
    println!("{}", meta.st_size());
    Ok(())
}
```

--------------------------------

### Rust Stream Position Example

Source: https://rustwiki.org/zh-CN/std/io/trait.Seek

Demonstrates how to get the current cursor position within a stream using the `stream_position` method of the `Seek` trait in Rust. This example reads a line from a file and calculates its length based on the change in stream position.

```rust
use std::{
    io::{self, BufRead, BufReader, Seek},
    fs::File,
};

fn main() -> io::Result<()> {
    let mut f = BufReader::new(File::open("foo.txt")?);

    let before = f.stream_position()?;
    f.read_line(&mut String::new())?;
    let after = f.stream_position()?;

    println!("The first line was {} bytes long", after - before);
    Ok(())
}
```

--------------------------------

### AtomicBool fetch_nand Example in Rust

Source: https://rustwiki.org/zh-CN/std/sync/atomic/struct.AtomicBool

Demonstrates the usage of fetch_nand for AtomicBool, performing a logical NAND operation and returning the previous value. It highlights different initial states and expected outcomes.

```rust
use std::sync::atomic::{AtomicBool, Ordering};

let foo = AtomicBool::new(true);
assert_eq!(foo.fetch_nand(false, Ordering::SeqCst), true);
assert_eq!(foo.load(Ordering::SeqCst), true);

let foo = AtomicBool::new(true);
assert_eq!(foo.fetch_nand(true, Ordering::SeqCst), true);
assert_eq!(foo.load(Ordering::SeqCst) as usize, 0);
assert_eq!(foo.load(Ordering::SeqCst), false);

let foo = AtomicBool::new(false);
assert_eq!(foo.fetch_nand(false, Ordering::SeqCst), false);
assert_eq!(foo.load(Ordering::SeqCst), true);
```

--------------------------------

### Rust: Example of using deprecated and recommended f64::MIN

Source: https://rustwiki.org/zh-CN/std/f64/constant.MIN

Demonstrates the usage of the deprecated `std::f64::MIN` and the recommended `f64::MIN` constant in Rust. The example shows how to declare a variable using both methods.

```rust
// 弃用的方式
let min = std::f64::MIN;

// 预期的方式
let min = f64::MIN;
```

--------------------------------

### Spawn a Process with Command in Rust

Source: https://rustwiki.org/zh-CN/std/process/index

Demonstrates how to spawn a child process and capture its output using `std::process::Command`. This example executes an 'echo' command and asserts its standard output.

```rust
use std::process::Command;

let output = Command::new("echo")
                     .arg("Hello world")
                     .output()
                     .expect("Failed to execute command");

assert_eq!(b"Hello world\n", output.stdout.as_slice());
```

--------------------------------

### Get Current Thread ID in Rust

Source: https://rustwiki.org/zh-CN/std/thread/struct.ThreadId

Demonstrates how to obtain the `ThreadId` of the current thread and compare it with the ID of another spawned thread. This example uses `thread::spawn` to create a new thread and `thread::current().id()` to get the ID of the current thread.

```rust
use std::thread;

let other_thread = thread::spawn(|| {
    thread::current().id()
});

let other_thread_id = other_thread.join().unwrap();
assert!(thread::current().id() != other_thread_id);
```

--------------------------------

### Create and Bind UnixListener (Rust)

Source: https://rustwiki.org/zh-CN/std/os/unix/net/struct.UnixListener

Demonstrates how to create and bind a `UnixListener` to a specified path, which is essential for setting up a server socket.

```rust
use std::os::unix::net::UnixListener;

let listener = match UnixListener::bind("/path/to/the/socket") {
    Ok(sock) => sock,
    Err(e) => {
        println!("Couldn't connect: {e:?}");
        return
    }
};
```

--------------------------------

### Example: Leaking a Ref (Nightly)

Source: https://rustwiki.org/zh-CN/std/cell/struct.Ref

An example showcasing the experimental Ref::leak function available on nightly Rust. It demonstrates borrowing from a RefCell, leaking the Ref to get a direct reference to the data, and then verifying that the original RefCell can still be borrowed immutably but not mutably.

```rust
#![feature(cell_leak)]
use std::cell::{RefCell, Ref};
let cell = RefCell::new(0);

let value = Ref::leak(cell.borrow());
assert_eq!(*value, 0);

assert!(cell.try_borrow().is_ok());
assert!(cell.try_borrow_mut().is_err());
```

--------------------------------

### Rust Spinlock Example using AtomicUsize

Source: https://rustwiki.org/zh-CN/std/sync/atomic/index

Demonstrates the creation and usage of a simple spinlock using `Arc<AtomicUsize>`. This example shows how to atomically modify the lock state and how another thread can wait for the lock to be released using a busy-wait loop with `hint::spin_loop()`.

```rust
use std::sync::Arc;
use std::sync::atomic::{AtomicUsize, Ordering};
use std::{hint, thread};

fn main() {
    let spinlock = Arc::new(AtomicUsize::new(1));

    let spinlock_clone = Arc::clone(&spinlock);
    let thread = thread::spawn(move|| {
        spinlock_clone.store(0, Ordering::SeqCst);
    });

    // Wait for the other thread to release the lock
    while spinlock.load(Ordering::SeqCst) != 0 {
        hint::spin_loop();
    }

    if let Err(panic) = thread.join() {
        println!("Thread had an error: {panic:?}");
    }
}
```

--------------------------------

### Rust: Get raw stat structure from file metadata (Linux)

Source: https://rustwiki.org/zh-CN/std/os/linux/fs/trait.MetadataExt

This example demonstrates how to get a reference to the underlying `stat` structure from `fs::Metadata` using the `as_raw_stat` method from the `MetadataExt` trait. Note that this method is deprecated in favor of other methods in the trait.

```rust
use std::fs;
use std::io;
use std::os::linux::fs::MetadataExt;

fn main() -> io::Result<()> {
    let meta = fs::metadata("some_file")?;
    let stat = meta.as_raw_stat();
    Ok(())
}
```

--------------------------------

### Rust NonZeroI8 MIN and MAX Constants Example

Source: https://rustwiki.org/zh-CN/std/num/struct.NonZeroI8

Shows the usage of the `MIN` and `MAX` constants for NonZeroI8. These constants represent the minimum and maximum representable values for a signed non-zero integer, which are `i8::MIN` and `i8::MAX` respectively. The example verifies their values using the `get()` method.

```rust
assert_eq!(NonZeroI8::MIN.get(), i8::MIN);
assert_eq!(NonZeroI8::MAX.get(), i8::MAX);
```

--------------------------------

### Get Current System Time Instance in Rust

Source: https://rustwiki.org/zh-CN/std/time/struct.SystemTime

A simple example demonstrating how to obtain a `SystemTime` instance representing the current moment using the `now()` function.

```rust
use std::time::SystemTime;

let sys_time = SystemTime::now();
```

--------------------------------

### Rust Example: Using std::writeln Macro

Source: https://rustwiki.org/zh-CN/std/macro.writeln

Demonstrates the usage of the std::writeln macro in Rust. This example shows how to write to a mutable buffer (Vec<u8>) with no arguments, a simple string, and a formatted string with arguments. It verifies the output against expected byte sequences.

```rust
use std::io::{Write, Result};

fn main() -> Result<()> {
    let mut w = Vec::new();
    writeln!(&mut w)?;
    writeln!(&mut w, "test")?;
    writeln!(&mut w, "formatted {}", "arguments")?;

    assert_eq!(&w[..], "\ntest\nformatted arguments\n".as_bytes());
    Ok(())
}
```

--------------------------------

### Mutating the Underlying OsStr Slice

Source: https://rustwiki.org/zh-CN/std/path/struct.Path

Demonstrates how to get a mutable reference to the underlying `OsStr` slice using `as_mut_os_str()` and modify it, for example, by converting to lowercase.

```rust
use std::path::{Path, PathBuf};

let mut path = PathBuf::from("Foo.TXT");

assert_ne!(path, Path::new("foo.txt"));

path.as_mut_os_str().make_ascii_lowercase();
assert_eq!(path, Path::new("foo.txt"));
```

--------------------------------

### AtomicBool fetch_xor Example in Rust

Source: https://rustwiki.org/zh-CN/std/sync/atomic/struct.AtomicBool

Demonstrates the fetch_xor method for AtomicBool, executing a logical XOR operation atomically. The examples show the return value (previous value) and the resulting state of the AtomicBool.

```rust
use std::sync::atomic::{AtomicBool, Ordering};

let foo = AtomicBool::new(true);
assert_eq!(foo.fetch_xor(false, Ordering::SeqCst), true);
assert_eq!(foo.load(Ordering::SeqCst), true);

let foo = AtomicBool::new(true);
assert_eq!(foo.fetch_xor(true, Ordering::SeqCst), true);
assert_eq!(foo.load(Ordering::SeqCst), false);

let foo = AtomicBool::new(false);
assert_eq!(foo.fetch_xor(false, Ordering::SeqCst), false);
assert_eq!(foo.load(Ordering::SeqCst), false);
```

--------------------------------

### Rust: Example of Using File::from_raw_fd

Source: https://rustwiki.org/zh-CN/std/os/fd/trait.FromRawFd

Demonstrates how to use the `File::from_raw_fd` method to create a `File` object from a raw file descriptor. This example highlights ownership transfer and safety precautions.

```rust
use std::fs::File;
#[cfg(any(unix, target_os = "wasi"))]
use std::os::fd::{FromRawFd, IntoRawFd, RawFd};

let f = File::open("foo.txt")?;
let raw_fd: RawFd = f.into_raw_fd();
// SAFETY: 没有其他函数可以调用 `from_raw_fd`，因此文件描述符只有一个所有者。
let f = unsafe { File::from_raw_fd(raw_fd) };
```

--------------------------------

### Example: Mapping a Ref to a component

Source: https://rustwiki.org/zh-CN/std/cell/struct.Ref

An example demonstrating the usage of Ref::map to create a new Ref pointing to a specific component of the borrowed data. It shows how to borrow from a RefCell, then use Ref::map to get a reference to a part of the data, and finally dereference the new Ref to access the value.

```rust
use std::cell::{RefCell, Ref};

let c = RefCell::new((5, 'b'));
let b1: Ref<'_, (u32, char)> = c.borrow();
let b2: Ref<'_, u32> = Ref::map(b1, |t| &t.0);
assert_eq!(*b2, 5)
```

--------------------------------

### Example: FilterMapping a Ref

Source: https://rustwiki.org/zh-CN/std/cell/struct.Ref

Illustrates the use of Ref::filter_map to obtain a Ref to an optional element within the borrowed data. The example shows borrowing a vector, then using filter_map to get a reference to the element at index 1, and asserting its value. If the element doesn't exist, the original Ref would be returned in an Err.

```rust
use std::cell::{RefCell, Ref};

let c = RefCell::new(vec![1, 2, 3]);
let b1: Ref<'_, Vec<u32>> = c.borrow();
let b2: Result<Ref<'_, u32>, _> = Ref::filter_map(b1, |v| v.get(1));
assert_eq!(*b2.unwrap(), 2);
```

--------------------------------

### Rust `print!` and `println!` Macros for Standard Output

Source: https://rustwiki.org/zh-CN/std/fmt/index

Shows examples of using the `print!` and `println!` macros in Rust to output formatted strings to the standard output (stdout). These macros, like `write!`, aim to minimize allocations.

```rust
print!("Hello {}!", "world");
println!("I have a newline {}", "character at the end");
```

--------------------------------

### Rust Path Ancestors

Source: https://rustwiki.org/zh-CN/std/path/struct.Path

This example demonstrates how to retrieve the ancestors of a given path using the `ancestors()` method. It iterates through the path components, starting from the path itself and going up to the root directory.

```rust
use std::path::Path;

let mut ancestors = Path::new("/foo/bar").ancestors();
assert_eq!(ancestors.next(), Some(Path::new("/foo/bar")));
assert_eq!(ancestors.next(), Some(Path::new("/foo")));
assert_eq!(ancestors.next(), Some(Path::new("/")));
assert_eq!(ancestors.next(), None);

let mut ancestors = Path::new("../foo/bar").ancestors();
assert_eq!(ancestors.next(), Some(Path::new("../foo/bar")));
assert_eq!(ancestors.next(), Some(Path::new("../foo")));
assert_eq!(ancestors.next(), Some(Path::new("..")));
assert_eq!(ancestors.next(), Some(Path::new("")));
assert_eq!(ancestors.next(), None);
```

--------------------------------

### Spawn a Child Process (Rust)

Source: https://rustwiki.org/zh-CN/std/process/struct.Command

Provides a basic example of spawning a child process using `Command::spawn`. This method executes the command and returns a `Child` handle, allowing for asynchronous execution. By default, stdin, stdout, and stderr are inherited from the parent. Error handling is managed with `expect`.

```rust
use std::process::Command;

Command::new("ls")
        .spawn()
        .expect("ls command failed to start");
```

--------------------------------

### Rust: Get inode number from file metadata (Linux)

Source: https://rustwiki.org/zh-CN/std/os/linux/fs/trait.MetadataExt

This example demonstrates how to obtain the inode number of a file using the `st_ino` method from the `MetadataExt` trait.

```rust
use std::fs;
use std::io;
use std::os::linux::fs::MetadataExt;

fn main() -> io::Result<()> {
    let meta = fs::metadata("some_file")?;
    println!("{}", meta.st_ino());
    Ok(())
}
```

--------------------------------

### Rust Example: Checking if a Prefix is Verbatim

Source: https://rustwiki.org/zh-CN/std/path/enum.Prefix

Shows how to use the `is_verbatim()` method on the `Prefix` enum in Rust to determine if a path prefix starts with `\?\`. This is useful for handling special path formats.

```rust
use std::path::Prefix::*;
use std::ffi::OsStr;

assert!(Verbatim(OsStr::new("pictures")).is_verbatim());
assert!(VerbatimUNC(OsStr::new("server"), OsStr::new("share")).is_verbatim());
assert!(VerbatimDisk(b'C').is_verbatim());
assert!(!DeviceNS(OsStr::new("BrainInterface")).is_verbatim());
assert!(!UNC(OsStr::new("server"), OsStr::new("share")).is_verbatim());
assert!(!Disk(b'C').is_verbatim());
```

--------------------------------

### Stdio::from(File)

Source: https://rustwiki.org/zh-CN/std/process/struct.Stdio

Converts a File into a Stdio configuration.

```APIDOC
## POST /std/process/Stdio/from_file

### Description
Converts a File into a Stdio configuration.

### Method
POST

### Endpoint
/std/process/Stdio/from_file

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **file** (object) - The File to convert.

### Request Example
```json
{
  "file": "<representation of File>"
}
```

### Response
#### Success Response (200)
- **Stdio** (object) - The converted Stdio configuration.

#### Response Example
```json
{
  "example": "Stdio object representing the converted File."
}
```
```

--------------------------------

### RwLock Usage Example

Source: https://rustwiki.org/zh-CN/std/sync/struct.RwLock

Demonstrates the basic usage of `RwLock` for managing shared data. It shows how to create a lock, acquire multiple read locks concurrently, and acquire a single write lock, along with assertions to verify the data's state.

```rust
use std::sync::RwLock;

let lock = RwLock::new(5);

// 可以一次持有许多 reader 锁
{
    let r1 = lock.read().unwrap();
    let r2 = lock.read().unwrap();
    assert_eq!(*r1, 5);
    assert_eq!(*r2, 5);
} // 此时将丢弃读锁

// 只能持有一个写锁，但是
{
    let mut w = lock.write().unwrap();
    *w += 1;
    assert_eq!(*w, 6);
} // 写锁在这里被丢弃
```

--------------------------------

### Rust RangeFrom contains Method Example

Source: https://rustwiki.org/zh-CN/std/ops/struct.RangeFrom

Illustrates the `contains` method of the `RangeFrom` struct in Rust. This method checks if a given item falls within the range defined by `start` and extends infinitely.

```rust
assert!(!(3..).contains(&2));
assert!( (3..).contains(&3));
assert!( (3..).contains(&1_000_000_000));

assert!( (0.0..).contains(&0.5));
assert!(!(0.0..).contains(&f32::NAN));
assert!(!(f32::NAN..).contains(&0.5));
```

--------------------------------

### Rust Macro std::format Usage Examples

Source: https://rustwiki.org/zh-CN/std/macro.format

Demonstrates common usage patterns for the std::format macro in Rust, including basic string creation, interpolation with positional arguments, and interpolation using named arguments.

```rust
format!("test");
format!("hello {}", "world!");
format!("x = {}, y = {y}", 10, y = 30);
let (x, y) = (1, 2);
format!("{x} + {y} = 3");
```

--------------------------------

### Rust: Example of creating and using RChunksExact

Source: https://rustwiki.org/zh-CN/std/slice/struct.RChunksExact

Demonstrates how to create an RChunksExact iterator from a slice and how to use its next() method to get chunks. The remainder() method is also shown to access any leftover elements.

```rust
let slice = ['l', 'o', 'r', 'e', 'm'];
let mut iter = slice.rchunks_exact(2);
assert_eq!(iter.remainder(), &['l'][..]);
assert_eq!(iter.next(), Some(&['e', 'm'][..]));
assert_eq!(iter.remainder(), &['l'][..]);
assert_eq!(iter.next(), Some(&['o', 'r'][..]));
assert_eq!(iter.remainder(), &['l'][..]);
assert_eq!(iter.next(), None);
assert_eq!(iter.remainder(), &['l'][..]);

```

--------------------------------

### Implement Display with Sign-Aware Zero Padding (Rust)

Source: https://rustwiki.org/zh-CN/std/fmt/struct.Formatter

Shows an example of implementing `fmt::Display` for a struct `Foo` where the `sign_aware_zero_pad()` formatter option is asserted to be true, along with width.

```rust
use std::fmt;

struct Foo(i32);

impl fmt::Display for Foo {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        assert!(formatter.sign_aware_zero_pad());
        assert_eq!(formatter.width(), Some(4));
        // 我们忽略格式化程序的选项。
        write!(formatter, "{}", self.0)
    }
}

assert_eq!(format!(
    "{:", "04"}", Foo(23)), "23"
);
```

--------------------------------

### Rust: Get file mode from file metadata (Linux)

Source: https://rustwiki.org/zh-CN/std/os/linux/fs/trait.MetadataExt

This example shows how to retrieve the file type and mode (permissions) using the `st_mode` method from the `MetadataExt` trait.

```rust
use std::fs;
use std::io;
use std::os::linux::fs::MetadataExt;

fn main() -> io::Result<()> {
    let meta = fs::metadata("some_file")?;
    println!("{}", meta.st_mode());
    Ok(())
}
```

--------------------------------

### Convert File to Stdio for Command Input (Rust Example)

Source: https://rustwiki.org/zh-CN/std/fs/struct.File

An example demonstrating how a `File` can be implicitly converted to `Stdio` when used as the standard input for a child process via `std::process::Command`.

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

--------------------------------

### Rust Path Extension

Source: https://rustwiki.org/zh-CN/std/path/struct.Path

This example demonstrates how to extract the file extension from a path using the `extension()` method. It returns `None` if there is no file name, no embedded dot, or if the file name starts with a dot and has no other dots.

```rust
use std::path::Path;

assert_eq!("rs", Path::new("foo.rs").extension().unwrap());
assert_eq!("gz", Path::new("foo.tar.gz").extension().unwrap());
```

--------------------------------

### Rust Formatting Trait Examples with Primitives

Source: https://rustwiki.org/zh-CN/std/fmt/index

Illustrates the difference between `fmt::Display` and `fmt::Debug` traits using primitive types and string literals. Shows how different formatting specifiers are applied to various data types.

```rust
assert_eq!(format!("{} {}", 3, 4), "3 4");
assert_eq!(format!("{} {}", 'a', 'b'), "a 'b'");
assert_eq!(format!("{} \"{}\"", "foo\n", "bar\n"), "foo\n \"bar\\n\"");
```

--------------------------------

### AtomicI32 fetch_min Example (Rust)

Source: https://rustwiki.org/zh-CN/std/sync/atomic/struct.AtomicI32

Demonstrates the `fetch_min` operation for `AtomicI32`. This atomically sets the value to the minimum of the current value and a given value, returning the previous value. It requires a memory ordering parameter.

```rust
use std::sync::atomic::{AtomicI32, Ordering};

let foo = AtomicI32::new(23);
assert_eq!(foo.fetch_min(42, Ordering::Relaxed), 23);
assert_eq!(foo.load(Ordering::Relaxed), 23);
assert_eq!(foo.fetch_min(22, Ordering::Relaxed), 23);
assert_eq!(foo.load(Ordering::Relaxed), 22);
```

```rust
use std::sync::atomic::{AtomicI32, Ordering};

let foo = AtomicI32::new(23);
let bar = 12;
let min_foo = foo.fetch_min(bar, Ordering::SeqCst).min(bar);
assert_eq!(min_foo, 12);
```

--------------------------------

### Rust: Get Underlying Thread Handle from ScopedJoinHandle

Source: https://rustwiki.org/zh-CN/std/thread/struct.ScopedJoinHandle

This example demonstrates how to retrieve the underlying `Thread` handle from a `ScopedJoinHandle`. This allows access to thread-specific information like its ID. It requires the `std::thread` module.

```rust
use std::thread;

thread::scope(|s| {
    let t = s.spawn(|| {
        println!("hello");
    });
    println!("thread id: {:?}", t.thread().id());
});
```

--------------------------------

### Create BufReader with Specific Capacity (Rust)

Source: https://rustwiki.org/zh-CN/std/io/struct.BufReader

Shows how to initialize a BufReader with a custom buffer capacity. This allows fine-tuning buffer size based on expected read patterns for potential performance gains.

```rust
use std::io::BufReader;
use std::fs::File;

fn main() -> std::io::Result<()> {
    let f = File::open("log.txt")?;
    let reader = BufReader::with_capacity(10, f);
    Ok(())
}
```
Tokens:
Raw