Bevy Async Task

https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/
Admin
Bevy Async Task provides ergonomic abstractions for asynchronous programming within the Bevy game...
Tokens:15,198
Snippets:209
Trust Score:9.7
Update:3 months ago
Show doc for...
Tokens:
Raw
### Start a TaskStream

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.TaskStream.html

Starts a new asynchronous stream in the background. If a stream is already running, it will be replaced.

```rust
pub fn start(&mut self, stream: impl Into<AsyncStream<T>>)
```

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

### Start a New Task with TaskRunner

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.TaskRunner.html

Starts a new asynchronous task. If a task is already running, it will be replaced. For multiple tasks, use TaskPool.

```rust
pub fn start(&mut self, task: impl Into<AsyncTask<T>>)

```

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

### Start a New Task with TimedTaskRunner

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.TimedTaskRunner.html

Starts a new asynchronous task. If a task is already pending, it will be replaced. For multiple concurrent tasks, consider using TimedTaskPool.

```rust
pub fn start(&mut self, task: impl Into<TimedAsyncTask<T>>)

```

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

### TimedTaskRunner::start

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.TimedTaskRunner.html

Starts a new asynchronous task. If a task is already running, it will be replaced.

```APIDOC
## TimedTaskRunner::start

### Description
Start an async task in the background. If there is an existing task pending, it will be dropped and replaced with the given task. If you need to run multiple tasks, use the `TimedTaskPool`.

### Method
`start(task: impl Into<TimedAsyncTask<T>>)`

### Parameters
- `task` (impl Into<TimedAsyncTask<T>>): The asynchronous task to start. Can be any type that can be converted into a `TimedAsyncTask<T>`.

### Returns
None
```

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

### TaskRunner SystemParam Get Param

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.TaskRunner.html

Retrieves the TaskRunner parameter for use in a SystemParamFunction.

```rust
unsafe fn get_param<'w, 's>( state: &'s mut Self::State, _system_meta: &SystemMeta, _world: UnsafeWorldCell<'w>, _change_tick: Tick, ) -> Self::Item<'w, 's>

```

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

### TaskPool SystemParam Get Param

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.TaskPool.html

Retrieves the TaskPool parameter for use within a system.

```rust
unsafe fn get_param<'w, 's>( state: &'s mut Self::State, _system_meta: &SystemMeta, _world: UnsafeWorldCell<'w>, _change_tick: Tick, ) -> Self::Item<'w, 's>
```

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

### TaskStream SystemParam Get Param

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.TaskStream.html

Retrieves the TaskStream parameter for use within a SystemParam function.

```rust
unsafe fn get_param<'w, 's>( state: &'s mut Self::State, _system_meta: &SystemMeta, _world: UnsafeWorldCell<'w>, _change_tick: Tick, ) -> Self::Item<'w, 's>;
```

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

### Error Description (Deprecated) for TimeoutError

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.TimeoutError.html

Deprecated method to get a string description of the error. Use Display or to_string() instead.

```rust
fn description(&self) -> &str;
```

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

### TaskPool ExclusiveSystemParam Get Param

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.TaskPool.html

Retrieves the TaskPool parameter for use within an exclusive system.

```rust
fn get_param<'s>( state: &'s mut Self::State, _system_meta: &SystemMeta, ) -> Self::Item<'s>
```

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

### TaskRunner ExclusiveSystemParam Get Param

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.TaskRunner.html

Retrieves the TaskRunner parameter for use in an ExclusiveSystemParamFunction.

```rust
fn get_param<'s>( state: &'s mut Self::State, _system_meta: &SystemMeta, ) -> Self::Item<'s>

```

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

### AsyncTask::split

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.AsyncTask.html

Splits an AsyncTask into two components: a future that can be run and an `AsyncReceiver` to get the result. This is a low-level operation for advanced use cases.

```APIDOC
## AsyncTask::split

### Description
Split the task into a runnable future and receiver. This is a low-level operation and only useful for specific needs.

### Method
`pub fn split(self) -> (impl ConditionalSendFuture<Output = ()>, AsyncReceiver<T>)`
```

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

### TaskStream ExclusiveSystemParam Get Param

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.TaskStream.html

Retrieves the TaskStream parameter for use within an ExclusiveSystemParam function.

```rust
fn get_param<'s>( state: &'s mut Self::State, _system_meta: &SystemMeta, ) -> Self::Item<'s>;
```

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

### Poll TaskRunner for Status

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.TaskRunner.html

Polls the TaskRunner to get the current task status, returning Pending or Ready(T).

```rust
pub fn poll(&mut self) -> Poll<T>

```

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

### Error Cause (Deprecated) for TimeoutError

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.TimeoutError.html

Deprecated method to get the cause of the error. Use Error::source instead.

```rust
fn cause(&self) -> Option<&dyn Error>;
```

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

### AsyncStream::lazy

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.AsyncStream.html

Creates a new async stream from a future that produces a stream. The stream will only start producing items when the future resolves.

```APIDOC
## AsyncStream::lazy

### Description
Creates a new async stream from a future that produces a stream. The stream will only start producing items when the future resolves.

### Signature
```rust
pub fn lazy<F, S>(fut: F) -> Self
where
    F: ConditionalSendFuture<Output = S> + 'static,
    S: ConditionalSendStream<Item = T> + 'static,
```

### Parameters
* `fut`: A future that resolves to a stream.

### Returns
A new `AsyncStream` instance.
```

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

### Poll TimedTaskRunner for Task Status

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.TimedTaskRunner.html

Polls the task runner to get the current status of the task. Returns Pending or Ready(T) if the task is finished.

```rust
pub fn poll(&mut self) -> Poll<Result<T, TimeoutError>>

```

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

### TaskRunner SystemParam Init State

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.TaskRunner.html

