Async-Std

https://docs.rs/async-std/latest/async_std
Admin
async-std was designed as an async version of the Rust standard library, providing core abstractions...
Tokens:199,787
Snippets:2,293
Trust Score:9.7
Update:2 months ago
Show doc for...
Tokens:
Raw
### Result Stream Processing

Source: https://docs.rs/async-std/latest/async_std/io/type.Result.html

Example setup for processing Results within an async stream.

```rust
use async_std::prelude::*;
use async_std::stream;
```

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

### exec

Source: https://docs.rs/async-std/latest/async_std/os/unix/process/trait.CommandExt.html

Performs all the required setup by this Command, followed by calling the execvp syscall. On success, this function will not return.

```APIDOC
## fn exec(&mut self) -> Error

### Description
Performs all the required setup by this Command, followed by calling the execvp syscall. On success this function will not return, and otherwise it will return an error indicating why the exec failed.
```

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

### Usage example for eprint

Source: https://docs.rs/async-std/latest/async_std/macro.eprint.html

Demonstrates how to use the eprint macro to output an error message.

```rust
use async_std::eprint;

eprint!("Error: Could not complete task").await;
```

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

### Using println! for Standard Output

Source: https://docs.rs/async-std/latest/async_std/macro.println.html

Examples of using the println! macro to print text and formatted arguments to standard output.

```rust
use async_std::println;

println!().await; // prints just a newline
println!("hello there!").await;
println!("format {} arguments", "some").await;
```

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

### Timeout usage example

Source: https://docs.rs/async-std/latest/async_std/future/fn.timeout.html

Demonstrates how to use timeout to await a future that never completes.

```rust
use std::time::Duration;

use async_std::future;

let never = future::pending::<()>();
let dur = Duration::from_millis(5);
assert!(future::timeout(dur, never).await.is_err());
```

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

### SocketAddr Usage Example

Source: https://docs.rs/async-std/latest/async_std/net/enum.SocketAddr.html

Basic usage of creating and parsing a SocketAddr.

```rust
use std::net::{IpAddr, Ipv4Addr, SocketAddr};

let socket = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080);

assert_eq!("127.0.0.1:8080".parse(), Ok(socket));
assert_eq!(socket.port(), 8080);
assert_eq!(socket.is_ipv4(), true);
```

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

### Using writeln with a Buffer

Source: https://docs.rs/async-std/latest/async_std/macro.writeln.html

Example demonstrating how to write formatted data and newlines to a Vec buffer.

```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(())
}
```

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

### Configure Cargo features for async-std

Source: https://docs.rs/async-std/latest/async_std/index.html

Examples of how to enable specific features or compatibility layers in Cargo.toml.

```toml
[dependencies.async-std]
version = "1.7.0"
features = ["unstable"]
```

```toml
[dependencies.async-std]
version = "1.7.0"
features = ["attributes"]
```

```toml
[dependencies.async-std]
version = "1.7.0"
features = ["tokio1"]
```

```toml
[dependencies.async-std]
version = "1.7.0"
features = ["tokio02"]
```

```toml
[dependencies.async-std]
version = "1.7.0"
features = ["tokio03"]
```

```toml
[dependencies.async-std]
version = "1.7.0"
default-features = false
features = ["std"]
```

```toml
[dependencies.async-std]
version = "1.7.0"
default-features = false
features = ["alloc"]
```

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

### Get creation time

Source: https://docs.rs/async-std/latest/async_std/fs/struct.Metadata.html

Returns the creation time of the file.

```rust
use async_std::fs;

let metadata = fs::metadata("a.txt").await?;
println!("{:?}", metadata.created());
```

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

### Read file to string example

Source: https://docs.rs/async-std/latest/async_std/fs/fn.read_to_string.html

Demonstrates reading the contents of 'a.txt' into a string variable using the await keyword.

```rust
use async_std::fs;

let contents = fs::read_to_string("a.txt").await?;
```

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

### Accessing Address Constants

Source: https://docs.rs/async-std/latest/async_std/net/struct.Ipv4Addr.html

Examples of using predefined constants for IPv4 addresses.

```rust
use std::net::Ipv4Addr;

assert_eq!(Ipv4Addr::BITS, 32);
```

```rust
use std::net::Ipv4Addr;

let addr = Ipv4Addr::LOCALHOST;
assert_eq!(addr, Ipv4Addr::new(127, 0, 0, 1));
```

```rust
use std::net::Ipv4Addr;

let addr = Ipv4Addr::UNSPECIFIED;
assert_eq!(addr, Ipv4Addr::new(0, 0, 0, 0));
```

```rust
use std::net::Ipv4Addr;

let addr = Ipv4Addr::BROADCAST;
assert_eq!(addr, Ipv4Addr::new(255, 255, 255, 255));
```

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

### Demonstrate sequential execution with global variables

Source: https://docs.rs/async-std/latest/async_std/sync/index.html

Example showing how global static variables behave in a single-threaded context without synchronization.

```rust
static mut A: u32 = 0;
static mut B: u32 = 0;
static mut C: u32 = 0;

fn main() {
    unsafe {
        A = 3;
        B = 4;
        A = A + B;
        C = B;
        println!("{} {} {}", A, B, C);
        C = A;
    }
}
```

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

### Get mutable reference with Arc::get_mut_unchecked

Source: https://docs.rs/async-std/latest/async_std/sync/struct.Arc.html

Provides an unsafe way to get a mutable reference without checking for other pointers. Requires the nightly feature get_mut_unchecked.

```rust
#![feature(get_mut_unchecked)]

use std::sync::Arc;

let mut x = Arc::new(String::new());
unsafe {
    Arc::get_mut_unchecked(&mut x).push_str("foo")
}
assert_eq!(*x, "foo");
```

```rust
#![feature(get_mut_unchecked)]

use std::sync::Arc;

let x: Arc<str> = Arc::from("Hello, world!");
let mut y: Arc<[u8]> = x.clone().into();
unsafe {
    // this is Undefined Behavior, because x's inner type is str, not [u8]
    Arc::get_mut_unchecked(&mut y).fill(0xff); // 0xff is invalid in UTF-8
}
println!("{}", &*x); // Invalid UTF-8 in a str
```

