Trait linera_witty::WitStore

pub trait WitStore: WitType {
    // Required methods
    fn store<Instance>(
        &self,
        memory: &mut Memory<'_, Instance>,
        location: GuestPointer,
    ) -> Result<(), RuntimeError>
       where Instance: InstanceWithMemory,
             <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>;
    fn lower<Instance>(
        &self,
        memory: &mut Memory<'_, Instance>,
    ) -> Result<<Self::Layout as Layout>::Flat, RuntimeError>
       where Instance: InstanceWithMemory,
             <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>;
}

A type that can be stored in a guest Wasm module.

Required Methods

fn store<Instance>( &self, memory: &mut Memory<'_, Instance>, location: GuestPointer, ) -> Result<(), RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

Stores the type at the location in the guest’s memory.

fn lower<Instance>( &self, memory: &mut Memory<'_, Instance>, ) -> Result<<Self::Layout as Layout>::Flat, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

Lowers the type into its flat layout representation.

May write to the memory if the type has references to heap data or if it doesn’t fit in the maximum flat layout size.

Object Safety

This trait is not object safe.

Implementations on Foreign Types

impl WitStore for Level

fn store<Instance>( &self, memory: &mut Memory<'_, Instance>, location: GuestPointer, ) -> Result<(), RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lower<Instance>( &self, memory: &mut Memory<'_, Instance>, ) -> Result<<Self::Layout as Layout>::Flat, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl WitStore for bool

fn store<Instance>( &self, memory: &mut Memory<'_, Instance>, location: GuestPointer, ) -> Result<(), RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lower<Instance>( &self, _memory: &mut Memory<'_, Instance>, ) -> Result<<Self::Layout as Layout>::Flat, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl WitStore for f32

fn store<Instance>( &self, memory: &mut Memory<'_, Instance>, location: GuestPointer, ) -> Result<(), RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lower<Instance>( &self, _memory: &mut Memory<'_, Instance>, ) -> Result<<Self::Layout as Layout>::Flat, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl WitStore for f64

fn store<Instance>( &self, memory: &mut Memory<'_, Instance>, location: GuestPointer, ) -> Result<(), RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lower<Instance>( &self, _memory: &mut Memory<'_, Instance>, ) -> Result<<Self::Layout as Layout>::Flat, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl WitStore for i8

fn store<Instance>( &self, memory: &mut Memory<'_, Instance>, location: GuestPointer, ) -> Result<(), RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lower<Instance>( &self, _memory: &mut Memory<'_, Instance>, ) -> Result<<Self::Layout as Layout>::Flat, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl WitStore for i16

fn store<Instance>( &self, memory: &mut Memory<'_, Instance>, location: GuestPointer, ) -> Result<(), RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lower<Instance>( &self, _memory: &mut Memory<'_, Instance>, ) -> Result<<Self::Layout as Layout>::Flat, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl WitStore for i32

fn store<Instance>( &self, memory: &mut Memory<'_, Instance>, location: GuestPointer, ) -> Result<(), RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lower<Instance>( &self, _memory: &mut Memory<'_, Instance>, ) -> Result<<Self::Layout as Layout>::Flat, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl WitStore for i64

fn store<Instance>( &self, memory: &mut Memory<'_, Instance>, location: GuestPointer, ) -> Result<(), RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lower<Instance>( &self, _memory: &mut Memory<'_, Instance>, ) -> Result<<Self::Layout as Layout>::Flat, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl WitStore for i128

fn store<Instance>( &self, memory: &mut Memory<'_, Instance>, location: GuestPointer, ) -> Result<(), RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lower<Instance>( &self, _memory: &mut Memory<'_, Instance>, ) -> Result<<Self::Layout as Layout>::Flat, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl WitStore for u8

fn store<Instance>( &self, memory: &mut Memory<'_, Instance>, location: GuestPointer, ) -> Result<(), RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lower<Instance>( &self, _memory: &mut Memory<'_, Instance>, ) -> Result<<Self::Layout as Layout>::Flat, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl WitStore for u16

fn store<Instance>( &self, memory: &mut Memory<'_, Instance>, location: GuestPointer, ) -> Result<(), RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lower<Instance>( &self, _memory: &mut Memory<'_, Instance>, ) -> Result<<Self::Layout as Layout>::Flat, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl WitStore for u32

fn store<Instance>( &self, memory: &mut Memory<'_, Instance>, location: GuestPointer, ) -> Result<(), RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lower<Instance>( &self, _memory: &mut Memory<'_, Instance>, ) -> Result<<Self::Layout as Layout>::Flat, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl WitStore for u64

fn store<Instance>( &self, memory: &mut Memory<'_, Instance>, location: GuestPointer, ) -> Result<(), RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lower<Instance>( &self, _memory: &mut Memory<'_, Instance>, ) -> Result<<Self::Layout as Layout>::Flat, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl WitStore for u128

fn store<Instance>( &self, memory: &mut Memory<'_, Instance>, location: GuestPointer, ) -> Result<(), RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lower<Instance>( &self, _memory: &mut Memory<'_, Instance>, ) -> Result<<Self::Layout as Layout>::Flat, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl WitStore for ()

where HNil: WitStore,

fn store<Instance>( &self, memory: &mut Memory<'_, Instance>, location: GuestPointer, ) -> Result<(), RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lower<Instance>( &self, memory: &mut Memory<'_, Instance>, ) -> Result<<Self::Layout as Layout>::Flat, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl WitStore for String

fn store<Instance>( &self, memory: &mut Memory<'_, Instance>, location: GuestPointer, ) -> Result<(), RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lower<Instance>( &self, memory: &mut Memory<'_, Instance>, ) -> Result<Self::Layout, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl WitStore for Duration

fn store<Instance>( &self, memory: &mut Memory<'_, Instance>, location: GuestPointer, ) -> Result<(), RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lower<Instance>( &self, memory: &mut Memory<'_, Instance>, ) -> Result<<Self::Layout as Layout>::Flat, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<'t, T> WitStore for &'t T

where T: WitStore + ?Sized,

fn store<Instance>( &self, memory: &mut Memory<'_, Instance>, location: GuestPointer, ) -> Result<(), RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lower<Instance>( &self, memory: &mut Memory<'_, Instance>, ) -> Result<<Self::Layout as Layout>::Flat, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<A> WitStore for (A,)

where A: WitStore, HCons<A, HNil>: WitStore, for<'a> HCons<&'a A, HNil>: WitType<Layout = <HCons<A, HNil> as WitType>::Layout> + WitStore,

fn store<Instance>( &self, memory: &mut Memory<'_, Instance>, location: GuestPointer, ) -> Result<(), RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lower<Instance>( &self, memory: &mut Memory<'_, Instance>, ) -> Result<<Self::Layout as Layout>::Flat, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<A, B> WitStore for (A, B)

where A: WitStore, B: WitStore, HCons<A, HCons<B, HNil>>: WitStore, for<'a> HCons<&'a A, HCons<&'a B, HNil>>: WitType<Layout = <HCons<A, HCons<B, HNil>> as WitType>::Layout> + WitStore,

fn store<Instance>( &self, memory: &mut Memory<'_, Instance>, location: GuestPointer, ) -> Result<(), RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lower<Instance>( &self, memory: &mut Memory<'_, Instance>, ) -> Result<<Self::Layout as Layout>::Flat, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<A, B, C> WitStore for (A, B, C)

where A: WitStore, B: WitStore, C: WitStore, HCons<A, HCons<B, HCons<C, HNil>>>: WitStore, for<'a> HCons<&'a A, HCons<&'a B, HCons<&'a C, HNil>>>: WitType<Layout = <HCons<A, HCons<B, HCons<C, HNil>>> as WitType>::Layout> + WitStore,

fn store<Instance>( &self, memory: &mut Memory<'_, Instance>, location: GuestPointer, ) -> Result<(), RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lower<Instance>( &self, memory: &mut Memory<'_, Instance>, ) -> Result<<Self::Layout as Layout>::Flat, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<A, B, C, D> WitStore for (A, B, C, D)

where A: WitStore, B: WitStore, C: WitStore, D: WitStore, HCons<A, HCons<B, HCons<C, HCons<D, HNil>>>>: WitStore, for<'a> HCons<&'a A, HCons<&'a B, HCons<&'a C, HCons<&'a D, HNil>>>>: WitType<Layout = <HCons<A, HCons<B, HCons<C, HCons<D, HNil>>>> as WitType>::Layout> + WitStore,

fn store<Instance>( &self, memory: &mut Memory<'_, Instance>, location: GuestPointer, ) -> Result<(), RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lower<Instance>( &self, memory: &mut Memory<'_, Instance>, ) -> Result<<Self::Layout as Layout>::Flat, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<A, B, C, D, E> WitStore for (A, B, C, D, E)

where A: WitStore, B: WitStore, C: WitStore, D: WitStore, E: WitStore, HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HNil>>>>>: WitStore, for<'a> HCons<&'a A, HCons<&'a B, HCons<&'a C, HCons<&'a D, HCons<&'a E, HNil>>>>>: WitType<Layout = <HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HNil>>>>> as WitType>::Layout> + WitStore,

fn store<Instance>( &self, memory: &mut Memory<'_, Instance>, location: GuestPointer, ) -> Result<(), RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lower<Instance>( &self, memory: &mut Memory<'_, Instance>, ) -> Result<<Self::Layout as Layout>::Flat, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<A, B, C, D, E, F> WitStore for (A, B, C, D, E, F)

where A: WitStore, B: WitStore, C: WitStore, D: WitStore, E: WitStore, F: WitStore, HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HNil>>>>>>: WitStore, for<'a> HCons<&'a A, HCons<&'a B, HCons<&'a C, HCons<&'a D, HCons<&'a E, HCons<&'a F, HNil>>>>>>: WitType<Layout = <HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HNil>>>>>> as WitType>::Layout> + WitStore,

fn store<Instance>( &self, memory: &mut Memory<'_, Instance>, location: GuestPointer, ) -> Result<(), RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lower<Instance>( &self, memory: &mut Memory<'_, Instance>, ) -> Result<<Self::Layout as Layout>::Flat, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<A, B, C, D, E, F, G> WitStore for (A, B, C, D, E, F, G)

where A: WitStore, B: WitStore, C: WitStore, D: WitStore, E: WitStore, F: WitStore, G: WitStore, HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HNil>>>>>>>: WitStore, for<'a> HCons<&'a A, HCons<&'a B, HCons<&'a C, HCons<&'a D, HCons<&'a E, HCons<&'a F, HCons<&'a G, HNil>>>>>>>: WitType<Layout = <HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HNil>>>>>>> as WitType>::Layout> + WitStore,

fn store<Instance>( &self, memory: &mut Memory<'_, Instance>, location: GuestPointer, ) -> Result<(), RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lower<Instance>( &self, memory: &mut Memory<'_, Instance>, ) -> Result<<Self::Layout as Layout>::Flat, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<A, B, C, D, E, F, G, H> WitStore for (A, B, C, D, E, F, G, H)

where A: WitStore, B: WitStore, C: WitStore, D: WitStore, E: WitStore, F: WitStore, G: WitStore, H: WitStore, HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HCons<H, HNil>>>>>>>>: WitStore, for<'a> HCons<&'a A, HCons<&'a B, HCons<&'a C, HCons<&'a D, HCons<&'a E, HCons<&'a F, HCons<&'a G, HCons<&'a H, HNil>>>>>>>>: WitType<Layout = <HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HCons<H, HNil>>>>>>>> as WitType>::Layout> + WitStore,

fn store<Instance>( &self, memory: &mut Memory<'_, Instance>, location: GuestPointer, ) -> Result<(), RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lower<Instance>( &self, memory: &mut Memory<'_, Instance>, ) -> Result<<Self::Layout as Layout>::Flat, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<A, B, C, D, E, F, G, H, I> WitStore for (A, B, C, D, E, F, G, H, I)

where A: WitStore, B: WitStore, C: WitStore, D: WitStore, E: WitStore, F: WitStore, G: WitStore, H: WitStore, I: WitStore, HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HCons<H, HCons<I, HNil>>>>>>>>>: WitStore, for<'a> HCons<&'a A, HCons<&'a B, HCons<&'a C, HCons<&'a D, HCons<&'a E, HCons<&'a F, HCons<&'a G, HCons<&'a H, HCons<&'a I, HNil>>>>>>>>>: WitType<Layout = <HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HCons<H, HCons<I, HNil>>>>>>>>> as WitType>::Layout> + WitStore,

fn store<Instance>( &self, memory: &mut Memory<'_, Instance>, location: GuestPointer, ) -> Result<(), RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lower<Instance>( &self, memory: &mut Memory<'_, Instance>, ) -> Result<<Self::Layout as Layout>::Flat, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<A, B, C, D, E, F, G, H, I, J> WitStore for (A, B, C, D, E, F, G, H, I, J)

where A: WitStore, B: WitStore, C: WitStore, D: WitStore, E: WitStore, F: WitStore, G: WitStore, H: WitStore, I: WitStore, J: WitStore, HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HCons<H, HCons<I, HCons<J, HNil>>>>>>>>>>: WitStore, for<'a> HCons<&'a A, HCons<&'a B, HCons<&'a C, HCons<&'a D, HCons<&'a E, HCons<&'a F, HCons<&'a G, HCons<&'a H, HCons<&'a I, HCons<&'a J, HNil>>>>>>>>>>: WitType<Layout = <HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HCons<H, HCons<I, HCons<J, HNil>>>>>>>>>> as WitType>::Layout> + WitStore,

fn store<Instance>( &self, memory: &mut Memory<'_, Instance>, location: GuestPointer, ) -> Result<(), RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lower<Instance>( &self, memory: &mut Memory<'_, Instance>, ) -> Result<<Self::Layout as Layout>::Flat, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<A, B, C, D, E, F, G, H, I, J, K> WitStore for (A, B, C, D, E, F, G, H, I, J, K)

where A: WitStore, B: WitStore, C: WitStore, D: WitStore, E: WitStore, F: WitStore, G: WitStore, H: WitStore, I: WitStore, J: WitStore, K: WitStore, HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HCons<H, HCons<I, HCons<J, HCons<K, HNil>>>>>>>>>>>: WitStore, for<'a> HCons<&'a A, HCons<&'a B, HCons<&'a C, HCons<&'a D, HCons<&'a E, HCons<&'a F, HCons<&'a G, HCons<&'a H, HCons<&'a I, HCons<&'a J, HCons<&'a K, HNil>>>>>>>>>>>: WitType<Layout = <HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HCons<H, HCons<I, HCons<J, HCons<K, HNil>>>>>>>>>>> as WitType>::Layout> + WitStore,

fn store<Instance>( &self, memory: &mut Memory<'_, Instance>, location: GuestPointer, ) -> Result<(), RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lower<Instance>( &self, memory: &mut Memory<'_, Instance>, ) -> Result<<Self::Layout as Layout>::Flat, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<A, B, C, D, E, F, G, H, I, J, K, L> WitStore for (A, B, C, D, E, F, G, H, I, J, K, L)

where A: WitStore, B: WitStore, C: WitStore, D: WitStore, E: WitStore, F: WitStore, G: WitStore, H: WitStore, I: WitStore, J: WitStore, K: WitStore, L: WitStore, HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HCons<H, HCons<I, HCons<J, HCons<K, HCons<L, HNil>>>>>>>>>>>>: WitStore, for<'a> HCons<&'a A, HCons<&'a B, HCons<&'a C, HCons<&'a D, HCons<&'a E, HCons<&'a F, HCons<&'a G, HCons<&'a H, HCons<&'a I, HCons<&'a J, HCons<&'a K, HCons<&'a L, HNil>>>>>>>>>>>>: WitType<Layout = <HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HCons<H, HCons<I, HCons<J, HCons<K, HCons<L, HNil>>>>>>>>>>>> as WitType>::Layout> + WitStore,

fn store<Instance>( &self, memory: &mut Memory<'_, Instance>, location: GuestPointer, ) -> Result<(), RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lower<Instance>( &self, memory: &mut Memory<'_, Instance>, ) -> Result<<Self::Layout as Layout>::Flat, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<A, B, C, D, E, F, G, H, I, J, K, L, M> WitStore for (A, B, C, D, E, F, G, H, I, J, K, L, M)

where A: WitStore, B: WitStore, C: WitStore, D: WitStore, E: WitStore, F: WitStore, G: WitStore, H: WitStore, I: WitStore, J: WitStore, K: WitStore, L: WitStore, M: WitStore, HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HCons<H, HCons<I, HCons<J, HCons<K, HCons<L, HCons<M, HNil>>>>>>>>>>>>>: WitStore, for<'a> HCons<&'a A, HCons<&'a B, HCons<&'a C, HCons<&'a D, HCons<&'a E, HCons<&'a F, HCons<&'a G, HCons<&'a H, HCons<&'a I, HCons<&'a J, HCons<&'a K, HCons<&'a L, HCons<&'a M, HNil>>>>>>>>>>>>>: WitType<Layout = <HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HCons<H, HCons<I, HCons<J, HCons<K, HCons<L, HCons<M, HNil>>>>>>>>>>>>> as WitType>::Layout> + WitStore,

fn store<Instance>( &self, memory: &mut Memory<'_, Instance>, location: GuestPointer, ) -> Result<(), RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lower<Instance>( &self, memory: &mut Memory<'_, Instance>, ) -> Result<<Self::Layout as Layout>::Flat, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N> WitStore for (A, B, C, D, E, F, G, H, I, J, K, L, M, N)

where A: WitStore, B: WitStore, C: WitStore, D: WitStore, E: WitStore, F: WitStore, G: WitStore, H: WitStore, I: WitStore, J: WitStore, K: WitStore, L: WitStore, M: WitStore, N: WitStore, HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HCons<H, HCons<I, HCons<J, HCons<K, HCons<L, HCons<M, HCons<N, HNil>>>>>>>>>>>>>>: WitStore, for<'a> HCons<&'a A, HCons<&'a B, HCons<&'a C, HCons<&'a D, HCons<&'a E, HCons<&'a F, HCons<&'a G, HCons<&'a H, HCons<&'a I, HCons<&'a J, HCons<&'a K, HCons<&'a L, HCons<&'a M, HCons<&'a N, HNil>>>>>>>>>>>>>>: WitType<Layout = <HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HCons<H, HCons<I, HCons<J, HCons<K, HCons<L, HCons<M, HCons<N, HNil>>>>>>>>>>>>>> as WitType>::Layout> + WitStore,

fn store<Instance>( &self, memory: &mut Memory<'_, Instance>, location: GuestPointer, ) -> Result<(), RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lower<Instance>( &self, memory: &mut Memory<'_, Instance>, ) -> Result<<Self::Layout as Layout>::Flat, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> WitStore for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)

where A: WitStore, B: WitStore, C: WitStore, D: WitStore, E: WitStore, F: WitStore, G: WitStore, H: WitStore, I: WitStore, J: WitStore, K: WitStore, L: WitStore, M: WitStore, N: WitStore, O: WitStore, HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HCons<H, HCons<I, HCons<J, HCons<K, HCons<L, HCons<M, HCons<N, HCons<O, HNil>>>>>>>>>>>>>>>: WitStore, for<'a> HCons<&'a A, HCons<&'a B, HCons<&'a C, HCons<&'a D, HCons<&'a E, HCons<&'a F, HCons<&'a G, HCons<&'a H, HCons<&'a I, HCons<&'a J, HCons<&'a K, HCons<&'a L, HCons<&'a M, HCons<&'a N, HCons<&'a O, HNil>>>>>>>>>>>>>>>: WitType<Layout = <HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HCons<H, HCons<I, HCons<J, HCons<K, HCons<L, HCons<M, HCons<N, HCons<O, HNil>>>>>>>>>>>>>>> as WitType>::Layout> + WitStore,

fn store<Instance>( &self, memory: &mut Memory<'_, Instance>, location: GuestPointer, ) -> Result<(), RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lower<Instance>( &self, memory: &mut Memory<'_, Instance>, ) -> Result<<Self::Layout as Layout>::Flat, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> WitStore for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)