Initializes the state for the TaskRunner SystemParam.

```rust
fn init_state(_world: &mut World) -> Self::State

```

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

### TaskPool SystemParam Init Access

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.TaskPool.html

Registers the world access patterns required by the TaskPool SystemParam.

```rust
fn init_access( _state: &Self::State, _system_meta: &mut SystemMeta, _component_access_set: &mut FilteredAccessSet, _world: &mut World, )
```

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

### TaskRunner SystemParam Init Access

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.TaskRunner.html

Registers world access for the TaskRunner SystemParam.

```rust
fn init_access( _state: &Self::State, _system_meta: &mut SystemMeta, _component_access_set: &mut FilteredAccessSet, _world: &mut World, )

```

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

### TaskRunner Methods

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.TaskRunner.html

Provides methods for interacting with the TaskRunner to manage asynchronous tasks within Bevy.

```APIDOC
## TaskRunner

### Description
A Bevy `SystemParam` to execute async tasks in the background.

### Methods

#### `is_idle()`
Returns whether the task runner is idle.

#### `is_pending()`
Returns whether the task runner is pending (running, but not finished).

#### `is_finished()`
Returns whether the task runner is finished.

#### `start(task: impl Into<AsyncTask<T>>)`
Start an async task in the background. If there is an existing task pending, it will be dropped and replaced with the given task. If you need to run multiple tasks, use the `TaskPool`.

#### `forget()`
Forget the task being run. This does not stop the task. Note: Bevy does not support cancelling a task on web currently.

#### `poll()` -> Poll<T>
Poll the task runner for the current task status. Possible returns are `Pending` or `Ready(T)`.
```

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

### TaskPool SystemParam Init State

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.TaskPool.html

Initializes the state for the TaskPool when it's used as a general SystemParam.

```rust
fn init_state(_world: &mut World) -> Self::State
```

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

### TaskRunner SystemParam Apply

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.TaskRunner.html

Applies deferred mutations for the TaskRunner SystemParam.

```rust
fn apply(state: &mut Self::State, system_meta: &SystemMeta, world: &mut World)

```

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

### TaskStream SystemParam Init State

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.TaskStream.html

Initializes the state for TaskStream as a SystemParam.

```rust
fn init_state(_world: &mut World) -> Self::State;
```

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

### TaskStream SystemParam Init Access

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.TaskStream.html

Registers world access for the TaskStream SystemParam.

```rust
fn init_access( _state: &Self::State, _system_meta: &mut SystemMeta, _component_access_set: &mut FilteredAccessSet, _world: &mut World, );
```

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

### TaskRunner ExclusiveSystemParam Init

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.TaskRunner.html

Initializes the state for the TaskRunner ExclusiveSystemParam.

```rust
fn init(_world: &mut World, _system_meta: &mut SystemMeta) -> Self::State

```

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

### AsyncTask::from

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.AsyncTask.html

Converts a future directly into an AsyncTask. This provides a convenient way to create an AsyncTask when you already have a compatible future.

```APIDOC
## AsyncTask::from

### Description
Converts to this type from the input type.

### Method
`fn from(value: Fnc) -> Self`
```

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

### TaskPool Methods

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.TaskPool.html

This section details the methods available on the TaskPool struct for managing asynchronous tasks.

```APIDOC
## TaskPool

### Description
A Bevy `SystemParam` to execute many similar `AsyncTask`s in the background simultaneously.

### Methods

#### `is_idle(&self) -> bool`
Returns whether the task pool is idle.

#### `spawn(&mut self, task: impl Into<AsyncTask<T>>)`
Spawn an async task in the background.

#### `iter_poll(&mut self) -> impl Iterator<Item = Poll<T>>`
Iterate and poll the task pool for the current task statuses.

#### `forget_all(&mut self)`
Forget all tasks being run. This does not stop any task.
Note: Bevy does not support cancelling a task on web currently.
```

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

### TaskRunner SystemParam Queue

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.TaskRunner.html

Queues deferred mutations for the TaskRunner SystemParam.

```rust
fn queue( state: &mut Self::State, system_meta: &SystemMeta, world: DeferredWorld<'_>, )

```

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

### TaskStream SystemParam Apply

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.TaskStream.html

Applies deferred mutations for the TaskStream SystemParam.

```rust
fn apply(state: &mut Self::State, system_meta: &SystemMeta, world: &mut World);
```

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

### TaskPool SystemParam Queue

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.TaskPool.html

Queues deferred mutations from the TaskPool SystemParam to be applied at the next ApplyDeferred stage.

```rust
fn queue( state: &mut Self::State, system_meta: &SystemMeta, world: DeferredWorld<'_>, )
```

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

### Spawn an AsyncTask

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.TaskPool.html

Spawns a new asynchronous task into the TaskPool for background execution.

```rust
pub fn spawn(&mut self, task: impl Into<AsyncTask<T>>)
```

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

### TimedAsyncTask Methods

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.TimedAsyncTask.html

Provides methods for creating, managing, and modifying TimedAsyncTask instances.