```rust
#![feature(get_mut_unchecked)]

use std::sync::Arc;

let x: Arc<&str> = Arc::new("Hello, world!");
{
    let s = String::from("Oh, no!");
    let mut y: Arc<&str> = x.clone();
    unsafe {
        // this is Undefined Behavior, because x's inner type
        // is &'long str, not &'short str
        *Arc::get_mut_unchecked(&mut y) = &s;
    }
}
println!("{}", &*x); // Use-after-free
```

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

### Spawn a process with Command

Source: https://docs.rs/async-std/latest/async_std/process/struct.Command.html

Demonstrates spawning a process while handling platform-specific command differences.

```rust
use async_process::Command;

let output = if cfg!(target_os = "windows") {
    Command::new("cmd").args(&["/C", "echo hello"]).output().await?
} else {
    Command::new("sh").arg("-c").arg("echo hello").output().await?
};
```

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

### Create a Path

Source: https://docs.rs/async-std/latest/async_std/path/struct.Path.html

Shows how to initialize a Path from string slices, Strings, or other Paths.

```rust
use async_std::path::Path;

Path::new("foo.txt");
```

```rust
use async_std::path::Path;

let string = String::from("foo.txt");
let from_string = Path::new(&string);
let from_path = Path::new(&from_string);
assert_eq!(from_string, from_path);
```

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

### get_ref()

Source: https://docs.rs/async-std/latest/async_std/io/struct.Take.html

Gets a reference to the underlying reader.

```APIDOC
## pub fn get_ref(&self) -> &T

### Description
Returns a reference to the underlying reader.
```

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

### get_mut()

Source: https://docs.rs/async-std/latest/async_std/io/struct.Take.html

Gets a mutable reference to the underlying reader.

```APIDOC
## pub fn get_mut(&mut self) -> &mut T

### Description
Returns a mutable reference to the underlying reader. Care should be taken to avoid modifying the internal I/O state of the underlying reader as it may corrupt the internal limit of the Take instance.
```

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

### take

Source: https://docs.rs/async-std/latest/async_std/io/prelude/trait.ReadExt.html

Creates an adaptor that reads at most a specified number of bytes.

```APIDOC
## fn take(self, limit: u64) -> Take<Self>

### Description
Creates an adaptor which will read at most `limit` bytes from the reader, after which it will return EOF.
```

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

### Cursor::get_ref

Source: https://docs.rs/async-std/latest/async_std/io/struct.Cursor.html

Gets a reference to the underlying value.

```APIDOC
## pub fn get_ref(&self) -> &T

### Description
Gets a reference to the underlying value in this cursor.
```

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

### Importing the Prelude

Source: https://docs.rs/async-std/latest/async_std/prelude/index.html

How to import the async-std prelude to access commonly used traits and macros.

```APIDOC
## Importing the Prelude

### Description
To use the commonly used traits and macros provided by async-std, import the prelude module.

### Usage
```rust
use async_std::prelude::*;
```
```

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

### BufWriter::get_ref

Source: https://docs.rs/async-std/latest/async_std/io/struct.BufWriter.html

Gets a reference to the underlying writer.

```APIDOC
## pub fn get_ref(&self) -> &W

### Description
Gets a reference to the underlying writer.
```

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

### Usage example for eprintln

Source: https://docs.rs/async-std/latest/async_std/macro.eprintln.html

Basic usage of the eprintln macro to output an error message to standard error.

```rust
use async_std::eprintln;

eprintln!("Error: Could not complete task").await;
```

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

### get_ref

Source: https://docs.rs/async-std/latest/async_std/io/struct.Chain.html

Gets references to the underlying readers in this Chain.

```APIDOC
## pub fn get_ref(&self) -> (&T, &U)

### Description
Gets references to the underlying readers in this `Chain`.

### Example
```rust
use async_std::prelude::*;
use async_std::fs::File;

let foo_file = File::open("foo.txt").await?;
let bar_file = File::open("bar.txt").await?;

let chain = foo_file.chain(bar_file);
let (foo_file, bar_file) = chain.get_ref();
```
```

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

### pub async fn symlink_dir<P: AsRef<Path>, Q: AsRef<Path>>(src: P, dst: Q) -> Result<()>

Source: https://docs.rs/async-std/latest/async_std/os/windows/fs/fn.symlink_dir.html

Creates a new directory symbolic link on the filesystem. The dst path will be a directory symbolic link pointing to the src path.

```APIDOC
## Function: symlink_dir

### Description
Creates a new directory symbolic link on the filesystem. The `dst` path will be a directory symbolic link pointing to the `src` path.

### Signature
`pub async fn symlink_dir<P: AsRef<Path>, Q: AsRef<Path>>(src: P, dst: Q) -> Result<()>`

### Parameters
- **src** (P: AsRef<Path>) - The path to the existing directory.
- **dst** (Q: AsRef<Path>) - The path where the symbolic link will be created.

### Example
```rust
use async_std::os::windows::fs::symlink_dir;

symlink_dir("a", "b").await?;
```
```

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

### fn take(self, limit: u64) -> Take<Self>

Source: https://docs.rs/async-std/latest/async_std/io/struct.Take.html

Creates an adaptor which will read at most `limit` bytes from the underlying reader.

```APIDOC
## fn take(self, limit: u64) -> Take<Self>

### Description
Creates an adaptor which will read at most `limit` bytes from the underlying reader. This is useful for limiting the amount of data read from a stream.

### Parameters
- **limit** (u64) - Required - The maximum number of bytes to read from the stream.
```

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

### starts_with

Source: https://docs.rs/async-std/latest/async_std/io/struct.IoSlice.html

Checks if the slice starts with a given prefix.

```APIDOC
## pub fn starts_with(&self, needle: &[T]) -> bool

### Description
Returns true if needle is a prefix of the slice or equal to the slice.
```

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

### Create and write to a file

Source: https://docs.rs/async-std/latest/async_std/fs/index.html

Demonstrates creating a new file and writing bytes to it asynchronously.