where A: WitStore, B: WitStore, C: WitStore, D: WitStore, E: WitStore, F: WitStore, G: WitStore, H: WitStore, I: WitStore, J: WitStore, K: WitStore, L: WitStore, M: WitStore, N: WitStore, O: WitStore, P: WitStore, HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HCons<H, HCons<I, HCons<J, HCons<K, HCons<L, HCons<M, HCons<N, HCons<O, HCons<P, HNil>>>>>>>>>>>>>>>>: WitStore, for<'a> HCons<&'a A, HCons<&'a B, HCons<&'a C, HCons<&'a D, HCons<&'a E, HCons<&'a F, HCons<&'a G, HCons<&'a H, HCons<&'a I, HCons<&'a J, HCons<&'a K, HCons<&'a L, HCons<&'a M, HCons<&'a N, HCons<&'a O, HCons<&'a P, HNil>>>>>>>>>>>>>>>>: WitType<Layout = <HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HCons<H, HCons<I, HCons<J, HCons<K, HCons<L, HCons<M, HCons<N, HCons<O, HCons<P, HNil>>>>>>>>>>>>>>>> as WitType>::Layout> + WitStore,

fn store<Instance>( &self, memory: &mut Memory<'_, Instance>, location: GuestPointer, ) -> Result<(), RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lower<Instance>( &self, memory: &mut Memory<'_, Instance>, ) -> Result<<Self::Layout as Layout>::Flat, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q> WitStore for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)

