Struct AsyncProtocol 

pub struct AsyncProtocol<'a> {
    pub binding: &'a AsyncBinding,
    pub cancellable: bool,
    pub result: RetPass,
    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. Owned results. Everything passed to the callback is owned by the consumer. String results are released with {prefix}_free_bytes, byte and buffered-value results with {prefix}_free_bytes, and interface-object results transfer one strong reference (the wrapper adopts the pointer). This is what lets runtimes that defer callback bodies past the native return (Dart’s NativeCallable.listener, for example) decode safely; a wrapper that processes results inline still copies or decodes first and then frees.
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. A non-null error is heap-boxed and owned by the consumer: the wrapper copies the code, message, and payload, then releases the box with {prefix}_error_free exactly once.

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: RetPass

How the callback’s result slots are received, including the release owed ({prefix}_free_bytes or the destroy symbol an adopted object owes).

error: ErrorStrategy

How the callback’s err slot is interpreted.

Trait Implementations

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

fn clone(&self) -> Self

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: &Self) -> bool

Equality operator ==.

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

Inequality operator !=.

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