```APIDOC
## TimedAsyncTask

### Description
A wrapper type around an async future with a timeout. The future may be executed asynchronously by an `TimedTaskRunner` or `TimedTaskPool` bevy system parameter.

### Methods

#### `new<F>(dur: Duration, fut: F) -> Self`

**Description**: Create an async task from a future with a timeout.

**Parameters**:
- `dur` (Duration): The timeout duration for the future.
- `fut` (F): The future to wrap.

**Panics**: This function will panic if the specified Duration is greater than `i32::MAX` in millis.

#### `pending() -> Self`

**Description**: A future that never resolves to a value or becomes ready. This will, however, timeout after `i32::MAX` millis (24.8 days).

#### `split(self) -> (impl ConditionalSendFuture<Output = ()>, AsyncReceiver<Result<T, TimeoutError>>)`

**Description**: Split the task into a runnable future and receiver. This is a low-level operation and only useful for specific needs.

#### `with_timeout(self, dur: Duration) -> Self`

**Description**: Replace the timeout for this task.

**Parameters**:
- `dur` (Duration): The new timeout duration.

**Panics**: This function will panic if the specified Duration is greater than `i32::MAX` in millis.

#### `without_timeout(self) -> AsyncTask<T>`

**Description**: Remove the timeout for this task.

#### `from<Fnc>(value: Fnc) -> Self` where `Fnc: ConditionalSendFuture<Output = T> + 'static`, `Fnc::Output: ConditionalSend + 'static`

**Description**: Converts a future into a `TimedAsyncTask`.

**Parameters**:
- `value` (Fnc): The future to convert.
```

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

### AsyncTask::new

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.AsyncTask.html

Creates a new AsyncTask from a given future. This is the primary way to wrap an asynchronous operation into an AsyncTask.

```APIDOC
## AsyncTask::new

### Description
Create an async task from a future.

### Method
`pub fn new<F>(fut: F) -> Self`

### Parameters
* **fut** (F) - A future that implements `ConditionalSendFuture` and returns a type `T` that also implements `ConditionalSend`.
```

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

### AsyncTask::fmt

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.AsyncTask.html

Formats the AsyncTask for debugging purposes, allowing it to be printed or inspected in a readable format.