where A: WitStore, B: WitStore, C: WitStore, D: WitStore, E: WitStore, F: WitStore, G: WitStore, H: WitStore, I: WitStore, J: WitStore, K: WitStore, L: WitStore, M: WitStore, N: WitStore, O: WitStore, P: WitStore, Q: WitStore, HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HCons<H, HCons<I, HCons<J, HCons<K, HCons<L, HCons<M, HCons<N, HCons<O, HCons<P, HCons<Q, HNil>>>>>>>>>>>>>>>>>: WitStore, for<'a> HCons<&'a A, HCons<&'a B, HCons<&'a C, HCons<&'a D, HCons<&'a E, HCons<&'a F, HCons<&'a G, HCons<&'a H, HCons<&'a I, HCons<&'a J, HCons<&'a K, HCons<&'a L, HCons<&'a M, HCons<&'a N, HCons<&'a O, HCons<&'a P, HCons<&'a Q, HNil>>>>>>>>>>>>>>>>>: WitType<Layout = <HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HCons<H, HCons<I, HCons<J, HCons<K, HCons<L, HCons<M, HCons<N, HCons<O, HCons<P, HCons<Q, HNil>>>>>>>>>>>>>>>>> as WitType>::Layout> + WitStore,

fn store<Instance>( &self, memory: &mut Memory<'_, Instance>, location: GuestPointer, ) -> Result<(), RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lower<Instance>( &self, memory: &mut Memory<'_, Instance>, ) -> Result<<Self::Layout as Layout>::Flat, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R> WitStore for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)

