Struct FiberHandle 

pub struct FiberHandle<A, E> { /* private fields */ }

Runtime-owned handle to a spawned fiber.

Completion is backed by Deferred (watch-channel rendezvous). Self::join and Self::await_exit surface completion; Self::await_exit returns the full Exit value.

Implementations

impl<A, E> FiberHandle<A, E>

where A: Clone + Send + Sync + 'static, E: Clone + Send + Sync + 'static,

pub fn pending(id: FiberId) -> Self

Handle for a fiber not yet completed (waits on internal Deferred).

pub fn completed(id: FiberId, result: Result<A, E>) -> Self

Handle already completed with result.

pub fn id(&self) -> FiberId

Fiber id assigned at creation.

pub fn mark_completed(&self, result: Result<A, E>)

Complete the underlying deferred with result (for tests / manual drivers).

pub fn interrupt(&self) -> bool

Fail the fiber with Cause::Interrupt. Returns false if already completed.

pub fn status(&self) -> FiberStatus

Running vs terminal outcome (blocking poll of the deferred).

pub fn is_done(&self) -> bool

true when Self::status is not FiberStatus::Running.

pub fn poll(&self) -> Effect<Option<Exit<A, E>>, Never, ()>

Non-blocking read of the current Exit, if the fiber has completed.

pub fn poll_result(&self) -> Option<Result<A, Cause<E>>>

Snapshot for callers that want the legacy Option<Result<_, Cause>> shape: None while running or when the stored exit is an interrupt (matches older FiberHandle::poll).

pub fn await_exit(&self) -> Effect<Exit<A, E>, Never, ()>

Wait for completion and return the full Exit (success or failure Cause).

pub async fn join(&self) -> Result<A, Cause<E>>

Await completion and map to Result (interrupt surfaces as Cause::Interrupt).

pub fn map<B>( self, f: impl Fn(A) -> B + Send + Sync + 'static, ) -> FiberHandle<B, E>

where B: Clone + Send + Sync + 'static,

Map a successful value after this fiber completes (spawns a background join on the tokio runtime).

pub fn zip<B>(self, other: FiberHandle<B, E>) -> FiberHandle<(A, B), E>

where B: Clone + Send + Sync + 'static,

Zip two fibers; both must succeed. The first failure Cause wins.

pub fn zip_with<B, C, F>( self, other: FiberHandle<B, E>, f: F, ) -> FiberHandle<C, E>

where B: Clone + Send + Sync + 'static, C: Clone + Send + Sync + 'static, F: Fn(A, B) -> C + Send + Sync + 'static,

Like Self::zip, then combine success values with f.

pub fn or_else(self, other: FiberHandle<A, E>) -> FiberHandle<A, E>

Race: complete with whichever fiber finishes first (the other keeps running for other waiters).

pub fn scoped(self) -> Effect<A, Cause<E>, Scope>

Register a scope finalizer that interrupts this fiber on scope close, then await completion under the given Scope environment.

pub fn interrupt_fork(&self) -> Effect<(), Never, ()>

Request interrupt from the async runtime without blocking the caller.

Trait Implementations

impl<A: Clone, E: Clone> Clone for FiberHandle<A, E>

fn clone(&self) -> FiberHandle<A, E>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<A: Debug, E: Debug> Debug for FiberHandle<A, E>

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

Formats the value using the given formatter.