```rust
use async_std::fs::File;
use async_std::prelude::*;

let mut file = File::create("a.txt").await?;
file.write_all(b"Hello, world!").await?;
```

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

### Arc::weak_count

Source: https://docs.rs/async-std/latest/async_std/sync/struct.Arc.html

Gets the number of Weak pointers to this allocation.

```APIDOC
## pub fn weak_count(this: &Arc<T, A>) -> usize

### Description
Gets the number of Weak pointers to this allocation. Note that another thread can change the weak count at any time.

### Parameters
- **this** (&Arc<T, A>) - Required - The Arc instance to query.
```

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

### multicast_loop_v6

Source: https://docs.rs/async-std/latest/async_std/net/struct.UdpSocket.html

Gets or sets the value of the IPV6_MULTICAST_LOOP option for this socket.

```APIDOC
## pub fn multicast_loop_v6(&self) -> Result<bool>
## pub fn set_multicast_loop_v6(&self, on: bool) -> Result<()>

### Description
Gets or sets the value of the IPV6_MULTICAST_LOOP option for this socket. Controls whether this socket sees the multicast packets it sends itself.
```

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

### take

Source: https://docs.rs/async-std/latest/async_std/stream/struct.Filter.html

Creates a stream that yields its first n elements.

```APIDOC
## fn take(self, n: usize) -> Take<Self>

### Description
Limits the stream to yield only the first n elements before terminating.

### Parameters
- **n** (usize) - Required - The maximum number of elements to yield.

### Returns
- **Take<Self>** - A stream that terminates after n elements.
```

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

### OpenOptions Configuration Methods

Source: https://docs.rs/async-std/latest/async_std/fs/struct.OpenOptions.html

Methods to configure the file access and creation behavior.

```APIDOC
### Configuration Methods

- **read(read: bool) -> &mut OpenOptions**: Configures read mode.
- **write(write: bool) -> &mut OpenOptions**: Configures write mode.
- **append(append: bool) -> &mut OpenOptions**: Configures append mode.
- **truncate(truncate: bool) -> &mut OpenOptions**: Configures truncation to 0 bytes.
- **create(create: bool) -> &mut OpenOptions**: Creates the file if it does not exist.
- **create_new(create_new: bool) -> &mut OpenOptions**: Creates a new file, failing if it already exists.
```

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

### multicast_ttl_v4

Source: https://docs.rs/async-std/latest/async_std/net/struct.UdpSocket.html

Gets or sets the value of the IP_MULTICAST_TTL option for this socket.

```APIDOC
## pub fn multicast_ttl_v4(&self) -> Result<u32>
## pub fn set_multicast_ttl_v4(&self, ttl: u32) -> Result<()>

### Description
Gets or sets the value of the IP_MULTICAST_TTL option for this socket. Indicates the time-to-live value of outgoing multicast packets for this socket.
```

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

### multicast_loop_v4

Source: https://docs.rs/async-std/latest/async_std/net/struct.UdpSocket.html

Gets or sets the value of the IP_MULTICAST_LOOP option for this socket.

```APIDOC
## pub fn multicast_loop_v4(&self) -> Result<bool>
## pub fn set_multicast_loop_v4(&self, on: bool) -> Result<()>

### Description
Gets or sets the value of the IP_MULTICAST_LOOP option for this socket. If enabled, multicast packets will be looped back to the local socket.
```

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

### broadcast

Source: https://docs.rs/async-std/latest/async_std/net/struct.UdpSocket.html

Gets or sets the value of the SO_BROADCAST option for this socket.

```APIDOC
## pub fn broadcast(&self) -> Result<bool>
## pub fn set_broadcast(&self, on: bool) -> Result<()>

### Description
Gets or sets the value of the SO_BROADCAST option for this socket. When enabled, this socket is allowed to send packets to a broadcast address.
```

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

### Importing the I/O prelude

Source: https://docs.rs/async-std/latest/async_std/io/prelude/index.html

Use this glob import to bring common I/O traits into scope for modules performing heavy I/O operations.

```rust
use async_std::io::prelude::*;
```

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

### Creating a new BufReader

Source: https://docs.rs/async-std/latest/async_std/io/struct.BufReader.html

Initializes a BufReader with default capacity.

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

let f = BufReader::new(File::open("a.txt").await?);
```

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

### Cursor::get_mut

Source: https://docs.rs/async-std/latest/async_std/io/struct.Cursor.html

Gets a mutable reference to the underlying value.

```APIDOC
## pub fn get_mut(&mut self) -> &mut T

### Description
Gets a mutable reference to the underlying value in this cursor. Care should be taken to avoid modifying the internal I/O state of the underlying value as it may corrupt this cursor’s position.
```

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

### Create a directory asynchronously

Source: https://docs.rs/async-std/latest/async_std/fs/struct.DirBuilder.html

Executes the directory creation process using the configured builder settings.

```rust
use async_std::fs::DirBuilder;

DirBuilder::new()
    .recursive(true)
    .create("./some/directory")
    .await?;
```

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

### BufWriter::get_mut

Source: https://docs.rs/async-std/latest/async_std/io/struct.BufWriter.html

Gets a mutable reference to the underlying writer.

```APIDOC
## pub fn get_mut(&mut self) -> &mut W

### Description
Gets a mutable reference to the underlying writer. It is inadvisable to directly write to the underlying writer.
```

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

### Display a path using format!

Source: https://docs.rs/async-std/latest/async_std/path/struct.Display.html

Use the display method on a Path to create a Display instance for printing.

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

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

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

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

### get_mut

Source: https://docs.rs/async-std/latest/async_std/io/struct.Chain.html

Gets mutable references to the underlying readers in this Chain.

```APIDOC
## pub fn get_mut(&mut self) -> (&mut T, &mut U)

### Description
Gets mutable references to the underlying readers in this `Chain`. Care should be taken to avoid modifying the internal I/O state of the underlying readers as doing so may corrupt the internal state of this `Chain`.