where A: WitStore, B: WitStore, C: WitStore, D: WitStore, E: WitStore, F: WitStore, G: WitStore, H: WitStore, I: WitStore, J: WitStore, K: WitStore, L: WitStore, M: WitStore, N: WitStore, O: WitStore, P: WitStore, Q: WitStore, R: WitStore, HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HCons<H, HCons<I, HCons<J, HCons<K, HCons<L, HCons<M, HCons<N, HCons<O, HCons<P, HCons<Q, HCons<R, HNil>>>>>>>>>>>>>>>>>>: WitStore, for<'a> HCons<&'a A, HCons<&'a B, HCons<&'a C, HCons<&'a D, HCons<&'a E, HCons<&'a F, HCons<&'a G, HCons<&'a H, HCons<&'a I, HCons<&'a J, HCons<&'a K, HCons<&'a L, HCons<&'a M, HCons<&'a N, HCons<&'a O, HCons<&'a P, HCons<&'a Q, HCons<&'a R, HNil>>>>>>>>>>>>>>>>>>: WitType<Layout = <HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HCons<H, HCons<I, HCons<J, HCons<K, HCons<L, HCons<M, HCons<N, HCons<O, HCons<P, HCons<Q, HCons<R, HNil>>>>>>>>>>>>>>>>>> as WitType>::Layout> + WitStore,