```APIDOC
## AsyncTask::fmt

### Description
Formats the value using the given formatter.

### Method
`fn fmt(&self, f: &mut Formatter<'_>) -> Result`
```

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

### Create AsyncTask from Future

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.AsyncTask.html

Creates a new AsyncTask from a given future. The future must be ConditionalSend and 'static.

```rust
pub fn new<F>(fut: F) -> Self
where F: ConditionalSendFuture<Output = T> + 'static, F::Output: ConditionalSend + 'static,
```

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

### TaskRunner Implementations

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.TaskRunner.html

This section details the various trait implementations available for the TaskRunner struct, including auto-trait and blanket implementations.

```APIDOC
## TaskRunner Auto-Trait Implementations

### `impl<'s, T> !RefUnwindSafe for TaskRunner<'s, T>`

### `impl<'s, T> !UnwindSafe for TaskRunner<'s, T>`

### `impl<'s, T> Freeze for TaskRunner<'s, T>`

### `impl<'s, T> Send for TaskRunner<'s, T>`
where T: Send,

### `impl<'s, T> Sync for TaskRunner<'s, T>`
where T: Send,

### `impl<'s, T> Unpin for TaskRunner<'s, T>`

### `impl<'s, T> UnsafeUnpin for TaskRunner<'s, T>`

## TaskRunner Blanket Implementations

### `impl<T> Any for T`
where T: 'static + ?Sized,
#### `fn type_id(&self) -> TypeId`
Gets the `TypeId` of `self`.

### `impl<T> Borrow<T> for T`
where T: ?Sized,
#### `fn borrow(&self) -> &T`
Immutably borrows from an owned value.

### `impl<T> BorrowMut<T> for T`
where T: ?Sized,
#### `fn borrow_mut(&mut self) -> &mut T`
Mutably borrows from an owned value.

### `impl<T> CompatExt for T`
#### `fn compat(self) -> Compat<T>`
where T: Sized,
Applies the `Compat` adapter by value.
#### `fn compat_ref(&self) -> Compat<&T>`
Applies the `Compat` adapter by shared reference.
#### `fn compat_mut(&mut self) -> Compat<&mut T>`
Applies the `Compat` adapter by mutable reference.

### `impl<T> ConditionalSend for T`
where T: Send,

### `impl<T> From<T> for T`
#### `fn from(t: T) -> T`
Returns the argument unchanged.

### `impl<T, U> Into<U> for T`
where U: From<T>,
#### `fn into(self) -> U`
Calls `U::from(self)`.
That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.

### `impl<T> IntoResult<T> for T`
#### `fn into_result(self) -> Result<T, RunSystemError>`
Converts this type into the system output type.

### `impl<T, U> TryFrom<U> for T`
where U: Into<T>,
#### `type Error = Infallible`
The type returned in the event of a conversion error.
#### `fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>`
Performs the conversion.

### `impl<T, U> TryInto<U> for T`
where U: TryFrom<T>,
#### `type Error = <U as TryFrom<T>>::Error`
The type returned in the event of a conversion error.
#### `fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>`
Performs the conversion.
```

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

### CompatExt Trait Implementations

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.AsyncReceiver.html

Provides methods to adapt types for compatibility, including compat, compat_ref, and compat_mut. These methods wrap the type in a Compat adapter.

```rust
impl<T> CompatExt for T
Source§
#### fn compat(self) -> Compat<T>
where T: Sized,
Applies the `Compat` adapter by value. Read more
Source§
#### fn compat_ref(&self) -> Compat<&T>
Applies the `Compat` adapter by shared reference. Read more
Source§
#### fn compat_mut(&mut self) -> Compat<&mut T>
Applies the `Compat` adapter by mutable reference. Read more
```

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

### Error Provide (Experimental) for TimeoutError

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.TimeoutError.html

Experimental nightly-only API for providing type-based access to error context.

```rust
fn provide<'a>(&'a self, request: &mut Request<'a>); 
```

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

### CompatExt Trait Implementations

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.TimedTaskRunner.html

Provides methods to adapt types for compatibility, including `compat`, `compat_ref`, and `compat_mut`.

```APIDOC
## fn compat(self) -> Compat<T>

### Description
Applies the `Compat` adapter by value.

### Method
N/A (Trait method)

### Endpoint
N/A

### Parameters
None

### Request Example
None

### Response
#### Success Response
- **Compat<T>**: The adapted type.
```

```APIDOC
## fn compat_ref(&self) -> Compat<&T>

### Description
Applies the `Compat` adapter by shared reference.

### Method
N/A (Trait method)

### Endpoint
N/A

### Parameters
None

### Request Example
None

### Response
#### Success Response
- **Compat<&T>**: The adapted type.
```

```APIDOC
## fn compat_mut(&mut self) -> Compat<&mut T>

### Description
Applies the `Compat` adapter by mutable reference.

### Method
N/A (Trait method)

### Endpoint
N/A

### Parameters
None

### Request Example
None

### Response
#### Success Response
- **Compat<&mut T>**: The adapted type.
```

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

### TaskPool ExclusiveSystemParam Init

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.TaskPool.html

Initializes the state for the TaskPool when it's used as an ExclusiveSystemParam.

```rust
fn init(_world: &mut World, _system_meta: &mut SystemMeta) -> Self::State
```

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

### TaskPool SystemParam Apply

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.TaskPool.html

Applies any deferred mutations made by the TaskPool SystemParam during the ApplyDeferred stage.

```rust
fn apply(state: &mut Self::State, system_meta: &SystemMeta, world: &mut World)
```

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

### AsyncTask Operations

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/index.html

Provides system parameters for executing asynchronous tasks in the background. TaskRunner executes individual tasks, while TaskPool executes many similar tasks concurrently.

```APIDOC
## Structs

### AsyncTask
Wrapper type around an async future. The future may be executed asynchronously by a `TaskRunner` or `TaskPool` bevy system parameter.

### TaskRunner
A Bevy `SystemParam` to execute async tasks in the background.

### TaskPool
A Bevy `SystemParam` to execute many similar `AsyncTask`s in the background simultaneously.
```

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

### AsyncTask::pending

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.AsyncTask.html

Creates an AsyncTask that will never resolve or become ready. This can be used as a placeholder or in scenarios where a task should intentionally not complete.

```APIDOC
## AsyncTask::pending

### Description
Never resolves to a value or becomes ready.

### Method
`pub fn pending() -> Self`
```

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

### TaskStream SystemParam Queue

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.TaskStream.html

Queues deferred mutations for the TaskStream SystemParam.

```rust
fn queue( state: &mut Self::State, system_meta: &SystemMeta, world: DeferredWorld<'_>, );
```

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

### Create a Pending TimedAsyncTask

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.TimedAsyncTask.html

Creates a TimedAsyncTask that never resolves. It will timeout after i32::MAX milliseconds (approximately 24.8 days).

```rust
pub fn pending() -> Self
```

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

### Utility Functions

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/index.html

Provides utility functions for asynchronous operations, including creating pending futures, non-blocking sleeps, and executing futures with timeouts.

```APIDOC
## Functions

### pending
Never resolves to a value or becomes ready.

### sleep
Sleep for a specified duration. This is non-blocking.

### timeout
Execute a future or error on timeout, whichever comes first.
```

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

### Try Receiving Next Item from AsyncStreamReceiver

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.AsyncStreamReceiver.html

Attempt to receive the next item from the stream without blocking. Returns Some(item) if an item is available, otherwise None.

```rust
pub fn try_recv(&mut self) -> Option<T>
```

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

### From<S> for AsyncStream<T>

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.AsyncStream.html

Allows creating an `AsyncStream` directly from any type `S` that implements `Stream` and `Send`. This leverages Rust's `From` trait for convenient conversion.

```APIDOC
## From<S> for AsyncStream<T>

### Description
Allows creating an `AsyncStream` directly from any type `S` that implements `Stream` and `Send`. This leverages Rust's `From` trait for convenient conversion.

### Signature
```rust
impl<T, S> From<S> for AsyncStream<T>
where
    T: ConditionalSend + 'static,
    S: Stream<Item = T> + Send + 'static,
```

### Parameters
* `stream`: The stream to convert into an `AsyncStream`.
```

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

### Spawn a TimedAsyncTask

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.TimedTaskPool.html

Spawns a new asynchronous task into the TimedTaskPool. The task can be any type that implements Into<TimedAsyncTask<T>>.

```rust
pub fn spawn(&mut self, task: impl Into<TimedAsyncTask<T>>)

```

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

### Create TimedAsyncTask with Timeout

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.TimedAsyncTask.html

Creates a new TimedAsyncTask from a future with a specified timeout duration. This function will panic if the duration exceeds i32::MAX milliseconds.

```rust
pub fn new<F>(dur: Duration, fut: F) -> Self
where
    F: ConditionalSendFuture<Output = T> + 'static,
    F::Output: ConditionalSend + 'static,

```

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

### AsyncTask Any Trait Implementation

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.AsyncTask.html

Implements the Any trait for AsyncTask, enabling runtime type identification.

```rust
fn type_id(&self) -> TypeId
```

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

### Display Implementation for TimeoutError

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.TimeoutError.html

Enables TimeoutError to be formatted as a displayable string.

```rust
fn fmt(&self, __formatter: &mut Formatter<'_>) -> Result;
```

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

### AsyncTask Debug Formatting

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.AsyncTask.html

Implements the Debug trait for AsyncTask, allowing it to be formatted for debugging.

```rust
fn fmt(&self, f: &mut Formatter<'_>) -> Result
```

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

### TaskRunner SystemParam Item

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.TaskRunner.html

Defines the item type returned by TaskRunner when used as a SystemParam.

```rust
type Item<'w, 's> = TaskRunner<'s, T>

```

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

### Create AsyncStream from a Stream

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.AsyncStream.html

Creates a new AsyncStream directly from an existing stream. The stream must implement ConditionalSendStream and be 'static, and its items must also be ConditionalSend.

```rust
pub fn new<S>(stream: S) -> Self
where S: ConditionalSendStream<Item = T> + 'static,
      S::Item: ConditionalSend + 'static,
```

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

### Create AsyncStream from a Future

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.AsyncStream.html

Creates a new AsyncStream from a future that produces a stream. The future and the stream it produces must be ConditionalSend and 'static.

```rust
pub fn lazy<F, S>(fut: F) -> Self
where F: ConditionalSendFuture<Output = S> + 'static,
      S: ConditionalSendStream<Item = T> + 'static,
```

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

### TaskStream Methods

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.TaskStream.html

Provides methods for interacting with and managing asynchronous streams using TaskStream.

```APIDOC
## TaskStream

### Description
A Bevy `SystemParam` to execute async streams in the background.

### Methods

#### `is_idle(&self) -> bool`
Returns whether the stream is idle (not started).

#### `is_pending(&self) -> bool`
Returns whether the stream is pending (running, but not finished).

#### `is_finished(&self) -> bool`
Returns whether the stream is finished.

#### `start(&mut self, stream: impl Into<AsyncStream<T>>)`
Start an async stream in the background. If there is an existing stream pending, it will be dropped and replaced with the given stream.

#### `forget(&mut self)`
Forget the stream being run. This does not stop the stream. Note: Bevy does not support cancelling a task on web currently.

#### `poll_next(&mut self) -> Poll<Option<T>>`
Poll for the next item. Returns `Poll::Ready(Some(T))` if an item is available, `Poll::Ready(None)` if the stream is finished, or `Poll::Pending` if waiting.
```

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

### TaskStream ExclusiveSystemParam Init State

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.TaskStream.html

Initializes the state for TaskStream as an ExclusiveSystemParam.

```rust
fn init(_world: &mut World, _system_meta: &mut SystemMeta) -> Self::State;
```

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

### TaskPool SystemParam Item

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.TaskPool.html

Specifies the item type returned when constructing the TaskPool system parameter for general system access.

```rust
type Item<'w, 's> = TaskPool<'s, T>
```

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

### AsyncTask Sleep Task

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.AsyncTask.html

Creates an AsyncTask that sleeps for a specified duration before completing.

```rust
pub async fn sleep(duration: Duration) -> Self
```

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

### AsyncStream::new

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.AsyncStream.html

Creates a new async stream directly from an existing stream. This is a straightforward way to wrap a stream within the AsyncStream.

```APIDOC
## AsyncStream::new

### Description
Creates a new async stream from a stream. This is a straightforward way to wrap a stream within the AsyncStream.

### Signature
```rust
pub fn new<S>(stream: S) -> Self
where
    S: ConditionalSendStream<Item = T> + 'static,
    S::Item: ConditionalSend + 'static,
```

### Parameters
* `stream`: An existing stream that implements `ConditionalSendStream`.

### Returns
A new `AsyncStream` instance.
```

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

### TaskPool SystemParam Validate Param

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.TaskPool.html

Validates that the TaskPool SystemParam can be safely acquired by the get_param method.

```rust
unsafe fn validate_param( state: &mut Self::State, system_meta: &SystemMeta, world: UnsafeWorldCell<'_>, ) -> Result<(), SystemParamValidationError>
```

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

### AsyncTask Struct Definition

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.AsyncTask.html

Defines the AsyncTask struct, a wrapper for async futures.

```rust
pub struct AsyncTask<T: ConditionalSend> { /* private fields */ }
```

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

### PartialEq Implementation for TimeoutError

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.TimeoutError.html

Enables equality comparison between TimeoutError instances.

```rust
fn eq(&self, other: &TimeoutError) -> bool;
```

```rust
fn ne(&self, other: &Rhs) -> bool;
```

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

### pending Function

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/fn.pending.html

Creates an async task that never resolves. Use this when you need a future that will never complete.

```rust
pub async fn pending<T>()
```

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

### Convert Stream to AsyncStream using From trait

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.AsyncStream.html

Implements the From trait to allow direct conversion of a stream into an AsyncStream. The stream must implement Stream and Send, and be 'static.

```rust
fn from(stream: S) -> Self
where S: Stream<Item = T> + Send + 'static,
```

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

### TimedTaskPool::spawn

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.TimedTaskPool.html

Spawns a new asynchronous task to be executed by the TimedTaskPool.

```APIDOC
## TimedTaskPool::spawn

### Description
Spawns an async task in the background.

### Method
`spawn`

### Parameters
- `task` (impl Into<TimedAsyncTask<T>>): The asynchronous task to spawn. This can be any type that can be converted into a `TimedAsyncTask<T>`.

### Returns
None
```

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

### AsyncStreamReceiver Methods

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.AsyncStreamReceiver.html

Provides methods for interacting with the AsyncStreamReceiver to check stream status and receive items.

```APIDOC
## AsyncStreamReceiver

### Description
A channel that receives multiple items from an async stream.

### Methods

#### `is_finished(&self) -> bool`
Returns whether the stream has finished producing items.

#### `try_recv(&mut self) -> Option<T>`
Try to receive the next item from the stream without blocking. Returns `Some(item)` if an item is available, `None` otherwise.
```

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

### TaskStream SystemParam Item

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.TaskStream.html

Defines the item type returned when constructing TaskStream as a SystemParam.

```rust
type Item<'w, 's> = TaskStream<'s, T>;
```

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

### AsyncTask TryInto Trait Implementation

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.AsyncTask.html

Implements TryInto for AsyncTask, enabling fallible conversion to other types.

```rust
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
```

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

### TaskRunner SystemParam Validate Param

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.TaskRunner.html

Validates that the TaskRunner SystemParam can be acquired.

```rust
unsafe fn validate_param( state: &mut Self::State, system_meta: &SystemMeta, world: UnsafeWorldCell<'_>, ) -> Result<(), SystemParamValidationError>

```

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

### StructuralPartialEq Implementation for TimeoutError

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.TimeoutError.html

Indicates that TimeoutError supports structural partial equality comparison.

```rust
impl StructuralPartialEq for TimeoutError
```

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

### TaskStream Trait Implementations

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.TaskStream.html

This section outlines the various trait implementations available for the TaskStream struct, indicating its compatibility with standard Rust features and its behavior in concurrent and asynchronous contexts.

```APIDOC
## TaskStream Implementations

This documentation details the trait implementations for the `TaskStream<'s, T>` struct.

### Auto Trait Implementations

- `!RefUnwindSafe for TaskStream<'s, T>`
- `!UnwindSafe for TaskStream<'s, T>`
- `Freeze for TaskStream<'s, T>`
- `Send for TaskStream<'s, T>` (where `T: Send`)
- `Sync for TaskStream<'s, T>` (where `T: Send`)
- `Unpin for TaskStream<'s, T>`
- `UnsafeUnpin for TaskStream<'s, T>`

### Blanket Implementations

- **`Any`**: Provides runtime type information.
  - `fn type_id(&self) -> TypeId`: Gets the `TypeId` of `self`.
- **`Borrow<T>`**: Allows borrowing the inner type.
  - `fn borrow(&self) -> &T`: Immutably borrows from an owned value.
- **`BorrowMut<T>`**: Allows mutable borrowing of the inner type.
  - `fn borrow_mut(&mut self) -> &mut T`: Mutably borrows from an owned value.
- **`CompatExt`**: Provides compatibility adapters.
  - `fn compat(self) -> Compat<T>`: Applies the `Compat` adapter by value.
  - `fn compat_ref(&self) -> Compat<&T>`: Applies the `Compat` adapter by shared reference.
  - `fn compat_mut(&mut self) -> Compat<&mut T>`: Applies the `Compat` adapter by mutable reference.
- **`ConditionalSend`**: Indicates conditional sendability.
- **`From<T>`**: Allows conversion from the inner type.
  - `fn from(t: T) -> T`: Returns the argument unchanged.
- **`Into<U>`**: Allows conversion into other types.
  - `fn into(self) -> U` (where `U: From<T>`): Calls `U::from(self)`.
- **`IntoResult<T>`**: Converts the type into a `Result`.
  - `fn into_result(self) -> Result<T, RunSystemError>`: Converts this type into the system output type.
- **`TryFrom<U>`**: Allows fallible conversion from other types.
  - `type Error = Infallible`
  - `fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>`: Performs the conversion.
- **`TryInto<U>`**: Allows fallible conversion into other types.
  - `type Error = <U as TryFrom<T>>::Error`
  - `fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>`: Performs the conversion.
```

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

### Debug Implementation for TimeoutError

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.TimeoutError.html

Allows TimeoutError to be formatted for debugging purposes.

```rust
fn fmt(&self, f: &mut Formatter<'_>) -> Result;
```

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

### AsyncTask CompatExt Trait Implementations

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.AsyncTask.html

Implements CompatExt for AsyncTask, providing compatibility adapters.

```rust
fn compat(self) -> Compat<T>
where T: Sized,
```

```rust
fn compat_ref(&self) -> Compat<&T>
```

```rust
fn compat_mut(&mut self) -> Compat<&mut T>
```

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

### AsyncTask TryFrom Trait Implementation

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.AsyncTask.html

Implements TryFrom for AsyncTask, enabling fallible conversion from other types.

```rust
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
```

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

### Error Source Implementation for TimeoutError

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.TimeoutError.html

Provides the underlying source error for TimeoutError, if any.

```rust
fn source(&self) -> Option<&(dyn Error + 'static)>;
```

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

### Constants

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/index.html

Defines constants for timeout values, including a default timeout and the maximum allowed timeout.

```APIDOC
## Constants

### DEFAULT_TIMEOUT
A good default timeout. Values over `i32::MAX` will cause panics on web.

### MAX_TIMEOUT
The maximum timeout allowed. Anything above this will cause a panic on web.
```

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

### TaskRunner Struct Definition

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.TaskRunner.html

Defines the TaskRunner struct, a Bevy SystemParam for background async task execution.

```rust
pub struct TaskRunner<'s, T>(/* private fields */);

```

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

### Into Trait Implementation

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.TimedTaskRunner.html

Allows conversion from a type `T` into another type `U` if `U` implements `From<T>`.

```APIDOC
## fn into(self) -> U

### Description
Calls `U::from(self)`. This conversion is whatever the implementation of `From<T> for U` chooses to do.

### Method
N/A (Trait method)

### Endpoint
N/A

### Parameters
None

### Request Example
None

### Response
#### Success Response
- **U**: The converted value.
```

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

### IntoResult Trait Implementation

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.TimedTaskRunner.html

Converts a type into a `Result<T, RunSystemError>`.

```APIDOC
## fn into_result(self) -> Result<T, RunSystemError>

### Description
Converts this type into the system output type.

### Method
N/A (Trait method)

### Endpoint
N/A

### Parameters
None

### Request Example
None

### Response
#### Success Response
- **Result<T, RunSystemError>**: The result of the conversion.
```

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

### TaskPool Struct Definition

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.TaskPool.html

Defines the TaskPool struct, a Bevy SystemParam for managing concurrent async tasks.

```rust
pub struct TaskPool<'s, T>(/* private fields */);
```

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

### TaskStream SystemParam Validate Param

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.TaskStream.html

Validates that the TaskStream SystemParam can be acquired.

```rust
unsafe fn validate_param( state: &mut Self::State, system_meta: &SystemMeta, world: UnsafeWorldCell<'_>, ) -> Result<(), SystemParamValidationError>;
```

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

### TimedTaskPool Trait Implementations

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.TimedTaskPool.html

This section outlines the various trait implementations for the TimedTaskPool struct, indicating its thread safety and compatibility with other Rust features.

```APIDOC
## TimedTaskPool Trait Implementations

This section details the automatically derived and blanket implementations for the `TimedTaskPool` struct.

### Auto Trait Implementations

- `!RefUnwindSafe`
- `!UnwindSafe`
- `Freeze`
- `Send` (requires `T: Send`)
- `Sync` (requires `T: Send`)
- `Unpin`
- `UnsafeUnpin`

### Blanket Implementations

- `Any` (for `T: 'static + ?Sized`)
  - `fn type_id(&self) -> TypeId`: Gets the `TypeId` of `self`.
- `Borrow<T>` (for `T`)
  - `fn borrow(&self) -> &T`: Immutably borrows from an owned value.
- `BorrowMut<T>` (for `T`)
  - `fn borrow_mut(&mut self) -> &mut T`: Mutably borrows from an owned value.
- `CompatExt`
  - `fn compat(self) -> Compat<T>` (requires `T: Sized`): Applies the `Compat` adapter by value.
  - `fn compat_ref(&self) -> Compat<&T>`: Applies the `Compat` adapter by shared reference.
  - `fn compat_mut(&mut self) -> Compat<&mut T>`: Applies the `Compat` adapter by mutable reference.
- `ConditionalSend` (requires `T: Send`)
- `From<T>` (for `T`)
  - `fn from(t: T) -> T`: Returns the argument unchanged.
- `Into<U>` (for `T`, requires `U: From<T>`)
  - `fn into(self) -> U`: Calls `U::from(self)`.
- `IntoResult<T>` (for `T`)
  - `fn into_result(self) -> Result<T, RunSystemError>`: Converts this type into the system output type.
- `TryFrom<U>` (for `T`, requires `U: Into<T>`)
  - `type Error = Infallible`
  - `fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>`: Performs the conversion.
- `TryInto<U>` (for `T`, requires `U: TryFrom<T>`)
  - `type Error = <U as TryFrom<T>>::Error`
  - `fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>`: Performs the conversion.
```

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

### Eq Implementation for TimeoutError

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.TimeoutError.html

Indicates that TimeoutError supports equality comparison.

```rust
impl Eq for TimeoutError
```

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

### Any Trait Implementation

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.TimedTaskRunner.html

Provides the `type_id` method for obtaining the unique identifier of a type.

```APIDOC
## fn type_id(&self) -> TypeId

### Description
Gets the `TypeId` of `self`.

### Method
N/A (Trait method)

### Endpoint
N/A

### Parameters
None

### Request Example
None

### Response
#### Success Response
- **TypeId**: The unique identifier of the type.
```

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

### Sync Implementation for AsyncReceiver

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.AsyncReceiver.html

Implements the Sync trait for AsyncReceiver, indicating that it can be safely shared between threads. Requires the generic type T to be Send.

```rust
impl<T> Sync for AsyncReceiver<T>
where T: Send,
```

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

### TryFrom Trait Implementation

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.TimedTaskRunner.html

Provides a fallible conversion from type `U` to type `T`.

```APIDOC
## fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

### Description
Performs the conversion.

### Method
N/A (Trait method)

### Endpoint
N/A

### Parameters
- **value** (U) - Required - The value to convert.

### Request Example
None

### Response
#### Success Response
- **Result<T, Error>**: The result of the conversion, where `Error` is `Infallible` in this implementation.
```

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

### Split AsyncTask into Future and Receiver

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.AsyncTask.html

Splits an AsyncTask into its constituent runnable future and an AsyncReceiver. This is a low-level operation for specific use cases.

```rust
pub fn split( self, ) -> (impl ConditionalSendFuture<Output = ()>, AsyncReceiver<T>)
```

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

### TimedAsyncTask Struct Definition

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.TimedAsyncTask.html

Defines the TimedAsyncTask struct, which is a wrapper for an async future with an associated timeout. It is designed to be executed by TimedTaskRunner or TimedTaskPool Bevy system parameters.

```rust
pub struct TimedAsyncTask<T: ConditionalSend> { /* private fields */ }
```

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

### Iterate and Poll Task Statuses

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.TaskPool.html

Provides an iterator to poll the status of all tasks currently managed by the TaskPool.

```rust
pub fn iter_poll(&mut self) -> impl Iterator<Item = Poll<T>>
```

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

### Any Trait Implementation

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.AsyncReceiver.html

Provides the type_id method for any type T that is 'static and ?Sized, allowing for runtime type identification.

```rust
impl<T> Any for T
where T: 'static + ?Sized,
Source§
#### fn type_id(&self) -> TypeId
```

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

### TryInto Trait Implementation

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.TimedTaskRunner.html

Provides a fallible conversion from type `T` to type `U`.

```APIDOC
## fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

### Description
Performs the conversion.

### Method
N/A (Trait method)

### Endpoint
N/A

### Parameters
None

### Request Example
None

### Response
#### Success Response
- **Result<U, Error>**: The result of the conversion, where `Error` is the `Error` type of `U`'s `TryFrom<T>` implementation.
```

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

### Copy Implementation for TimeoutError

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.TimeoutError.html

Indicates that TimeoutError can be copied by value.

```rust
impl Copy for TimeoutError
```

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

### Clone Implementation for TimeoutError

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.TimeoutError.html

Provides the ability to create a duplicate of a TimeoutError instance.

```rust
fn clone(&self) -> TimeoutError;
```

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

### From Trait Implementation

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.TimedTaskRunner.html

Allows conversion from a type `T` to itself.

```APIDOC
## fn from(t: T) -> T

### Description
Returns the argument unchanged.

### Method
N/A (Trait method)

### Endpoint
N/A

### Parameters
- **t** (T) - Required - The value to convert.

### Request Example
None

### Response
#### Success Response
- **T**: The original value.
```

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

### AsyncReceiver Struct Definition

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.AsyncReceiver.html

Defines the AsyncReceiver struct, which is a channel for receiving results from an AsyncTask. It has private fields.

```rust
pub struct AsyncReceiver<T> { /* private fields */ }
```

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

### Add Timeout to AsyncTask

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.AsyncTask.html

Adds a timeout to an existing AsyncTask. Panics if the duration exceeds i32::MAX milliseconds.

```rust
pub fn with_timeout(self, dur: Duration) -> TimedAsyncTask<T>
```

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

### TaskRunner Debug Implementation

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.TaskRunner.html

Implements the Debug trait for TaskRunner, allowing it to be formatted for debugging.

```rust
fn fmt(&self, f: &mut Formatter<'_>) -> Result

```

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

### AsyncTask Borrow Trait Implementation

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.AsyncTask.html

Implements the Borrow trait for AsyncTask, allowing immutable borrowing.

```rust
fn borrow(&self) -> &T
```

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

### Convert Future to TimedAsyncTask

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.TimedAsyncTask.html

Converts a compatible future type into a TimedAsyncTask. This leverages the From trait implementation.

```rust
fn from(value: Fnc) -> Self
```

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

### timeout Function

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/fn.timeout.html

Executes a future with a specified duration. It returns the future's output if it completes before the duration elapses, otherwise it returns a timeout error.

```APIDOC
## Function timeout

### Description
Execute a future or error on timeout, whichever comes first.

### Signature
```rust
pub async fn timeout<F, T>(dur: Duration, f: F) -> Result<T, TimeoutError>
where
    F: Future<Output = T>,
```

### Parameters
* `dur` (Duration): The maximum duration to wait for the future to complete.
* `f` (F: Future<Output = T>): The future to execute.

### Returns
* `Result<T, TimeoutError>`: Ok(T) if the future completes within the duration, Err(TimeoutError) if the timeout occurs first.

### Errors
* `TimeoutError`: Returned if the timeout occurs before the future is ready.
```

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

### From Trait Implementation

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.AsyncReceiver.html

Implements the From trait for type T, allowing conversion from T to T. This is an identity conversion.

```rust
impl<T> From<T> for T
Source§
#### fn from(t: T) -> T
```

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

### AsyncTask IntoResult Trait Implementation

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.AsyncTask.html

Implements IntoResult for AsyncTask, converting it into a system output type.

```rust
fn into_result(self) -> Result<T, RunSystemError>
```

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

### Timed Task Operations

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/index.html

Allows for the execution of asynchronous tasks with a specified timeout. TimedAsyncTask wraps futures with timeouts, and TimedTaskRunner/TimedTaskPool execute them.

```APIDOC
## Structs

### TimedAsyncTask
A wrapper type around an async future with a timeout. The future may be executed asynchronously by a `TimedTaskRunner` or `TimedTaskPool` bevy system parameter.

### TimedTaskPool
A Bevy `SystemParam` to execute many similar `AsyncTask`s in the background simultaneously.

### TimedTaskRunner
A Bevy `SystemParam` to execute async tasks in the background with a timeout.

### TimeoutError
A timeout occurred on a timed asynchronous task.
```

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

### Into Trait Implementation

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.AsyncReceiver.html

Implements the Into trait for type T, allowing conversion from T to U where U implements From<T>. This enables type conversions.

```rust
impl<T, U> Into<U> for T
where U: From<T>,
Source§
#### fn into(self) -> U
```

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

### AsyncTask::sleep

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.AsyncTask.html

Creates a new AsyncTask that sleeps for a specified duration before completing. This is useful for introducing delays in asynchronous operations.

```APIDOC
## AsyncTask::sleep

### Description
A task which sleeps for a specified duration.

### Method
`async fn sleep(duration: Duration) -> Self`

### Parameters
* **duration** (Duration) - The duration to sleep for.
```

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

### Debug Implementation for AsyncReceiver

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.AsyncReceiver.html

Implements the Debug trait for AsyncReceiver, allowing instances to be formatted for debugging purposes. Requires the generic type T to implement Debug.

```rust
impl<T: Debug> Debug for AsyncReceiver<T>
Source§
#### fn fmt(&self, f: &mut Formatter<'_>) -> Result
```

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

### Poll Next Item from TaskStream

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.TaskStream.html

Polls for the next item from the asynchronous stream. Returns Poll::Ready(Some(T)) if an item is available, Poll::Ready(None) if the stream is finished, or Poll::Pending if waiting.

```rust
pub fn poll_next(&mut self) -> Poll<Option<T>>
```

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

### AsyncStreamReceiver Struct Definition

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.AsyncStreamReceiver.html

Defines the AsyncStreamReceiver struct, which is used to receive multiple items from an async stream. It has private fields.

```rust
pub struct AsyncStreamReceiver<T> { /* private fields */ }
```

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

### TaskStream Struct Definition

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.TaskStream.html

Defines the TaskStream struct, a Bevy SystemParam for background async stream execution.

```rust
pub struct TaskStream<'s, T>(/* private fields */);
```

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

### Split AsyncStream into Future and Receiver

Source: https://docs.rs/bevy_async_task/0.12.0/bevy_async_task/struct.AsyncStream.html

Splits an AsyncStream into a runnable future and an AsyncStreamReceiver. This is a low-level operation intended for specific use cases.

```rust
pub fn split( self, ) -> (impl ConditionalSendFuture<Output = ()>, AsyncStreamReceiver<T>)
```
Tokens:
Raw