### Example
```rust
use async_std::prelude::*;
use async_std::fs::File;

let foo_file = File::open("foo.txt").await?;
let bar_file = File::open("bar.txt").await?;

let mut chain = foo_file.chain(bar_file);
let (foo_file, bar_file) = chain.get_mut();
```
```

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

### Listen for incoming connections

Source: https://docs.rs/async-std/latest/async_std/os/unix/net/struct.UnixListener.html

Demonstrates binding to a socket path and processing incoming connections using an async stream.

```rust
use async_std::os::unix::net::UnixListener;
use async_std::prelude::*;

let listener = UnixListener::bind("/tmp/socket").await?;
let mut incoming = listener.incoming();

while let Some(stream) = incoming.next().await {
    let mut stream = stream?;
    stream.write_all(b"hello world").await?;
}
```

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

### pub async fn hard_link<P: AsRef<Path>, Q: AsRef<Path>>(from: P, to: Q) -> Result<()>

Source: https://docs.rs/async-std/latest/async_std/fs/fn.hard_link.html

Creates a hard link on the filesystem where the 'to' path becomes a link pointing to the 'from' path.

```APIDOC
## hard_link

### Description
Creates a hard link on the filesystem. The `to` path will be a link pointing to the `from` path. Note that operating systems often require these two paths to be located on the same filesystem.

### Signature
`pub async fn hard_link<P: AsRef<Path>, Q: AsRef<Path>>(from: P, to: Q) -> Result<()>`

### Parameters
- **from** (P: AsRef<Path>) - The source path to the existing file.
- **to** (Q: AsRef<Path>) - The destination path for the new hard link.

### Errors
- `src` does not point to an existing file.
- Some other I/O error occurred.

### Example
```rust
use async_std::fs;

fs::hard_link("a.txt", "b.txt").await?;
```
```

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

### Get file permissions

Source: https://docs.rs/async-std/latest/async_std/fs/struct.Metadata.html

Returns the permissions associated with the file.

```rust
use async_std::fs;

let metadata = fs::metadata("a.txt").await?;
println!("{:?}", metadata.permissions());
```

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

### Get file size

Source: https://docs.rs/async-std/latest/async_std/fs/struct.Metadata.html

Returns the size of the file in bytes.

```rust
use async_std::fs;

let metadata = fs::metadata("a.txt").await?;
println!("{}", metadata.len());
```

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

### as_mut

Source: https://docs.rs/async-std/latest/async_std/pin/struct.Pin.html

Gets a mutable reference to the pinned value this Pin points to.

```APIDOC
## pub fn as_mut(&mut self) -> Pin<&mut <Ptr as Deref>::Target>

### Description
Gets a mutable reference to the pinned value this Pin<Ptr> points to. This is useful when doing multiple calls to functions that consume the pinning pointer.

### Parameters
- **self** (&mut self) - Required - The Pin instance.
```

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

### as_ref

Source: https://docs.rs/async-std/latest/async_std/pin/struct.Pin.html

Gets a shared reference to the pinned value this Pin points to.

```APIDOC
## pub fn as_ref(&self) -> Pin<&<Ptr as Deref>::Target>

### Description
Gets a shared reference to the pinned value this Pin points to. This is a generic method to go from &Pin<Pointer<T>> to Pin<&T>.

### Parameters
- **self** (&self) - Required - The Pin instance.
```

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

### Configure create mode

Source: https://docs.rs/async-std/latest/async_std/fs/struct.OpenOptions.html

Creates the file if it does not exist. Requires write or append mode.

```rust
use async_std::fs::OpenOptions;

let file = OpenOptions::new()
    .write(true)
    .create(true)
    .open("a.txt")
    .await?;
```

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

### TcpStream::nodelay / set_nodelay

Source: https://docs.rs/async-std/latest/async_std/net/struct.TcpStream.html

Gets or sets the TCP_NODELAY option on the socket.

```APIDOC
## pub fn nodelay(&self) -> Result<bool>
## pub fn set_nodelay(&self, nodelay: bool) -> Result<()>

### Description
Gets or sets the TCP_NODELAY option. When set, this disables the Nagle algorithm, ensuring segments are sent as soon as possible.
```

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

### TcpStream::ttl / set_ttl

Source: https://docs.rs/async-std/latest/async_std/net/struct.TcpStream.html

Gets or sets the IP_TTL option for the socket.

```APIDOC
## pub fn ttl(&self) -> Result<u32>
## pub fn set_ttl(&self, ttl: u32) -> Result<()>

### Description
Gets or sets the value of the IP_TTL option for this socket, which defines the time-to-live field for packets sent from this socket.
```

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

### Get Port Number

Source: https://docs.rs/async-std/latest/async_std/net/enum.SocketAddr.html

Retrieving the port number from a socket address.

```rust
use std::net::{IpAddr, Ipv4Addr, SocketAddr};

let socket = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080);
assert_eq!(socket.port(), 8080);
```

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

### Builder::new

Source: https://docs.rs/async-std/latest/async_std/task/struct.Builder.html

Creates a new instance of the task builder.

```APIDOC
## pub fn new() -> Builder

### Description
Creates a new builder instance to configure task settings.
```

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

### Spawn a process

Source: https://docs.rs/async-std/latest/async_std/process/struct.Command.html

Executes the command and returns a Child handle.

```rust
use async_process::Command;

let child = Command::new("ls").spawn()?;
```

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

### Get IP Address

Source: https://docs.rs/async-std/latest/async_std/net/enum.SocketAddr.html

Retrieving the IP address from a socket address.

```rust
use std::net::{IpAddr, Ipv4Addr, SocketAddr};

let socket = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080);
assert_eq!(socket.ip(), IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)));
```

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

### OpenOptions::open

Source: https://docs.rs/async-std/latest/async_std/fs/struct.OpenOptions.html

Opens a file at the specified path using the configured options.

```APIDOC
### pub fn open<P: AsRef<Path>>(&self, path: P) -> impl Future<Output = Result<File>>

Opens the file at the given path with the options configured on this builder instance.
```

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

### Get access time

Source: https://docs.rs/async-std/latest/async_std/fs/struct.Metadata.html

Returns the last access time of the file.

```rust
use async_std::fs;