fn store<Instance>( &self, memory: &mut Memory<'_, Instance>, location: GuestPointer, ) -> Result<(), RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lower<Instance>( &self, memory: &mut Memory<'_, Instance>, ) -> Result<<Self::Layout as Layout>::Flat, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S> WitStore for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)

where A: WitStore, B: WitStore, C: WitStore, D: WitStore, E: WitStore, F: WitStore, G: WitStore, H: WitStore, I: WitStore, J: WitStore, K: WitStore, L: WitStore, M: WitStore, N: WitStore, O: WitStore, P: WitStore, Q: WitStore, R: WitStore, S: WitStore, HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HCons<H, HCons<I, HCons<J, HCons<K, HCons<L, HCons<M, HCons<N, HCons<O, HCons<P, HCons<Q, HCons<R, HCons<S, HNil>>>>>>>>>>>>>>>>>>>: WitStore, for<'a> HCons<&'a A, HCons<&'a B, HCons<&'a C, HCons<&'a D, HCons<&'a E, HCons<&'a F, HCons<&'a G, HCons<&'a H, HCons<&'a I, HCons<&'a J, HCons<&'a K, HCons<&'a L, HCons<&'a M, HCons<&'a N, HCons<&'a O, HCons<&'a P, HCons<&'a Q, HCons<&'a R, HCons<&'a S, HNil>>>>>>>>>>>>>>>>>>>: WitType<Layout = <HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HCons<H, HCons<I, HCons<J, HCons<K, HCons<L, HCons<M, HCons<N, HCons<O, HCons<P, HCons<Q, HCons<R, HCons<S, HNil>>>>>>>>>>>>>>>>>>> as WitType>::Layout> + WitStore,

fn store<Instance>( &self, memory: &mut Memory<'_, Instance>, location: GuestPointer, ) -> Result<(), RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lower<Instance>( &self, memory: &mut Memory<'_, Instance>, ) -> Result<<Self::Layout as Layout>::Flat, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T> WitStore for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)

where A: WitStore, B: WitStore, C: WitStore, D: WitStore, E: WitStore, F: WitStore, G: WitStore, H: WitStore, I: WitStore, J: WitStore, K: WitStore, L: WitStore, M: WitStore, N: WitStore, O: WitStore, P: WitStore, Q: WitStore, R: WitStore, S: WitStore, T: WitStore, HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HCons<H, HCons<I, HCons<J, HCons<K, HCons<L, HCons<M, HCons<N, HCons<O, HCons<P, HCons<Q, HCons<R, HCons<S, HCons<T, HNil>>>>>>>>>>>>>>>>>>>>: WitStore, for<'a> HCons<&'a A, HCons<&'a B, HCons<&'a C, HCons<&'a D, HCons<&'a E, HCons<&'a F, HCons<&'a G, HCons<&'a H, HCons<&'a I, HCons<&'a J, HCons<&'a K, HCons<&'a L, HCons<&'a M, HCons<&'a N, HCons<&'a O, HCons<&'a P, HCons<&'a Q, HCons<&'a R, HCons<&'a S, HCons<&'a T, HNil>>>>>>>>>>>>>>>>>>>>: WitType<Layout = <HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HCons<H, HCons<I, HCons<J, HCons<K, HCons<L, HCons<M, HCons<N, HCons<O, HCons<P, HCons<Q, HCons<R, HCons<S, HCons<T, HNil>>>>>>>>>>>>>>>>>>>> as WitType>::Layout> + WitStore,

fn store<Instance>( &self, memory: &mut Memory<'_, Instance>, location: GuestPointer, ) -> Result<(), RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lower<Instance>( &self, memory: &mut Memory<'_, Instance>, ) -> Result<<Self::Layout as Layout>::Flat, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U> WitStore for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)

