Struct AsyncProtocol 

pub struct AsyncProtocol<'a> {
    pub binding: &'a AsyncBinding,
    pub cancellable: bool,
    pub result_adopt: ReturnFree,
    pub error: ErrorStrategy,
}

The async completion contract every backend renders.

The launcher returns immediately; the producer later invokes the completion callback exactly once, from an arbitrary producer thread. The contract has three clauses:

1. Single completion. The callback fires exactly once per launch; the wrapper resolves its native future idiom (a Python asyncio future, a JS Promise, a Swift continuation, a C# TaskCompletionSource, a Go channel) exactly once and then releases the registration.
2. Borrowed results. Result buffers passed to the callback (strings, bytes, arrays) are owned by the producer and valid only for the callback’s duration; the wrapper must deep-copy them before the callback returns and must not free them. Owned-object results (records, rich enums, interfaces) are the exception: the callback receives ownership and adopts the pointer.
3. Foreign-thread delivery. The callback runs on a producer thread, so the wrapper must hop back to its native scheduler before touching consumer state (call_soon_threadsafe, a threadsafe function, a dispatched continuation) rather than resolving inline where the target’s runtime forbids it.

The callback’s err slot follows the owning function’s ErrorStrategy. The error struct itself is producer-owned and borrowed for the callback’s duration: the wrapper copies the code and message inside the callback and the producer releases the message afterward. A wrapper may also call error_clear itself; the clear is idempotent (it nulls the message pointer), so the producer’s own release stays safe.

Fields

binding: &'a AsyncBinding

The lowered async surface: launcher and callback typedef.

cancellable: bool

Whether the launcher carries a cancel_token slot before callback/context.

result_adopt: ReturnFree

The release owed for an owned-object result adopted by the callback; ReturnFree::None for borrowed (copy-only) results.

error: ErrorStrategy

How the callback’s err slot is interpreted.

Trait Implementations

impl<'a> Clone for AsyncProtocol<'a>

fn clone(&self) -> AsyncProtocol<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for AsyncProtocol<'a>

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

Formats the value using the given formatter.

impl<'a> Eq for AsyncProtocol<'a>

impl<'a> PartialEq for AsyncProtocol<'a>

fn eq(&self, other: &AsyncProtocol<'a>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<'a> StructuralPartialEq for AsyncProtocol<'a>