let metadata = fs::metadata("a.txt").await?;
println!("{:?}", metadata.accessed());
```

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

### DirBuilder::create()

Source: https://docs.rs/async-std/latest/async_std/fs/struct.DirBuilder.html

Creates a directory at the specified path using the configured options.

```APIDOC
## pub fn create<P: AsRef<Path>>(&self, path: P) -> impl Future<Output = Result<()>>

### Description
Creates a directory with the configured options. It is an error if the directory already exists unless recursive mode is enabled.

### Parameters
- **path** (P: AsRef<Path>) - Required - The path where the directory should be created.

### Errors
- Returns an error if the path already exists (and recursive is false), if permissions are insufficient, or if an I/O error occurs.
```

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

### Get modification time

Source: https://docs.rs/async-std/latest/async_std/fs/struct.Metadata.html

Returns the last modification time of the file.

```rust
use async_std::fs;

let metadata = fs::metadata("a.txt").await?;
println!("{:?}", metadata.modified());
```

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

### Using the print macro

Source: https://docs.rs/async-std/latest/async_std/macro.print.html

Demonstrates printing multiple segments to the same line and flushing the output buffer.

```rust
use async_std::io;
use async_std::prelude::*;
use async_std::print;

print!("this ").await;
print!("will ").await;
print!("be ").await;
print!("on ").await;
print!("the ").await;
print!("same ").await;
print!("line ").await;

io::stdout().flush().await.unwrap();

print!("this string has a newline, why not choose println! instead?\n").await;

io::stdout().flush().await.unwrap();
```

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

### Get the number of senders

Source: https://docs.rs/async-std/latest/async_std/channel/struct.Sender.html

Returns the count of active senders for the channel.

```rust
use async_channel::unbounded;

let (s, r) = unbounded::<()>();
assert_eq!(s.sender_count(), 1);

let s2 = s.clone();
assert_eq!(s.sender_count(), 2);
```

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

### Get the number of receivers

Source: https://docs.rs/async-std/latest/async_std/channel/struct.Sender.html

Returns the count of active receivers for the channel.

```rust
use async_channel::unbounded;

let (s, r) = unbounded::<()>();
assert_eq!(s.receiver_count(), 1);

let r2 = r.clone();
assert_eq!(s.receiver_count(), 2);
```

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

### Creating a new RwLock

Source: https://docs.rs/async-std/latest/async_std/sync/struct.RwLock.html

Initializes a new RwLock instance.

```rust
use async_lock::RwLock;

let lock = RwLock::new(0);
```

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

### delay

Source: https://docs.rs/async-std/latest/async_std/prelude/trait.StreamExt.html

Creates a stream that is delayed before it starts yielding items (unstable).

```APIDOC
## fn delay(self, dur: Duration) -> Delay<Self>

### Description
Creates a stream that is delayed before it starts yielding items. This method is available on unstable versions.
```

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

### OpenOptions::new

Source: https://docs.rs/async-std/latest/async_std/fs/struct.OpenOptions.html

Creates a new, blank set of options where all flags are initially set to false.

```APIDOC
### pub fn new() -> OpenOptions

Creates a blank set of options for configuring file access.
```

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

### Sort a mutable slice

Source: https://docs.rs/async-std/latest/async_std/io/struct.IoSliceMut.html

Example of sorting a mutable slice of integers.

```rust
let mut v = [4, -5, 1, -3, 2];
```

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

### Open a file for reading and writing with creation

Source: https://docs.rs/async-std/latest/async_std/fs/struct.OpenOptions.html

Opens a file for both reading and writing, creating it if it does not exist.

```rust
use async_std::fs::OpenOptions;

let file = OpenOptions::new()
    .read(true)
    .write(true)
    .create(true)
    .open("a.txt")
    .await?;
```

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

### Splitting the first element

Source: https://docs.rs/async-std/latest/async_std/io/struct.IoSliceMut.html

Examples of removing the first element from a slice.

```rust
let mut slice: &[_] = &['a', 'b', 'c'];
let first = slice.split_off_first().unwrap();

assert_eq!(slice, &['b', 'c']);
assert_eq!(first, &'a');
```

```rust
let mut slice: &mut [_] = &mut ['a', 'b', 'c'];
let first = slice.split_off_first_mut().unwrap();
*first = 'd';

assert_eq!(slice, &['b', 'c']);
assert_eq!(first, &'d');
```

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

### Configure working directory and stdin

Source: https://docs.rs/async-std/latest/async_std/process/struct.Command.html

Sets the working directory or standard input configuration for the process.

```rust
use async_process::Command;

let mut cmd = Command::new("ls");
cmd.current_dir("/");
```

```rust
use async_process::{Command, Stdio};

let mut cmd = Command::new("cat");
cmd.stdin(Stdio::null());
```

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

### Echo Server with TcpListener

Source: https://docs.rs/async-std/latest/async_std/net/struct.TcpListener.html

Demonstrates creating a TCP listener and echoing incoming data back to the client using an async stream.

```rust
use async_std::io;
use async_std::net::TcpListener;
use async_std::prelude::*;

let listener = TcpListener::bind("127.0.0.1:8080").await?;
let mut incoming = listener.incoming();

while let Some(stream) = incoming.next().await {
    let stream = stream?;
    let (reader, writer) = &mut (&stream, &stream);
    io::copy(reader, writer).await?;
}
```

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

### as_deref_mut

Source: https://docs.rs/async-std/latest/async_std/pin/struct.Pin.html

Gets Pin<&mut T> to the underlying pinned value from this nested Pin-pointer.

```APIDOC
## pub fn as_deref_mut(self: Pin<&mut Pin<Ptr>>) -> Pin<&mut <Ptr as Deref>::Target>

### Description
Gets Pin<&mut T> to the underlying pinned value from this nested Pin-pointer. This is a generic method to go from Pin<&mut Pin<Pointer<T>>> to Pin<&mut T>.

### Parameters
- **self** (Pin<&mut Pin<Ptr>>) - Required - The nested Pin instance.
```

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

### Get Process ID

Source: https://docs.rs/async-std/latest/async_std/process/struct.Child.html

Retrieves the OS-assigned process identifier for the child process.

```rust
use async_process::Command;