where A: WitStore, B: WitStore, C: WitStore, D: WitStore, E: WitStore, F: WitStore, G: WitStore, H: WitStore, I: WitStore, J: WitStore, K: WitStore, L: WitStore, M: WitStore, N: WitStore, O: WitStore, P: WitStore, Q: WitStore, R: WitStore, S: WitStore, T: WitStore, U: WitStore, HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HCons<H, HCons<I, HCons<J, HCons<K, HCons<L, HCons<M, HCons<N, HCons<O, HCons<P, HCons<Q, HCons<R, HCons<S, HCons<T, HCons<U, HNil>>>>>>>>>>>>>>>>>>>>>: WitStore, for<'a> HCons<&'a A, HCons<&'a B, HCons<&'a C, HCons<&'a D, HCons<&'a E, HCons<&'a F, HCons<&'a G, HCons<&'a H, HCons<&'a I, HCons<&'a J, HCons<&'a K, HCons<&'a L, HCons<&'a M, HCons<&'a N, HCons<&'a O, HCons<&'a P, HCons<&'a Q, HCons<&'a R, HCons<&'a S, HCons<&'a T, HCons<&'a U, HNil>>>>>>>>>>>>>>>>>>>>>: WitType<Layout = <HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HCons<H, HCons<I, HCons<J, HCons<K, HCons<L, HCons<M, HCons<N, HCons<O, HCons<P, HCons<Q, HCons<R, HCons<S, HCons<T, HCons<U, HNil>>>>>>>>>>>>>>>>>>>>> as WitType>::Layout> + WitStore,

fn store<Instance>( &self, memory: &mut Memory<'_, Instance>, location: GuestPointer, ) -> Result<(), RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lower<Instance>( &self, memory: &mut Memory<'_, Instance>, ) -> Result<<Self::Layout as Layout>::Flat, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V> WitStore for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)

where A: WitStore, B: WitStore, C: WitStore, D: WitStore, E: WitStore, F: WitStore, G: WitStore, H: WitStore, I: WitStore, J: WitStore, K: WitStore, L: WitStore, M: WitStore, N: WitStore, O: WitStore, P: WitStore, Q: WitStore, R: WitStore, S: WitStore, T: WitStore, U: WitStore, V: WitStore, HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HCons<H, HCons<I, HCons<J, HCons<K, HCons<L, HCons<M, HCons<N, HCons<O, HCons<P, HCons<Q, HCons<R, HCons<S, HCons<T, HCons<U, HCons<V, HNil>>>>>>>>>>>>>>>>>>>>>>: WitStore, for<'a> HCons<&'a A, HCons<&'a B, HCons<&'a C, HCons<&'a D, HCons<&'a E, HCons<&'a F, HCons<&'a G, HCons<&'a H, HCons<&'a I, HCons<&'a J, HCons<&'a K, HCons<&'a L, HCons<&'a M, HCons<&'a N, HCons<&'a O, HCons<&'a P, HCons<&'a Q, HCons<&'a R, HCons<&'a S, HCons<&'a T, HCons<&'a U, HCons<&'a V, HNil>>>>>>>>>>>>>>>>>>>>>>: WitType<Layout = <HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HCons<H, HCons<I, HCons<J, HCons<K, HCons<L, HCons<M, HCons<N, HCons<O, HCons<P, HCons<Q, HCons<R, HCons<S, HCons<T, HCons<U, HCons<V, HNil>>>>>>>>>>>>>>>>>>>>>> as WitType>::Layout> + WitStore,

fn store<Instance>( &self, memory: &mut Memory<'_, Instance>, location: GuestPointer, ) -> Result<(), RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lower<Instance>( &self, memory: &mut Memory<'_, Instance>, ) -> Result<<Self::Layout as Layout>::Flat, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W> WitStore for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)

where A: WitStore, B: WitStore, C: WitStore, D: WitStore, E: WitStore, F: WitStore, G: WitStore, H: WitStore, I: WitStore, J: WitStore, K: WitStore, L: WitStore, M: WitStore, N: WitStore, O: WitStore, P: WitStore, Q: WitStore, R: WitStore, S: WitStore, T: WitStore, U: WitStore, V: WitStore, W: WitStore, HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HCons<H, HCons<I, HCons<J, HCons<K, HCons<L, HCons<M, HCons<N, HCons<O, HCons<P, HCons<Q, HCons<R, HCons<S, HCons<T, HCons<U, HCons<V, HCons<W, HNil>>>>>>>>>>>>>>>>>>>>>>>: WitStore, for<'a> HCons<&'a A, HCons<&'a B, HCons<&'a C, HCons<&'a D, HCons<&'a E, HCons<&'a F, HCons<&'a G, HCons<&'a H, HCons<&'a I, HCons<&'a J, HCons<&'a K, HCons<&'a L, HCons<&'a M, HCons<&'a N, HCons<&'a O, HCons<&'a P, HCons<&'a Q, HCons<&'a R, HCons<&'a S, HCons<&'a T, HCons<&'a U, HCons<&'a V, HCons<&'a W, HNil>>>>>>>>>>>>>>>>>>>>>>>: WitType<Layout = <HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HCons<H, HCons<I, HCons<J, HCons<K, HCons<L, HCons<M, HCons<N, HCons<O, HCons<P, HCons<Q, HCons<R, HCons<S, HCons<T, HCons<U, HCons<V, HCons<W, HNil>>>>>>>>>>>>>>>>>>>>>>> as WitType>::Layout> + WitStore,

fn store<Instance>( &self, memory: &mut Memory<'_, Instance>, location: GuestPointer, ) -> Result<(), RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lower<Instance>( &self, memory: &mut Memory<'_, Instance>, ) -> Result<<Self::Layout as Layout>::Flat, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X> WitStore for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)

