Trait sallyport::guest::call::Call

pub trait Call<'a, K> where
    K: Kind, {
    type Staged: Commit<Item = Self::Committed>;
    type Committed: Collect<Item = Self::Collected>;
    type Collected;

    fn stage(self, alloc: &mut impl Allocator) -> Result<Self::Staged>;
}

An executable call.

Required Associated Types

type Staged: Commit<Item = Self::Committed>

Opaque staged value, which returns Self::Committed when committed via Commit::commit.

This is designed to serve as a container for data allocated within stage.

type Committed: Collect<Item = Self::Collected>

Opaque committed value returned by Commit::commit called upon Self::Staged, which is, in turn, passed to Collect::collect to yield a Self::Collected.

type Collected

Value call collects as.

For example, a syscall return value.

Required Methods

fn stage(self, alloc: &mut impl Allocator) -> Result<Self::Staged>

Allocate data, if necessary and return resulting opaque staged value on success.

Implementations on Foreign Types

impl<'a, AK, A> Call<'a, (AK,)> for (A,) where
    AK: Kind,
    A: Call<'a, AK>, 

type Staged = (<A as Call<'a, AK>>::Staged,)

type Committed = (<A as Call<'a, AK>>::Committed,)

type Collected = (<A as Call<'a, AK>>::Collected,)

fn stage(self, alloc: &mut impl Allocator) -> Result<Self::Staged>

impl<'a, AK, BK, A, B> Call<'a, (AK, BK)> for (A, B) where
    AK: Kind,
    BK: Kind,
    A: Call<'a, AK>,
    B: Call<'a, BK>, 

type Staged = (<A as Call<'a, AK>>::Staged, <B as Call<'a, BK>>::Staged)

type Committed = (<A as Call<'a, AK>>::Committed, <B as Call<'a, BK>>::Committed)

type Collected = (<A as Call<'a, AK>>::Collected, <B as Call<'a, BK>>::Collected)

fn stage(self, alloc: &mut impl Allocator) -> Result<Self::Staged>

impl<'a, AK, BK, CK, A, B, C> Call<'a, (AK, BK, CK)> for (A, B, C) where
    AK: Kind,
    BK: Kind,
    CK: Kind,
    A: Call<'a, AK>,
    B: Call<'a, BK>,
    C: Call<'a, CK>, 

type Staged = (<A as Call<'a, AK>>::Staged, <B as Call<'a, BK>>::Staged, <C as Call<'a, CK>>::Staged)

type Committed = (<A as Call<'a, AK>>::Committed, <B as Call<'a, BK>>::Committed, <C as Call<'a, CK>>::Committed)

type Collected = (<A as Call<'a, AK>>::Collected, <B as Call<'a, BK>>::Collected, <C as Call<'a, CK>>::Collected)

fn stage(self, alloc: &mut impl Allocator) -> Result<Self::Staged>

impl<'a, AK, BK, CK, DK, A, B, C, D> Call<'a, (AK, BK, CK, DK)> for (A, B, C, D) where
    AK: Kind,
    BK: Kind,
    CK: Kind,
    DK: Kind,
    A: Call<'a, AK>,
    B: Call<'a, BK>,
    C: Call<'a, CK>,
    D: Call<'a, DK>, 

type Staged = (<A as Call<'a, AK>>::Staged, <B as Call<'a, BK>>::Staged, <C as Call<'a, CK>>::Staged, <D as Call<'a, DK>>::Staged)

type Committed = (<A as Call<'a, AK>>::Committed, <B as Call<'a, BK>>::Committed, <C as Call<'a, CK>>::Committed, <D as Call<'a, DK>>::Committed)

type Collected = (<A as Call<'a, AK>>::Collected, <B as Call<'a, BK>>::Collected, <C as Call<'a, CK>>::Collected, <D as Call<'a, DK>>::Collected)

fn stage(self, alloc: &mut impl Allocator) -> Result<Self::Staged>

Implementors

impl<'a, K, T> Call<'a, Alloc<K>> for T where
    K: Kind,
    T: Alloc<'a, K>, 

type Staged = StagedCall<'a, K, T>

type Committed = CommittedCall<'a, K, T>

type Collected = <T as Alloc<'a, K>>::Collected

impl<'a, K, T> Call<'a, MaybeAlloc<K>> for T where
    K: Kind,
    T: MaybeAlloc<'a, K>, 

type Staged = StagedMaybeAlloc<'a, K, <T as MaybeAlloc<'a, K>>::Alloc>

type Committed = CommittedMaybeAlloc<'a, K, <T as MaybeAlloc<'a, K>>::Alloc>

type Collected = <<T as MaybeAlloc<'a, K>>::Alloc as Alloc<'a, K>>::Collected

impl<T: Stub> Call<'_, Stub> for T

type Staged = T

type Committed = T

type Collected = <T as Stub>::Ret