let mut child = Command::new("ls").spawn()?;
println!("id: {}", child.id());
```

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

### Builder::spawn

Source: https://docs.rs/async-std/latest/async_std/task/struct.Builder.html

Spawns a task with the configured settings.

```APIDOC
## pub fn spawn<F, T>(self, future: F) -> Result<JoinHandle<T>>

### Description
Spawns a task with the configured settings. Requires the future to be Send and 'static.
```

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

### Comparing method-call and fully qualified syntax

Source: https://docs.rs/async-std/latest/async_std/sync/struct.Arc.html

Illustrates the difference between method-call syntax and fully qualified syntax for cloning an Arc.

```rust
use std::sync::Arc;

let arc = Arc::new(());
// Method-call syntax
let arc2 = arc.clone();
// Fully qualified syntax
let arc3 = Arc::clone(&arc);
```

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

### Get local socket address

Source: https://docs.rs/async-std/latest/async_std/os/unix/net/struct.UnixListener.html

Retrieves the local address that the UnixListener is bound to.

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

let listener = UnixListener::bind("/tmp/socket").await?;
let addr = listener.local_addr()?;
```

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

### Parse path components

Source: https://docs.rs/async-std/latest/async_std/path/index.html

Demonstrates how to create a Path slice and extract parent directories, file stems, and extensions.

```rust
use async_std::path::Path;
use std::ffi::OsStr;

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

let parent = path.parent();
assert_eq!(parent, Some(Path::new("/tmp/foo")));

let file_stem = path.file_stem();
assert_eq!(file_stem, Some(OsStr::new("bar")));

let extension = path.extension();
assert_eq!(extension, Some(OsStr::new("txt")));
```

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

### Get local address

Source: https://docs.rs/async-std/latest/async_std/net/struct.UdpSocket.html

Retrieves the local address the socket is currently bound to.

```rust
use async_std::net::UdpSocket;

let socket = UdpSocket::bind("127.0.0.1:0").await?;
let addr = socket.local_addr()?;
```

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

### Builder::local

Source: https://docs.rs/async-std/latest/async_std/task/struct.Builder.html

Spawns a task locally with the configured settings.

```APIDOC
## pub fn local<F, T>(self, future: F) -> Result<JoinHandle<T>>

### Description
Spawns a task locally. Available under the 'unstable' feature flag.
```

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

### Get Peer Address

Source: https://docs.rs/async-std/latest/async_std/net/struct.TcpStream.html

Retrieve the remote socket address the stream is connected to.

```rust
use async_std::net::TcpStream;

let stream = TcpStream::connect("127.0.0.1:8080").await?;
let peer = stream.peer_addr()?;
```

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

### Create directories asynchronously

Source: https://docs.rs/async-std/latest/async_std/fs/fn.create_dir_all.html

Creates a directory path including all missing parent directories. Requires the default feature flag and a supported target OS.

```rust
use async_std::fs;

fs::create_dir_all("./some/directory").await?;
```

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

### Get Local Address

Source: https://docs.rs/async-std/latest/async_std/net/struct.TcpStream.html

Retrieve the local socket address associated with the stream.

```rust
use async_std::net::TcpStream;

let stream = TcpStream::connect("127.0.0.1:8080").await?;
let addr = stream.local_addr()?;
```

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

### Get a reference to the underlying reader

Source: https://docs.rs/async-std/latest/async_std/io/struct.Take.html

Retrieves an immutable reference to the wrapped reader.

```rust
use async_std::prelude::*;
use async_std::fs::File;

let file = File::open("foo.txt").await?;

let mut buffer = [0; 5];
let mut handle = file.take(5);
handle.read(&mut buffer).await?;

let file = handle.get_ref();
```

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

### Check slice prefixes with starts_with

Source: https://docs.rs/async-std/latest/async_std/io/struct.IoSlice.html

Determines if a slice starts with a given prefix.

```rust
let v = [10, 40, 30];
assert!(v.starts_with(&[10]));
assert!(v.starts_with(&[10, 40]));
assert!(v.starts_with(&v));
assert!(!v.starts_with(&[50]));
assert!(!v.starts_with(&[10, 50]));
```

```rust
let v = &[10, 40, 30];
assert!(v.starts_with(&[]));
let v: &[u8] = &[];
assert!(v.starts_with(&[]));
```

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

### Create a symbolic link

Source: https://docs.rs/async-std/latest/async_std/os/unix/fs/fn.symlink.html

Creates a symbolic link named b.txt pointing to a.txt.

```rust
use async_std::os::unix::fs::symlink;

symlink("a.txt", "b.txt").await?;
```

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

### Importing the async-std prelude

Source: https://docs.rs/async-std/latest/async_std/prelude/index.html

Use this statement to bring the most commonly used traits and macros into scope.

```rust
use async_std::prelude::*;
```

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

### Get File Name

Source: https://docs.rs/async-std/latest/async_std/path/struct.PathBuf.html

Extract the final component of the path, such as a file or directory name.

```rust
use std::ffi::OsStr;

use async_std::path::Path;

assert_eq!(Some(OsStr::new("bin")), Path::new("/usr/bin/").file_name());
assert_eq!(Some(OsStr::new("foo.txt")), Path::new("tmp/foo.txt").file_name());
assert_eq!(Some(OsStr::new("foo.txt")), Path::new("foo.txt/.").file_name());
assert_eq!(Some(OsStr::new("foo.txt")), Path::new("foo.txt/.//").file_name());
assert_eq!(None, Path::new("foo.txt/..").file_name());
assert_eq!(None, Path::new("/").file_name());
```

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

### pub async fn symlink<P: AsRef<Path>, Q: AsRef<Path>>(src: P, dst: Q) -> Result<()>

Source: https://docs.rs/async-std/latest/async_std/os/unix/fs/fn.symlink.html

Creates a new symbolic link on the filesystem. The dst path will be a symbolic link pointing to the src path. This function is an async version of std::os::unix::fs::symlink.

```APIDOC
## Function: symlink

### Description
Creates a new symbolic link on the filesystem. The `dst` path will be a symbolic link pointing to the `src` path.

### Signature
`pub async fn symlink<P: AsRef<Path>, Q: AsRef<Path>>(src: P, dst: Q) -> Result<()>`

### Parameters
- **src** (P: AsRef<Path>) - The path to the existing file or directory.
- **dst** (Q: AsRef<Path>) - The path where the symbolic link will be created.

### Example
```rust
use async_std::os::unix::fs::symlink;