where A: WitStore, B: WitStore, C: WitStore, D: WitStore, E: WitStore, F: WitStore, G: WitStore, H: WitStore, I: WitStore, J: WitStore, K: WitStore, L: WitStore, M: WitStore, N: WitStore, O: WitStore, P: WitStore, Q: WitStore, R: WitStore, S: WitStore, T: WitStore, U: WitStore, V: WitStore, W: WitStore, X: WitStore, HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HCons<H, HCons<I, HCons<J, HCons<K, HCons<L, HCons<M, HCons<N, HCons<O, HCons<P, HCons<Q, HCons<R, HCons<S, HCons<T, HCons<U, HCons<V, HCons<W, HCons<X, HNil>>>>>>>>>>>>>>>>>>>>>>>>: WitStore, for<'a> HCons<&'a A, HCons<&'a B, HCons<&'a C, HCons<&'a D, HCons<&'a E, HCons<&'a F, HCons<&'a G, HCons<&'a H, HCons<&'a I, HCons<&'a J, HCons<&'a K, HCons<&'a L, HCons<&'a M, HCons<&'a N, HCons<&'a O, HCons<&'a P, HCons<&'a Q, HCons<&'a R, HCons<&'a S, HCons<&'a T, HCons<&'a U, HCons<&'a V, HCons<&'a W, HCons<&'a X, HNil>>>>>>>>>>>>>>>>>>>>>>>>: WitType<Layout = <HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HCons<H, HCons<I, HCons<J, HCons<K, HCons<L, HCons<M, HCons<N, HCons<O, HCons<P, HCons<Q, HCons<R, HCons<S, HCons<T, HCons<U, HCons<V, HCons<W, HCons<X, HNil>>>>>>>>>>>>>>>>>>>>>>>> as WitType>::Layout> + WitStore,

fn store<Instance>( &self, memory: &mut Memory<'_, Instance>, location: GuestPointer, ) -> Result<(), RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lower<Instance>( &self, memory: &mut Memory<'_, Instance>, ) -> Result<<Self::Layout as Layout>::Flat, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y> WitStore for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)

where A: WitStore, B: WitStore, C: WitStore, D: WitStore, E: WitStore, F: WitStore, G: WitStore, H: WitStore, I: WitStore, J: WitStore, K: WitStore, L: WitStore, M: WitStore, N: WitStore, O: WitStore, P: WitStore, Q: WitStore, R: WitStore, S: WitStore, T: WitStore, U: WitStore, V: WitStore, W: WitStore, X: WitStore, Y: WitStore, HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HCons<H, HCons<I, HCons<J, HCons<K, HCons<L, HCons<M, HCons<N, HCons<O, HCons<P, HCons<Q, HCons<R, HCons<S, HCons<T, HCons<U, HCons<V, HCons<W, HCons<X, HCons<Y, HNil>>>>>>>>>>>>>>>>>>>>>>>>>: WitStore, for<'a> HCons<&'a A, HCons<&'a B, HCons<&'a C, HCons<&'a D, HCons<&'a E, HCons<&'a F, HCons<&'a G, HCons<&'a H, HCons<&'a I, HCons<&'a J, HCons<&'a K, HCons<&'a L, HCons<&'a M, HCons<&'a N, HCons<&'a O, HCons<&'a P, HCons<&'a Q, HCons<&'a R, HCons<&'a S, HCons<&'a T, HCons<&'a U, HCons<&'a V, HCons<&'a W, HCons<&'a X, HCons<&'a Y, HNil>>>>>>>>>>>>>>>>>>>>>>>>>: WitType<Layout = <HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HCons<H, HCons<I, HCons<J, HCons<K, HCons<L, HCons<M, HCons<N, HCons<O, HCons<P, HCons<Q, HCons<R, HCons<S, HCons<T, HCons<U, HCons<V, HCons<W, HCons<X, HCons<Y, HNil>>>>>>>>>>>>>>>>>>>>>>>>> as WitType>::Layout> + WitStore,

fn store<Instance>( &self, memory: &mut Memory<'_, Instance>, location: GuestPointer, ) -> Result<(), RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lower<Instance>( &self, memory: &mut Memory<'_, Instance>, ) -> Result<<Self::Layout as Layout>::Flat, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> WitStore for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)

where A: WitStore, B: WitStore, C: WitStore, D: WitStore, E: WitStore, F: WitStore, G: WitStore, H: WitStore, I: WitStore, J: WitStore, K: WitStore, L: WitStore, M: WitStore, N: WitStore, O: WitStore, P: WitStore, Q: WitStore, R: WitStore, S: WitStore, T: WitStore, U: WitStore, V: WitStore, W: WitStore, X: WitStore, Y: WitStore, Z: WitStore, HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HCons<H, HCons<I, HCons<J, HCons<K, HCons<L, HCons<M, HCons<N, HCons<O, HCons<P, HCons<Q, HCons<R, HCons<S, HCons<T, HCons<U, HCons<V, HCons<W, HCons<X, HCons<Y, HCons<Z, HNil>>>>>>>>>>>>>>>>>>>>>>>>>>: WitStore, for<'a> HCons<&'a A, HCons<&'a B, HCons<&'a C, HCons<&'a D, HCons<&'a E, HCons<&'a F, HCons<&'a G, HCons<&'a H, HCons<&'a I, HCons<&'a J, HCons<&'a K, HCons<&'a L, HCons<&'a M, HCons<&'a N, HCons<&'a O, HCons<&'a P, HCons<&'a Q, HCons<&'a R, HCons<&'a S, HCons<&'a T, HCons<&'a U, HCons<&'a V, HCons<&'a W, HCons<&'a X, HCons<&'a Y, HCons<&'a Z, HNil>>>>>>>>>>>>>>>>>>>>>>>>>>: WitType<Layout = <HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HCons<H, HCons<I, HCons<J, HCons<K, HCons<L, HCons<M, HCons<N, HCons<O, HCons<P, HCons<Q, HCons<R, HCons<S, HCons<T, HCons<U, HCons<V, HCons<W, HCons<X, HCons<Y, HCons<Z, HNil>>>>>>>>>>>>>>>>>>>>>>>>>> as WitType>::Layout> + WitStore,

