Crate zng_task

Parallel async tasks and async task runners.

Crate

This crate is part of the zng project.

Cargo Features

This crate provides 4 feature flags, 0 enabled by default.

"deadlock_detection"

Enables parking_lot deadlock detection.

"ipc"

Enables ipc tasks.

Only enables in cfg(not(any(target_os = "android", target_arch = "wasm32", target_os = "ios"))) builds.

"http"

Enables http tasks.

"test_util"

Enabled by doc tests.

Re-exports

• pub use parking_lot;
• pub use rayon;

Modules

• channel
  Async channels.
• fs
  Async filesystem primitives.
• http
  HTTP client.
• io
  IO tasks.
• ipc
  IPC tasks.

Macros

• all
  A future that zips other futures.
• all_ok
  A future that is ready when all futures are ready with an Ok(T) result or any future is ready with an Err(E) result.
• all_some
  A future that is ready when all futures are ready with Some(T) or when any is future ready with None.
• any
  A future that awaits for the first future that is ready.
• any_ok
  A future that waits for the first future that is ready with an Ok(T) result.
• any_some
  A future that is ready when any of the futures is ready and Some(T).

Structs

• DEADLINE_APP
  Deadline APP integration.
• DeadlineError
  Error when with_deadline reach a time limit before a task finishes.
• McWaker
  A Waker that dispatches a wake call to multiple other wakers.
• ParallelIteratorWithCtx
  Parallel iterator adapter the propagates the thread context.
• Progress
  Status update about a task progress.
• ScopeCtx
  Represents a fork-join scope which can be used to spawn any number of tasks that run in the caller’s thread context.
• SignalOnce
  A future that will await until set is called.
• UiTask
  Represents a Future running in sync with the UI.

Traits

• ParallelIteratorExt
  Extends rayon’s ParallelIterator with thread context.

Functions

• block_on
  Blocks the thread until the task future finishes.
• deadline
  A future that is Pending until the deadline is reached.
• doc_test
  Executor used in async doc tests.
• future_fn
  Implements a Future from a closure.
• join
  Rayon join with local context.
• join_context
  Rayon join context with local context.
• poll_respond
  Polls the task once immediately on the calling thread, if the task is ready returns the response already set, if the task is pending continues execution like respond.
• poll_spawn
  Polls the task once immediately on the calling thread, if the task is pending, continues execution in spawn.
• respond
  Spawn a parallel async task that will send its result to a ResponseVar<R>.
• run
  Spawn a parallel async task that can also be .await for the task result.
• run_catch
  Like run but catches panics.
• scope
  Rayon scope with local context.
• spawn
  Spawn a parallel async task, this function is not blocking and the task starts executing immediately.
• spawn_wait
  Fire and forget a wait task. The task starts executing immediately.
• spin_on
  Continuous poll the task until if finishes.
• wait
  Create a parallel task that blocks awaiting for an IO operation, the task starts on the first .await.
• wait_catch
  Like wait but catches panics.
• wait_respond
  Like spawn_wait, but the task will send its result to a ResponseVar<R>.
• with_deadline
  Add a deadline to a future.
• yield_now
  A future that is Pending once and wakes the current task.