symlink("a.txt", "b.txt").await?;
```
```

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

### Basic UnixDatagram usage

Source: https://docs.rs/async-std/latest/async_std/os/unix/net/struct.UnixDatagram.html

Demonstrates binding a socket to a path, sending data, and receiving data from a peer.

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

let socket = UnixDatagram::bind("/tmp/socket1").await?;
socket.send_to(b"hello world", "/tmp/socket2").await?;

let mut buf = vec![0u8; 1024];
let (n, peer) = socket.recv_from(&mut buf).await?;
```

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

### Get process status

Source: https://docs.rs/async-std/latest/async_std/process/struct.Command.html

Executes the command and waits for it to exit, returning the exit status.

```rust
use async_process::Command;

let status = Command::new("cp")
    .arg("a.txt")
    .arg("b.txt")
    .status()
    .await?;
```

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

### Create a bounded channel

Source: https://docs.rs/async-std/latest/async_std/channel/fn.bounded.html

Demonstrates creating a channel with a capacity of one and performing send and receive operations.

```rust
use async_channel::{bounded, TryRecvError, TrySendError};

let (s, r) = bounded(1);

assert_eq!(s.send(10).await, Ok(()));
assert_eq!(s.try_send(20), Err(TrySendError::Full(20)));

assert_eq!(r.recv().await, Ok(10));
assert_eq!(r.try_recv(), Err(TryRecvError::Empty));
```

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

### Get reference to underlying value

Source: https://docs.rs/async-std/latest/async_std/io/struct.Cursor.html

Obtains an immutable reference to the buffer wrapped by the cursor.

```rust
use async_std::io::Cursor;

let buff = Cursor::new(Vec::new());

let reference = buff.get_ref();
```

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

### Create a directory with async_std

Source: https://docs.rs/async-std/latest/async_std/fs/fn.create_dir.html

Creates a new directory at the provided path. Ensure the parent directories exist before calling this function.

```rust
use async_std::fs;

fs::create_dir("./some/directory").await?;
```

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

### Get a reference to the underlying writer

Source: https://docs.rs/async-std/latest/async_std/io/struct.BufWriter.html

Retrieves a reference to the inner writer wrapped by the BufWriter.

```rust
use async_std::io::BufWriter;
use async_std::net::TcpStream;

let mut buffer = BufWriter::new(TcpStream::connect("127.0.0.1:34254").await?);

// We can use reference just like buffer
let reference = buffer.get_ref();
```

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

### fn mode(&mut self, mode: u32) -> &mut Self

Source: https://docs.rs/async-std/latest/async_std/os/unix/fs/trait.DirBuilderExt.html

Sets the mode to create new directories with. This option defaults to 0o777.

```APIDOC
## fn mode(&mut self, mode: u32) -> &mut Self

### Description
Sets the mode to create new directories with. This option defaults to 0o777.

### Parameters
- **mode** (u32) - Required - The mode to set for new directories.
```

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

### Get the channel capacity

Source: https://docs.rs/async-std/latest/async_std/channel/struct.Sender.html

Returns the capacity of the channel if it is bounded, otherwise returns None.

```rust
use async_channel::{bounded, unbounded};

let (s, r) = bounded::<i32>(5);
assert_eq!(s.capacity(), Some(5));

let (s, r) = unbounded::<i32>();
assert_eq!(s.capacity(), None);
```

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

### Get the number of messages in the channel

Source: https://docs.rs/async-std/latest/async_std/channel/struct.Sender.html

Returns the current count of messages waiting in the channel.

```rust
use async_channel::unbounded;

let (s, r) = unbounded();
assert_eq!(s.len(), 0);

s.send(1).await;
s.send(2).await;
assert_eq!(s.len(), 2);
```

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

### Basic Mutex Usage

Source: https://docs.rs/async-std/latest/async_std/sync/struct.Mutex.html

Demonstrates creating a mutex, acquiring a lock asynchronously, modifying the data, and verifying the lock state.

```rust
use async_lock::Mutex;

let m = Mutex::new(1);

let mut guard = m.lock().await;
*guard = 2;

assert!(m.try_lock().is_none());
drop(guard);
assert_eq!(*m.try_lock().unwrap(), 2);
```

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

### rchunks_exact

Source: https://docs.rs/async-std/latest/async_std/io/struct.IoSlice.html

Returns an iterator over chunk_size elements of the slice at a time, starting at the end of the slice.

```APIDOC
## pub fn rchunks_exact(&self, chunk_size: usize) -> RChunksExact<'_, T>

### Description
Returns an iterator over `chunk_size` elements of the slice at a time, starting at the end of the slice. The chunks are slices and do not overlap. If `chunk_size` does not divide the length of the slice, the last up to `chunk_size-1` elements will be omitted.

### Panics
Panics if `chunk_size` is zero.
```

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

### Creating a BufReader with custom capacity

Source: https://docs.rs/async-std/latest/async_std/io/struct.BufReader.html

Initializes a BufReader with a specific buffer size in bytes.

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

let f = BufReader::with_capacity(1024, File::open("a.txt").await?);
```

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

### async_std::fs::create_dir_all

Source: https://docs.rs/async-std/latest/async_std/fs/fn.create_dir_all.html

Creates a new directory and all of its parents if they are missing. This function is an async version of std::fs::create_dir_all.

```APIDOC
## async_std::fs::create_dir_all

### Signature
`pub async fn create_dir_all<P: AsRef<Path>>(path: P) -> Result<()>`

### Description
Creates a new directory and all of its parents if they are missing. This function is an async version of std::fs::create_dir_all.

### Errors
An error will be returned in the following situations:
- `path` already points to an existing file or directory.
- The current process lacks permissions to create the directory or its missing parents.
- Some other I/O error occurred.

### Example
```rust
use async_std::fs;

fs::create_dir_all("./some/directory").await?;
```
```

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

### Basic process abort usage