fn store<Instance>( &self, memory: &mut Memory<'_, Instance>, location: GuestPointer, ) -> Result<(), RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lower<Instance>( &self, memory: &mut Memory<'_, Instance>, ) -> Result<<Self::Layout as Layout>::Flat, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<K, V> WitStore for BTreeMap<K, V>

where K: WitType, V: WitType, (K, V): WitStore, for<'a> (&'a K, &'a V): WitStore,

fn store<Instance>( &self, memory: &mut Memory<'_, Instance>, location: GuestPointer, ) -> Result<(), RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lower<Instance>( &self, memory: &mut Memory<'_, Instance>, ) -> Result<Self::Layout, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<T> WitStore for Option<T>

where T: WitStore, HNil: Merge<T::Layout>, <HNil as Merge<T::Layout>>::Output: Layout, <T::Layout as Layout>::Flat: JoinFlatLayouts<<<HNil as Merge<T::Layout>>::Output as Layout>::Flat>,

fn store<Instance>( &self, memory: &mut Memory<'_, Instance>, location: GuestPointer, ) -> Result<(), RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lower<Instance>( &self, memory: &mut Memory<'_, Instance>, ) -> Result<<Self::Layout as Layout>::Flat, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<T> WitStore for [T]

where T: WitStore,

fn store<Instance>( &self, memory: &mut Memory<'_, Instance>, location: GuestPointer, ) -> Result<(), RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lower<Instance>( &self, memory: &mut Memory<'_, Instance>, ) -> Result<Self::Layout, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<T> WitStore for Box<[T]>

where T: WitStore,

fn store<Instance>( &self, memory: &mut Memory<'_, Instance>, location: GuestPointer, ) -> Result<(), RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lower<Instance>( &self, memory: &mut Memory<'_, Instance>, ) -> Result<Self::Layout, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<T> WitStore for Box<T>

where T: WitStore,

fn store<Instance>( &self, memory: &mut Memory<'_, Instance>, location: GuestPointer, ) -> Result<(), RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lower<Instance>( &self, memory: &mut Memory<'_, Instance>, ) -> Result<<Self::Layout as Layout>::Flat, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<T> WitStore for BTreeSet<T>

where T: WitType + WitStore, for<'a> &'a T: WitStore,

fn store<Instance>( &self, memory: &mut Memory<'_, Instance>, location: GuestPointer, ) -> Result<(), RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lower<Instance>( &self, memory: &mut Memory<'_, Instance>, ) -> Result<Self::Layout, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<T> WitStore for Rc<[T]>

where T: WitStore,

fn store<Instance>( &self, memory: &mut Memory<'_, Instance>, location: GuestPointer, ) -> Result<(), RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lower<Instance>( &self, memory: &mut Memory<'_, Instance>, ) -> Result<Self::Layout, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<T> WitStore for Rc<T>

where T: WitStore,

fn store<Instance>( &self, memory: &mut Memory<'_, Instance>, location: GuestPointer, ) -> Result<(), RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lower<Instance>( &self, memory: &mut Memory<'_, Instance>, ) -> Result<<Self::Layout as Layout>::Flat, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<T> WitStore for Arc<[T]>

where T: WitStore,

fn store<Instance>( &self, memory: &mut Memory<'_, Instance>, location: GuestPointer, ) -> Result<(), RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lower<Instance>( &self, memory: &mut Memory<'_, Instance>, ) -> Result<Self::Layout, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<T> WitStore for Arc<T>

where T: WitStore,

fn store<Instance>( &self, memory: &mut Memory<'_, Instance>, location: GuestPointer, ) -> Result<(), RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lower<Instance>( &self, memory: &mut Memory<'_, Instance>, ) -> Result<<Self::Layout as Layout>::Flat, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<T> WitStore for Vec<T>

where T: WitStore,

fn store<Instance>( &self, memory: &mut Memory<'_, Instance>, location: GuestPointer, ) -> Result<(), RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lower<Instance>( &self, memory: &mut Memory<'_, Instance>, ) -> Result<Self::Layout, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<T> WitStore for PhantomData<T>

fn store<Instance>( &self, _memory: &mut Memory<'_, Instance>, _location: GuestPointer, ) -> Result<(), RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lower<Instance>( &self, _memory: &mut Memory<'_, Instance>, ) -> Result<Self::Layout, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<T, E> WitStore for Result<T, E>

where T: WitStore, E: WitStore, T::Layout: Merge<E::Layout>, <T::Layout as Merge<E::Layout>>::Output: Layout, <T::Layout as Layout>::Flat: JoinFlatLayouts<<<T::Layout as Merge<E::Layout>>::Output as Layout>::Flat>, <E::Layout as Layout>::Flat: JoinFlatLayouts<<<T::Layout as Merge<E::Layout>>::Output as Layout>::Flat>,

fn store<Instance>( &self, memory: &mut Memory<'_, Instance>, location: GuestPointer, ) -> Result<(), RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lower<Instance>( &self, memory: &mut Memory<'_, Instance>, ) -> Result<<Self::Layout as Layout>::Flat, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

Implementors

impl WitStore for GuestPointer

impl WitStore for HNil

impl<Head, Tail> WitStore for HCons<Head, Tail>

where Head: WitStore, Tail: WitStore + SizeCalculation, Head::Layout: Add<Tail::Layout>, <Head::Layout as Add<Tail::Layout>>::Output: Layout, <Head::Layout as Layout>::Flat: Add<<Tail::Layout as Layout>::Flat>, Self::Layout: Layout<Flat = <<Head::Layout as Layout>::Flat as Add<<Tail::Layout as Layout>::Flat>>::Output>,