Source: https://docs.rs/async-std/latest/async_std/process/fn.abort.html

Demonstrates the immediate termination of a process using process::abort.

```rust
use std::process;

fn main() {
    println!("aborting");

    process::abort();

    // execution never gets here
}
```

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

### Get first chunk of slice

Source: https://docs.rs/async-std/latest/async_std/io/struct.IoSlice.html

Returns an array reference to the first N items in the slice.

```rust
let u = [10, 40, 30];
assert_eq!(Some(&[10, 40]), u.first_chunk::<2>());

let v: &[i32] = &[10];
assert_eq!(None, v.first_chunk::<2>());

let w: &[i32] = &[];
assert_eq!(Some(&[]), w.first_chunk::<0>());
```

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

### pub async fn is_file(&self) -> bool

Source: https://docs.rs/async-std/latest/async_std/path/struct.Path.html

Returns true if the path exists on disk and is pointing at a regular file.

```APIDOC
## pub async fn is_file(&self) -> bool

### Description
Returns true if the path exists on disk and is pointing at a regular file. This function will traverse symbolic links.

### Signature
`pub async fn is_file(&self) -> bool`

### Example
```rust
use async_std::path::Path;
assert_eq!(Path::new("./is_a_directory/").is_file().await, false);
assert_eq!(Path::new("a_file.txt").is_file().await, true);
```
```

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

### Create and inspect IpAddr

Source: https://docs.rs/async-std/latest/async_std/net/enum.IpAddr.html

Demonstrates creating IPv4 and IPv6 addresses and checking their type.

```rust
use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};

let localhost_v4 = IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1));
let localhost_v6 = IpAddr::V6(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1));

assert_eq!("127.0.0.1".parse(), Ok(localhost_v4));
assert_eq!("::1".parse(), Ok(localhost_v6));

assert_eq!(localhost_v4.is_ipv6(), false);
assert_eq!(localhost_v4.is_ipv4(), true);
```

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

### SocketAddrV6::scope_id / set_scope_id

Source: https://docs.rs/async-std/latest/async_std/net/struct.SocketAddrV6.html

Methods to get or change the scope ID associated with the socket address.

```APIDOC
## pub const fn scope_id(&self) -> u32
## pub const fn set_scope_id(&mut self, new_scope_id: u32)

### Description
Retrieves or updates the scope ID associated with this socket address.
```

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

### Construct a new Command

Source: https://docs.rs/async-std/latest/async_std/process/struct.Command.html

Initializes a new Command instance for a specified program.

```rust
use async_process::Command;

let mut cmd = Command::new("ls");
```

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

### SocketAddrV6::flowinfo / set_flowinfo

Source: https://docs.rs/async-std/latest/async_std/net/struct.SocketAddrV6.html

Methods to get or change the flow information associated with the socket address.

```APIDOC
## pub const fn flowinfo(&self) -> u32
## pub const fn set_flowinfo(&mut self, new_flowinfo: u32)

### Description
Retrieves or updates the flow information associated with this socket address.
```

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

### SocketAddrV6::port / set_port

Source: https://docs.rs/async-std/latest/async_std/net/struct.SocketAddrV6.html

Methods to get or change the port number associated with the socket address.

```APIDOC
## pub const fn port(&self) -> u16
## pub const fn set_port(&mut self, new_port: u16)

### Description
Retrieves or updates the port number associated with this socket address.
```

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

### SocketAddrV6::ip / set_ip

Source: https://docs.rs/async-std/latest/async_std/net/struct.SocketAddrV6.html

Methods to get or change the IP address associated with the socket address.

```APIDOC
## pub const fn ip(&self) -> &Ipv6Addr
## pub const fn set_ip(&mut self, new_ip: Ipv6Addr)

### Description
Retrieves or updates the IPv6 address associated with this socket address.
```

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

### Set the file extension

Source: https://docs.rs/async-std/latest/async_std/path/struct.PathBuf.html

Updates or adds the file extension to the path.

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

let mut p = PathBuf::from("/feel/the");

p.set_extension("force");
assert_eq!(Path::new("/feel/the.force"), p.as_path());

p.set_extension("dark_side");
assert_eq!(Path::new("/feel/the.dark_side"), p.as_path());
```

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

### Get the limit of a Take reader

Source: https://docs.rs/async-std/latest/async_std/io/struct.Take.html

Retrieves the remaining number of bytes that can be read before reaching EOF.

```rust
use async_std::prelude::*;
use async_std::fs::File;

let f = File::open("foo.txt").await?;

// read at most five bytes
let handle = f.take(5);

println!("limit: {}", handle.limit());
```

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

### Construct Arc with custom allocator

Source: https://docs.rs/async-std/latest/async_std/sync/struct.Arc.html

Demonstrates creating an Arc instance using the System allocator. Requires the allocator_api feature.

```rust
#![feature(allocator_api)]

use std::sync::Arc;
use std::alloc::System;

let five = Arc::try_new_in(5, System)?;
```

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

### Creating a finite stream with repeat_with

Source: https://docs.rs/async-std/latest/async_std/stream/fn.repeat_with.html

Demonstrates how to use take to limit an infinite stream generated by repeat_with.

```rust
use async_std::prelude::*;
use async_std::stream;

let mut n = 1;
let s = stream::repeat_with(|| {
    let item = n;
    n *= 2;
    item
})
.take(4);

pin_utils::pin_mut!(s);

assert_eq!(s.next().await, Some(1));
assert_eq!(s.next().await, Some(2));
assert_eq!(s.next().await, Some(4));
assert_eq!(s.next().await, Some(8));
assert_eq!(s.next().await, None);
```

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

### Skip elements with skip_while

Source: https://docs.rs/async-std/latest/async_std/prelude/trait.StreamExt.html

Ignores elements from the start of the stream until the provided predicate returns false.

```rust
use async_std::prelude::*;
use async_std::stream;

let a = stream::from_iter(vec![-1i32, 0, 1]);
let mut s = a.skip_while(|x| x.is_negative());

assert_eq!(s.next().await, Some(0));
assert_eq!(s.next().await, Some(1));
assert_eq!(s.next().await, None);
```
Tokens:
Raw