Trait linera_witty::WitType

pub trait WitType {
    type Layout: Layout;
    type Dependencies: RegisterWitTypes;

    const SIZE: u32;

    // Required methods
    fn wit_type_name() -> Cow<'static, str>;
    fn wit_type_declaration() -> Cow<'static, str>;
}

A type that is representable by fundamental WIT types.

Required Associated Types

type Layout: Layout

The layout of the type as fundamental types.

type Dependencies: RegisterWitTypes

Other WitTypes that this type depends on.

Required Associated Constants

const SIZE: u32

The size of the type when laid out in memory.

Required Methods

fn wit_type_name() -> Cow<'static, str>

Generates the WIT type name for this type.

fn wit_type_declaration() -> Cow<'static, str>

Generates the WIT type declaration for this type.

Object Safety

This trait is not object safe.

Implementations on Foreign Types

impl WitType for Level

const SIZE: u32 = 1u32

type Layout = HCons<i8, HNil>

type Dependencies = HNil

fn wit_type_name() -> Cow<'static, str>

fn wit_type_declaration() -> Cow<'static, str>

impl WitType for bool

const SIZE: u32 = 1u32

type Layout = HCons<i8, HNil>

type Dependencies = HNil

fn wit_type_name() -> Cow<'static, str>

fn wit_type_declaration() -> Cow<'static, str>

impl WitType for f32

const SIZE: u32 = 4u32

type Layout = HCons<f32, HNil>

type Dependencies = HNil

fn wit_type_name() -> Cow<'static, str>

fn wit_type_declaration() -> Cow<'static, str>

impl WitType for f64

const SIZE: u32 = 8u32

type Layout = HCons<f64, HNil>

type Dependencies = HNil

fn wit_type_name() -> Cow<'static, str>

fn wit_type_declaration() -> Cow<'static, str>

impl WitType for i8

const SIZE: u32 = 1u32

type Layout = HCons<i8, HNil>

type Dependencies = HNil

fn wit_type_name() -> Cow<'static, str>

fn wit_type_declaration() -> Cow<'static, str>

impl WitType for i16

const SIZE: u32 = 2u32

type Layout = HCons<i16, HNil>

type Dependencies = HNil

fn wit_type_name() -> Cow<'static, str>

fn wit_type_declaration() -> Cow<'static, str>

impl WitType for i32

const SIZE: u32 = 4u32

type Layout = HCons<i32, HNil>

type Dependencies = HNil

fn wit_type_name() -> Cow<'static, str>

fn wit_type_declaration() -> Cow<'static, str>

impl WitType for i64

const SIZE: u32 = 8u32

type Layout = HCons<i64, HNil>

type Dependencies = HNil

fn wit_type_name() -> Cow<'static, str>

fn wit_type_declaration() -> Cow<'static, str>

impl WitType for i128

const SIZE: u32 = 16u32

type Layout = HCons<i64, HCons<i64, HNil>>

type Dependencies = HNil

fn wit_type_name() -> Cow<'static, str>

fn wit_type_declaration() -> Cow<'static, str>

impl WitType for u8

const SIZE: u32 = 1u32

type Layout = HCons<u8, HNil>

type Dependencies = HNil

fn wit_type_name() -> Cow<'static, str>

fn wit_type_declaration() -> Cow<'static, str>

impl WitType for u16

const SIZE: u32 = 2u32

type Layout = HCons<u16, HNil>

type Dependencies = HNil

fn wit_type_name() -> Cow<'static, str>

fn wit_type_declaration() -> Cow<'static, str>

impl WitType for u32

const SIZE: u32 = 4u32

type Layout = HCons<u32, HNil>

type Dependencies = HNil

fn wit_type_name() -> Cow<'static, str>

fn wit_type_declaration() -> Cow<'static, str>

impl WitType for u64

const SIZE: u32 = 8u32

type Layout = HCons<u64, HNil>

type Dependencies = HNil

fn wit_type_name() -> Cow<'static, str>

fn wit_type_declaration() -> Cow<'static, str>

impl WitType for u128

const SIZE: u32 = 16u32

type Layout = HCons<u64, HCons<u64, HNil>>

type Dependencies = HNil

fn wit_type_name() -> Cow<'static, str>

fn wit_type_declaration() -> Cow<'static, str>

impl WitType for ()

where HNil: WitType,

const SIZE: u32 = 0u32

type Layout = <HNil as WitType>::Layout

type Dependencies = HNil

fn wit_type_name() -> Cow<'static, str>

fn wit_type_declaration() -> Cow<'static, str>

impl WitType for String

const SIZE: u32 = 8u32

type Layout = HCons<i32, HCons<i32, HNil>>

type Dependencies = HNil

fn wit_type_name() -> Cow<'static, str>

fn wit_type_declaration() -> Cow<'static, str>

impl WitType for Duration

const SIZE: u32 = 16u32

type Layout = <HCons<u64, HCons<u32, HNil>> as WitType>::Layout

type Dependencies = HNil

fn wit_type_name() -> Cow<'static, str>

fn wit_type_declaration() -> Cow<'static, str>

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

where T: WitType + ?Sized,

const SIZE: u32 = T::SIZE

type Layout = <T as WitType>::Layout

type Dependencies = <T as WitType>::Dependencies

fn wit_type_name() -> Cow<'static, str>

fn wit_type_declaration() -> Cow<'static, str>

impl<A> WitType for (A,)

where A: WitType, HCons<A, HNil>: WitType,

const SIZE: u32 = <::frunk_core::hlist::HCons<A, ::frunk_core::hlist::HNil> as WitType>::SIZE

type Layout = <HCons<A, HNil> as WitType>::Layout

type Dependencies = HCons<A, HNil>

fn wit_type_name() -> Cow<'static, str>

fn wit_type_declaration() -> Cow<'static, str>

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

where A: WitType, B: WitType, HCons<A, HCons<B, HNil>>: WitType,

const SIZE: u32 = <::frunk_core::hlist::HCons<A, ::frunk_core::hlist::HCons<B, ::frunk_core::hlist::HNil>> as WitType>::SIZE

type Layout = <HCons<A, HCons<B, HNil>> as WitType>::Layout

type Dependencies = HCons<A, HCons<B, HNil>>

fn wit_type_name() -> Cow<'static, str>

fn wit_type_declaration() -> Cow<'static, str>

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

where A: WitType, B: WitType, C: WitType, HCons<A, HCons<B, HCons<C, HNil>>>: WitType,

const SIZE: u32 = <::frunk_core::hlist::HCons<A, ::frunk_core::hlist::HCons<B, ::frunk_core::hlist::HCons<C, ::frunk_core::hlist::HNil>>> as WitType>::SIZE

type Layout = <HCons<A, HCons<B, HCons<C, HNil>>> as WitType>::Layout

type Dependencies = HCons<A, HCons<B, HCons<C, HNil>>>

fn wit_type_name() -> Cow<'static, str>

fn wit_type_declaration() -> Cow<'static, str>

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

where A: WitType, B: WitType, C: WitType, D: WitType, HCons<A, HCons<B, HCons<C, HCons<D, HNil>>>>: WitType,

const SIZE: u32 = <::frunk_core::hlist::HCons<A, ::frunk_core::hlist::HCons<B, ::frunk_core::hlist::HCons<C, ::frunk_core::hlist::HCons<D, ::frunk_core::hlist::HNil>>>> as WitType>::SIZE

type Layout = <HCons<A, HCons<B, HCons<C, HCons<D, HNil>>>> as WitType>::Layout

type Dependencies = HCons<A, HCons<B, HCons<C, HCons<D, HNil>>>>

fn wit_type_name() -> Cow<'static, str>

fn wit_type_declaration() -> Cow<'static, str>

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

where A: WitType, B: WitType, C: WitType, D: WitType, E: WitType, HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HNil>>>>>: WitType,

const SIZE: u32 = <::frunk_core::hlist::HCons<A, ::frunk_core::hlist::HCons<B, ::frunk_core::hlist::HCons<C, ::frunk_core::hlist::HCons<D, ::frunk_core::hlist::HCons<E, ::frunk_core::hlist::HNil>>>>> as WitType>::SIZE

type Layout = <HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HNil>>>>> as WitType>::Layout

type Dependencies = HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HNil>>>>>

fn wit_type_name() -> Cow<'static, str>

fn wit_type_declaration() -> Cow<'static, str>

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

where A: WitType, B: WitType, C: WitType, D: WitType, E: WitType, F: WitType, HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HNil>>>>>>: WitType,

const SIZE: u32 = <::frunk_core::hlist::HCons<A, ::frunk_core::hlist::HCons<B, ::frunk_core::hlist::HCons<C, ::frunk_core::hlist::HCons<D, ::frunk_core::hlist::HCons<E, ::frunk_core::hlist::HCons<F, ::frunk_core::hlist::HNil>>>>>> as WitType>::SIZE

type Layout = <HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HNil>>>>>> as WitType>::Layout

type Dependencies = HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HNil>>>>>>

fn wit_type_name() -> Cow<'static, str>

fn wit_type_declaration() -> Cow<'static, str>

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

where A: WitType, B: WitType, C: WitType, D: WitType, E: WitType, F: WitType, G: WitType, HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HNil>>>>>>>: WitType,

const SIZE: u32 = <::frunk_core::hlist::HCons<A, ::frunk_core::hlist::HCons<B, ::frunk_core::hlist::HCons<C, ::frunk_core::hlist::HCons<D, ::frunk_core::hlist::HCons<E, ::frunk_core::hlist::HCons<F, ::frunk_core::hlist::HCons<G, ::frunk_core::hlist::HNil>>>>>>> as WitType>::SIZE

type Layout = <HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HNil>>>>>>> as WitType>::Layout

type Dependencies = HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HNil>>>>>>>

fn wit_type_name() -> Cow<'static, str>

fn wit_type_declaration() -> Cow<'static, str>

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

where A: WitType, B: WitType, C: WitType, D: WitType, E: WitType, F: WitType, G: WitType, H: WitType, HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HCons<H, HNil>>>>>>>>: WitType,

const SIZE: u32 = <::frunk_core::hlist::HCons<A, ::frunk_core::hlist::HCons<B, ::frunk_core::hlist::HCons<C, ::frunk_core::hlist::HCons<D, ::frunk_core::hlist::HCons<E, ::frunk_core::hlist::HCons<F, ::frunk_core::hlist::HCons<G, ::frunk_core::hlist::HCons<H, ::frunk_core::hlist::HNil>>>>>>>> as WitType>::SIZE

type Layout = <HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HCons<H, HNil>>>>>>>> as WitType>::Layout

type Dependencies = HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HCons<H, HNil>>>>>>>>

fn wit_type_name() -> Cow<'static, str>

fn wit_type_declaration() -> Cow<'static, str>

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

where A: WitType, B: WitType, C: WitType, D: WitType, E: WitType, F: WitType, G: WitType, H: WitType, I: WitType, HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HCons<H, HCons<I, HNil>>>>>>>>>: WitType,

const SIZE: u32 = <::frunk_core::hlist::HCons<A, ::frunk_core::hlist::HCons<B, ::frunk_core::hlist::HCons<C, ::frunk_core::hlist::HCons<D, ::frunk_core::hlist::HCons<E, ::frunk_core::hlist::HCons<F, ::frunk_core::hlist::HCons<G, ::frunk_core::hlist::HCons<H, ::frunk_core::hlist::HCons<I, ::frunk_core::hlist::HNil>>>>>>>>> as WitType>::SIZE

type Layout = <HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HCons<H, HCons<I, HNil>>>>>>>>> as WitType>::Layout

type Dependencies = HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HCons<H, HCons<I, HNil>>>>>>>>>

fn wit_type_name() -> Cow<'static, str>

fn wit_type_declaration() -> Cow<'static, str>

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

where A: WitType, B: WitType, C: WitType, D: WitType, E: WitType, F: WitType, G: WitType, H: WitType, I: WitType, J: WitType, HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HCons<H, HCons<I, HCons<J, HNil>>>>>>>>>>: WitType,

const SIZE: u32 = <::frunk_core::hlist::HCons<A, ::frunk_core::hlist::HCons<B, ::frunk_core::hlist::HCons<C, ::frunk_core::hlist::HCons<D, ::frunk_core::hlist::HCons<E, ::frunk_core::hlist::HCons<F, ::frunk_core::hlist::HCons<G, ::frunk_core::hlist::HCons<H, ::frunk_core::hlist::HCons<I, ::frunk_core::hlist::HCons<J, ::frunk_core::hlist::HNil>>>>>>>>>> as WitType>::SIZE

type 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

type Dependencies = HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HCons<H, HCons<I, HCons<J, HNil>>>>>>>>>>

fn wit_type_name() -> Cow<'static, str>

fn wit_type_declaration() -> Cow<'static, str>

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

where A: WitType, B: WitType, C: WitType, D: WitType, E: WitType, F: WitType, G: WitType, H: WitType, I: WitType, J: WitType, K: WitType, HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HCons<H, HCons<I, HCons<J, HCons<K, HNil>>>>>>>>>>>: WitType,

const SIZE: u32 = <::frunk_core::hlist::HCons<A, ::frunk_core::hlist::HCons<B, ::frunk_core::hlist::HCons<C, ::frunk_core::hlist::HCons<D, ::frunk_core::hlist::HCons<E, ::frunk_core::hlist::HCons<F, ::frunk_core::hlist::HCons<G, ::frunk_core::hlist::HCons<H, ::frunk_core::hlist::HCons<I, ::frunk_core::hlist::HCons<J, ::frunk_core::hlist::HCons<K, ::frunk_core::hlist::HNil>>>>>>>>>>> as WitType>::SIZE

type 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

type Dependencies = HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HCons<H, HCons<I, HCons<J, HCons<K, HNil>>>>>>>>>>>

fn wit_type_name() -> Cow<'static, str>

fn wit_type_declaration() -> Cow<'static, str>

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

where A: WitType, B: WitType, C: WitType, D: WitType, E: WitType, F: WitType, G: WitType, H: WitType, I: WitType, J: WitType, K: WitType, L: WitType, 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>>>>>>>>>>>>: WitType,

const SIZE: u32 = <::frunk_core::hlist::HCons<A, ::frunk_core::hlist::HCons<B, ::frunk_core::hlist::HCons<C, ::frunk_core::hlist::HCons<D, ::frunk_core::hlist::HCons<E, ::frunk_core::hlist::HCons<F, ::frunk_core::hlist::HCons<G, ::frunk_core::hlist::HCons<H, ::frunk_core::hlist::HCons<I, ::frunk_core::hlist::HCons<J, ::frunk_core::hlist::HCons<K, ::frunk_core::hlist::HCons<L, ::frunk_core::hlist::HNil>>>>>>>>>>>> as WitType>::SIZE

type 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

type Dependencies = 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>>>>>>>>>>>>

fn wit_type_name() -> Cow<'static, str>

fn wit_type_declaration() -> Cow<'static, str>

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

where A: WitType, B: WitType, C: WitType, D: WitType, E: WitType, F: WitType, G: WitType, H: WitType, I: WitType, J: WitType, K: WitType, L: WitType, M: WitType, 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>>>>>>>>>>>>>: WitType,

const SIZE: u32 = <::frunk_core::hlist::HCons<A, ::frunk_core::hlist::HCons<B, ::frunk_core::hlist::HCons<C, ::frunk_core::hlist::HCons<D, ::frunk_core::hlist::HCons<E, ::frunk_core::hlist::HCons<F, ::frunk_core::hlist::HCons<G, ::frunk_core::hlist::HCons<H, ::frunk_core::hlist::HCons<I, ::frunk_core::hlist::HCons<J, ::frunk_core::hlist::HCons<K, ::frunk_core::hlist::HCons<L, ::frunk_core::hlist::HCons<M, ::frunk_core::hlist::HNil>>>>>>>>>>>>> as WitType>::SIZE

type 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

type Dependencies = 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>>>>>>>>>>>>>

fn wit_type_name() -> Cow<'static, str>

fn wit_type_declaration() -> Cow<'static, str>

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

where A: WitType, B: WitType, C: WitType, D: WitType, E: WitType, F: WitType, G: WitType, H: WitType, I: WitType, J: WitType, K: WitType, L: WitType, M: WitType, N: WitType, 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>>>>>>>>>>>>>>: WitType,

const SIZE: u32 = <::frunk_core::hlist::HCons<A, ::frunk_core::hlist::HCons<B, ::frunk_core::hlist::HCons<C, ::frunk_core::hlist::HCons<D, ::frunk_core::hlist::HCons<E, ::frunk_core::hlist::HCons<F, ::frunk_core::hlist::HCons<G, ::frunk_core::hlist::HCons<H, ::frunk_core::hlist::HCons<I, ::frunk_core::hlist::HCons<J, ::frunk_core::hlist::HCons<K, ::frunk_core::hlist::HCons<L, ::frunk_core::hlist::HCons<M, ::frunk_core::hlist::HCons<N, ::frunk_core::hlist::HNil>>>>>>>>>>>>>> as WitType>::SIZE

type 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

type Dependencies = 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>>>>>>>>>>>>>>

fn wit_type_name() -> Cow<'static, str>

fn wit_type_declaration() -> Cow<'static, str>

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

where A: WitType, B: WitType, C: WitType, D: WitType, E: WitType, F: WitType, G: WitType, H: WitType, I: WitType, J: WitType, K: WitType, L: WitType, M: WitType, N: WitType, O: WitType, 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>>>>>>>>>>>>>>>: WitType,

const SIZE: u32 = <::frunk_core::hlist::HCons<A, ::frunk_core::hlist::HCons<B, ::frunk_core::hlist::HCons<C, ::frunk_core::hlist::HCons<D, ::frunk_core::hlist::HCons<E, ::frunk_core::hlist::HCons<F, ::frunk_core::hlist::HCons<G, ::frunk_core::hlist::HCons<H, ::frunk_core::hlist::HCons<I, ::frunk_core::hlist::HCons<J, ::frunk_core::hlist::HCons<K, ::frunk_core::hlist::HCons<L, ::frunk_core::hlist::HCons<M, ::frunk_core::hlist::HCons<N, ::frunk_core::hlist::HCons<O, ::frunk_core::hlist::HNil>>>>>>>>>>>>>>> as WitType>::SIZE

type 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

type Dependencies = 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>>>>>>>>>>>>>>>

fn wit_type_name() -> Cow<'static, str>

fn wit_type_declaration() -> Cow<'static, str>

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

where A: WitType, B: WitType, C: WitType, D: WitType, E: WitType, F: WitType, G: WitType, H: WitType, I: WitType, J: WitType, K: WitType, L: WitType, M: WitType, N: WitType, O: WitType, P: WitType, 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>>>>>>>>>>>>>>>>: WitType,

const SIZE: u32 = <::frunk_core::hlist::HCons<A, ::frunk_core::hlist::HCons<B, ::frunk_core::hlist::HCons<C, ::frunk_core::hlist::HCons<D, ::frunk_core::hlist::HCons<E, ::frunk_core::hlist::HCons<F, ::frunk_core::hlist::HCons<G, ::frunk_core::hlist::HCons<H, ::frunk_core::hlist::HCons<I, ::frunk_core::hlist::HCons<J, ::frunk_core::hlist::HCons<K, ::frunk_core::hlist::HCons<L, ::frunk_core::hlist::HCons<M, ::frunk_core::hlist::HCons<N, ::frunk_core::hlist::HCons<O, ::frunk_core::hlist::HCons<P, ::frunk_core::hlist::HNil>>>>>>>>>>>>>>>> as WitType>::SIZE

type 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

type Dependencies = 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>>>>>>>>>>>>>>>>

fn wit_type_name() -> Cow<'static, str>

fn wit_type_declaration() -> Cow<'static, str>

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

where A: WitType, B: WitType, C: WitType, D: WitType, E: WitType, F: WitType, G: WitType, H: WitType, I: WitType, J: WitType, K: WitType, L: WitType, M: WitType, N: WitType, O: WitType, P: WitType, Q: WitType, 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>>>>>>>>>>>>>>>>>: WitType,

const SIZE: u32 = <::frunk_core::hlist::HCons<A, ::frunk_core::hlist::HCons<B, ::frunk_core::hlist::HCons<C, ::frunk_core::hlist::HCons<D, ::frunk_core::hlist::HCons<E, ::frunk_core::hlist::HCons<F, ::frunk_core::hlist::HCons<G, ::frunk_core::hlist::HCons<H, ::frunk_core::hlist::HCons<I, ::frunk_core::hlist::HCons<J, ::frunk_core::hlist::HCons<K, ::frunk_core::hlist::HCons<L, ::frunk_core::hlist::HCons<M, ::frunk_core::hlist::HCons<N, ::frunk_core::hlist::HCons<O, ::frunk_core::hlist::HCons<P, ::frunk_core::hlist::HCons<Q, ::frunk_core::hlist::HNil>>>>>>>>>>>>>>>>> as WitType>::SIZE

type 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

type Dependencies = 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>>>>>>>>>>>>>>>>>

fn wit_type_name() -> Cow<'static, str>

fn wit_type_declaration() -> Cow<'static, str>

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

where A: WitType, B: WitType, C: WitType, D: WitType, E: WitType, F: WitType, G: WitType, H: WitType, I: WitType, J: WitType, K: WitType, L: WitType, M: WitType, N: WitType, O: WitType, P: WitType, Q: WitType, R: WitType, 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>>>>>>>>>>>>>>>>>>: WitType,

const SIZE: u32 = <::frunk_core::hlist::HCons<A, ::frunk_core::hlist::HCons<B, ::frunk_core::hlist::HCons<C, ::frunk_core::hlist::HCons<D, ::frunk_core::hlist::HCons<E, ::frunk_core::hlist::HCons<F, ::frunk_core::hlist::HCons<G, ::frunk_core::hlist::HCons<H, ::frunk_core::hlist::HCons<I, ::frunk_core::hlist::HCons<J, ::frunk_core::hlist::HCons<K, ::frunk_core::hlist::HCons<L, ::frunk_core::hlist::HCons<M, ::frunk_core::hlist::HCons<N, ::frunk_core::hlist::HCons<O, ::frunk_core::hlist::HCons<P, ::frunk_core::hlist::HCons<Q, ::frunk_core::hlist::HCons<R, ::frunk_core::hlist::HNil>>>>>>>>>>>>>>>>>> as WitType>::SIZE

type 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

type Dependencies = 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>>>>>>>>>>>>>>>>>>

fn wit_type_name() -> Cow<'static, str>

fn wit_type_declaration() -> Cow<'static, str>

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

where A: WitType, B: WitType, C: WitType, D: WitType, E: WitType, F: WitType, G: WitType, H: WitType, I: WitType, J: WitType, K: WitType, L: WitType, M: WitType, N: WitType, O: WitType, P: WitType, Q: WitType, R: WitType, S: WitType, 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>>>>>>>>>>>>>>>>>>>: WitType,

const SIZE: u32 = <::frunk_core::hlist::HCons<A, ::frunk_core::hlist::HCons<B, ::frunk_core::hlist::HCons<C, ::frunk_core::hlist::HCons<D, ::frunk_core::hlist::HCons<E, ::frunk_core::hlist::HCons<F, ::frunk_core::hlist::HCons<G, ::frunk_core::hlist::HCons<H, ::frunk_core::hlist::HCons<I, ::frunk_core::hlist::HCons<J, ::frunk_core::hlist::HCons<K, ::frunk_core::hlist::HCons<L, ::frunk_core::hlist::HCons<M, ::frunk_core::hlist::HCons<N, ::frunk_core::hlist::HCons<O, ::frunk_core::hlist::HCons<P, ::frunk_core::hlist::HCons<Q, ::frunk_core::hlist::HCons<R, ::frunk_core::hlist::HCons<S, ::frunk_core::hlist::HNil>>>>>>>>>>>>>>>>>>> as WitType>::SIZE

type 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

type Dependencies = 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>>>>>>>>>>>>>>>>>>>

fn wit_type_name() -> Cow<'static, str>

fn wit_type_declaration() -> Cow<'static, str>

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

where A: WitType, B: WitType, C: WitType, D: WitType, E: WitType, F: WitType, G: WitType, H: WitType, I: WitType, J: WitType, K: WitType, L: WitType, M: WitType, N: WitType, O: WitType, P: WitType, Q: WitType, R: WitType, S: WitType, T: WitType, 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>>>>>>>>>>>>>>>>>>>>: WitType,

const SIZE: u32 = <::frunk_core::hlist::HCons<A, ::frunk_core::hlist::HCons<B, ::frunk_core::hlist::HCons<C, ::frunk_core::hlist::HCons<D, ::frunk_core::hlist::HCons<E, ::frunk_core::hlist::HCons<F, ::frunk_core::hlist::HCons<G, ::frunk_core::hlist::HCons<H, ::frunk_core::hlist::HCons<I, ::frunk_core::hlist::HCons<J, ::frunk_core::hlist::HCons<K, ::frunk_core::hlist::HCons<L, ::frunk_core::hlist::HCons<M, ::frunk_core::hlist::HCons<N, ::frunk_core::hlist::HCons<O, ::frunk_core::hlist::HCons<P, ::frunk_core::hlist::HCons<Q, ::frunk_core::hlist::HCons<R, ::frunk_core::hlist::HCons<S, ::frunk_core::hlist::HCons<T, ::frunk_core::hlist::HNil>>>>>>>>>>>>>>>>>>>> as WitType>::SIZE

type 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

type Dependencies = 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>>>>>>>>>>>>>>>>>>>>

fn wit_type_name() -> Cow<'static, str>

fn wit_type_declaration() -> Cow<'static, str>

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

where A: WitType, B: WitType, C: WitType, D: WitType, E: WitType, F: WitType, G: WitType, H: WitType, I: WitType, J: WitType, K: WitType, L: WitType, M: WitType, N: WitType, O: WitType, P: WitType, Q: WitType, R: WitType, S: WitType, T: WitType, U: WitType, 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>>>>>>>>>>>>>>>>>>>>>: WitType,

const SIZE: u32 = <::frunk_core::hlist::HCons<A, ::frunk_core::hlist::HCons<B, ::frunk_core::hlist::HCons<C, ::frunk_core::hlist::HCons<D, ::frunk_core::hlist::HCons<E, ::frunk_core::hlist::HCons<F, ::frunk_core::hlist::HCons<G, ::frunk_core::hlist::HCons<H, ::frunk_core::hlist::HCons<I, ::frunk_core::hlist::HCons<J, ::frunk_core::hlist::HCons<K, ::frunk_core::hlist::HCons<L, ::frunk_core::hlist::HCons<M, ::frunk_core::hlist::HCons<N, ::frunk_core::hlist::HCons<O, ::frunk_core::hlist::HCons<P, ::frunk_core::hlist::HCons<Q, ::frunk_core::hlist::HCons<R, ::frunk_core::hlist::HCons<S, ::frunk_core::hlist::HCons<T, ::frunk_core::hlist::HCons<U, ::frunk_core::hlist::HNil>>>>>>>>>>>>>>>>>>>>> as WitType>::SIZE

type 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

type Dependencies = 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>>>>>>>>>>>>>>>>>>>>>

fn wit_type_name() -> Cow<'static, str>

fn wit_type_declaration() -> Cow<'static, str>

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V> WitType 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: WitType, B: WitType, C: WitType, D: WitType, E: WitType, F: WitType, G: WitType, H: WitType, I: WitType, J: WitType, K: WitType, L: WitType, M: WitType, N: WitType, O: WitType, P: WitType, Q: WitType, R: WitType, S: WitType, T: WitType, U: WitType, V: WitType, 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>>>>>>>>>>>>>>>>>>>>>>: WitType,

const SIZE: u32 = <::frunk_core::hlist::HCons<A, ::frunk_core::hlist::HCons<B, ::frunk_core::hlist::HCons<C, ::frunk_core::hlist::HCons<D, ::frunk_core::hlist::HCons<E, ::frunk_core::hlist::HCons<F, ::frunk_core::hlist::HCons<G, ::frunk_core::hlist::HCons<H, ::frunk_core::hlist::HCons<I, ::frunk_core::hlist::HCons<J, ::frunk_core::hlist::HCons<K, ::frunk_core::hlist::HCons<L, ::frunk_core::hlist::HCons<M, ::frunk_core::hlist::HCons<N, ::frunk_core::hlist::HCons<O, ::frunk_core::hlist::HCons<P, ::frunk_core::hlist::HCons<Q, ::frunk_core::hlist::HCons<R, ::frunk_core::hlist::HCons<S, ::frunk_core::hlist::HCons<T, ::frunk_core::hlist::HCons<U, ::frunk_core::hlist::HCons<V, ::frunk_core::hlist::HNil>>>>>>>>>>>>>>>>>>>>>> as WitType>::SIZE

type 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

type Dependencies = 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>>>>>>>>>>>>>>>>>>>>>>

fn wit_type_name() -> Cow<'static, str>

fn wit_type_declaration() -> Cow<'static, str>

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W> WitType 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: WitType, B: WitType, C: WitType, D: WitType, E: WitType, F: WitType, G: WitType, H: WitType, I: WitType, J: WitType, K: WitType, L: WitType, M: WitType, N: WitType, O: WitType, P: WitType, Q: WitType, R: WitType, S: WitType, T: WitType, U: WitType, V: WitType, W: WitType, 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>>>>>>>>>>>>>>>>>>>>>>>: WitType,

const SIZE: u32 = <::frunk_core::hlist::HCons<A, ::frunk_core::hlist::HCons<B, ::frunk_core::hlist::HCons<C, ::frunk_core::hlist::HCons<D, ::frunk_core::hlist::HCons<E, ::frunk_core::hlist::HCons<F, ::frunk_core::hlist::HCons<G, ::frunk_core::hlist::HCons<H, ::frunk_core::hlist::HCons<I, ::frunk_core::hlist::HCons<J, ::frunk_core::hlist::HCons<K, ::frunk_core::hlist::HCons<L, ::frunk_core::hlist::HCons<M, ::frunk_core::hlist::HCons<N, ::frunk_core::hlist::HCons<O, ::frunk_core::hlist::HCons<P, ::frunk_core::hlist::HCons<Q, ::frunk_core::hlist::HCons<R, ::frunk_core::hlist::HCons<S, ::frunk_core::hlist::HCons<T, ::frunk_core::hlist::HCons<U, ::frunk_core::hlist::HCons<V, ::frunk_core::hlist::HCons<W, ::frunk_core::hlist::HNil>>>>>>>>>>>>>>>>>>>>>>> as WitType>::SIZE

type 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

type Dependencies = 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>>>>>>>>>>>>>>>>>>>>>>>

fn wit_type_name() -> Cow<'static, str>

fn wit_type_declaration() -> Cow<'static, str>

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> WitType 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: WitType, B: WitType, C: WitType, D: WitType, E: WitType, F: WitType, G: WitType, H: WitType, I: WitType, J: WitType, K: WitType, L: WitType, M: WitType, N: WitType, O: WitType, P: WitType, Q: WitType, R: WitType, S: WitType, T: WitType, U: WitType, V: WitType, W: WitType, X: WitType, 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>>>>>>>>>>>>>>>>>>>>>>>>: WitType,

const SIZE: u32 = <::frunk_core::hlist::HCons<A, ::frunk_core::hlist::HCons<B, ::frunk_core::hlist::HCons<C, ::frunk_core::hlist::HCons<D, ::frunk_core::hlist::HCons<E, ::frunk_core::hlist::HCons<F, ::frunk_core::hlist::HCons<G, ::frunk_core::hlist::HCons<H, ::frunk_core::hlist::HCons<I, ::frunk_core::hlist::HCons<J, ::frunk_core::hlist::HCons<K, ::frunk_core::hlist::HCons<L, ::frunk_core::hlist::HCons<M, ::frunk_core::hlist::HCons<N, ::frunk_core::hlist::HCons<O, ::frunk_core::hlist::HCons<P, ::frunk_core::hlist::HCons<Q, ::frunk_core::hlist::HCons<R, ::frunk_core::hlist::HCons<S, ::frunk_core::hlist::HCons<T, ::frunk_core::hlist::HCons<U, ::frunk_core::hlist::HCons<V, ::frunk_core::hlist::HCons<W, ::frunk_core::hlist::HCons<X, ::frunk_core::hlist::HNil>>>>>>>>>>>>>>>>>>>>>>>> as WitType>::SIZE

type 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

type Dependencies = 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>>>>>>>>>>>>>>>>>>>>>>>>

fn wit_type_name() -> Cow<'static, str>

fn wit_type_declaration() -> Cow<'static, str>

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> WitType 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: WitType, B: WitType, C: WitType, D: WitType, E: WitType, F: WitType, G: WitType, H: WitType, I: WitType, J: WitType, K: WitType, L: WitType, M: WitType, N: WitType, O: WitType, P: WitType, Q: WitType, R: WitType, S: WitType, T: WitType, U: WitType, V: WitType, W: WitType, X: WitType, Y: WitType, 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>>>>>>>>>>>>>>>>>>>>>>>>>: WitType,

const SIZE: u32 = <::frunk_core::hlist::HCons<A, ::frunk_core::hlist::HCons<B, ::frunk_core::hlist::HCons<C, ::frunk_core::hlist::HCons<D, ::frunk_core::hlist::HCons<E, ::frunk_core::hlist::HCons<F, ::frunk_core::hlist::HCons<G, ::frunk_core::hlist::HCons<H, ::frunk_core::hlist::HCons<I, ::frunk_core::hlist::HCons<J, ::frunk_core::hlist::HCons<K, ::frunk_core::hlist::HCons<L, ::frunk_core::hlist::HCons<M, ::frunk_core::hlist::HCons<N, ::frunk_core::hlist::HCons<O, ::frunk_core::hlist::HCons<P, ::frunk_core::hlist::HCons<Q, ::frunk_core::hlist::HCons<R, ::frunk_core::hlist::HCons<S, ::frunk_core::hlist::HCons<T, ::frunk_core::hlist::HCons<U, ::frunk_core::hlist::HCons<V, ::frunk_core::hlist::HCons<W, ::frunk_core::hlist::HCons<X, ::frunk_core::hlist::HCons<Y, ::frunk_core::hlist::HNil>>>>>>>>>>>>>>>>>>>>>>>>> as WitType>::SIZE

type 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

type Dependencies = 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>>>>>>>>>>>>>>>>>>>>>>>>>

fn wit_type_name() -> Cow<'static, str>

fn wit_type_declaration() -> Cow<'static, str>

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> WitType 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: WitType, B: WitType, C: WitType, D: WitType, E: WitType, F: WitType, G: WitType, H: WitType, I: WitType, J: WitType, K: WitType, L: WitType, M: WitType, N: WitType, O: WitType, P: WitType, Q: WitType, R: WitType, S: WitType, T: WitType, U: WitType, V: WitType, W: WitType, X: WitType, Y: WitType, Z: WitType, 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>>>>>>>>>>>>>>>>>>>>>>>>>>: WitType,

const SIZE: u32 = <::frunk_core::hlist::HCons<A, ::frunk_core::hlist::HCons<B, ::frunk_core::hlist::HCons<C, ::frunk_core::hlist::HCons<D, ::frunk_core::hlist::HCons<E, ::frunk_core::hlist::HCons<F, ::frunk_core::hlist::HCons<G, ::frunk_core::hlist::HCons<H, ::frunk_core::hlist::HCons<I, ::frunk_core::hlist::HCons<J, ::frunk_core::hlist::HCons<K, ::frunk_core::hlist::HCons<L, ::frunk_core::hlist::HCons<M, ::frunk_core::hlist::HCons<N, ::frunk_core::hlist::HCons<O, ::frunk_core::hlist::HCons<P, ::frunk_core::hlist::HCons<Q, ::frunk_core::hlist::HCons<R, ::frunk_core::hlist::HCons<S, ::frunk_core::hlist::HCons<T, ::frunk_core::hlist::HCons<U, ::frunk_core::hlist::HCons<V, ::frunk_core::hlist::HCons<W, ::frunk_core::hlist::HCons<X, ::frunk_core::hlist::HCons<Y, ::frunk_core::hlist::HCons<Z, ::frunk_core::hlist::HNil>>>>>>>>>>>>>>>>>>>>>>>>>> as WitType>::SIZE

type 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

type Dependencies = 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>>>>>>>>>>>>>>>>>>>>>>>>>>

fn wit_type_name() -> Cow<'static, str>

fn wit_type_declaration() -> Cow<'static, str>

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

where K: WitType, V: WitType, (K, V): WitType,

const SIZE: u32 = 8u32

type Layout = <Vec<(K, V)> as WitType>::Layout

type Dependencies = HCons<K, HCons<V, HNil>>

fn wit_type_name() -> Cow<'static, str>

fn wit_type_declaration() -> Cow<'static, str>

impl<T> WitType for Option<T>

where T: WitType, HNil: Merge<T::Layout>, <HNil as Merge<T::Layout>>::Output: Layout,

const SIZE: u32 = _

type Layout = HCons<i8, <HNil as Merge<<T as WitType>::Layout>>::Output>

type Dependencies = HCons<T, HNil>

fn wit_type_name() -> Cow<'static, str>

fn wit_type_declaration() -> Cow<'static, str>

impl<T> WitType for [T]

where T: WitType,

const SIZE: u32 = 8u32

type Layout = HCons<i32, HCons<i32, HNil>>

type Dependencies = HCons<T, HNil>

fn wit_type_name() -> Cow<'static, str>

fn wit_type_declaration() -> Cow<'static, str>

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

where T: WitType,

const SIZE: u32 = 8u32

type Layout = <[T] as WitType>::Layout

type Dependencies = <[T] as WitType>::Dependencies

fn wit_type_name() -> Cow<'static, str>

fn wit_type_declaration() -> Cow<'static, str>

impl<T> WitType for Box<T>

where T: WitType,

const SIZE: u32 = T::SIZE

type Layout = <T as WitType>::Layout

type Dependencies = <T as WitType>::Dependencies

fn wit_type_name() -> Cow<'static, str>

fn wit_type_declaration() -> Cow<'static, str>

impl<T> WitType for BTreeSet<T>

where T: WitType,

const SIZE: u32 = 8u32

type Layout = <Vec<T> as WitType>::Layout

type Dependencies = HCons<T, HNil>

fn wit_type_name() -> Cow<'static, str>

fn wit_type_declaration() -> Cow<'static, str>

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

where T: WitType,

const SIZE: u32 = 8u32

type Layout = <[T] as WitType>::Layout

type Dependencies = <[T] as WitType>::Dependencies

fn wit_type_name() -> Cow<'static, str>

fn wit_type_declaration() -> Cow<'static, str>

impl<T> WitType for Rc<T>

where T: WitType,

const SIZE: u32 = T::SIZE

type Layout = <T as WitType>::Layout

type Dependencies = <T as WitType>::Dependencies

fn wit_type_name() -> Cow<'static, str>

fn wit_type_declaration() -> Cow<'static, str>

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

where T: WitType,

const SIZE: u32 = 8u32

type Layout = <[T] as WitType>::Layout

type Dependencies = <[T] as WitType>::Dependencies

fn wit_type_name() -> Cow<'static, str>

fn wit_type_declaration() -> Cow<'static, str>

impl<T> WitType for Arc<T>

where T: WitType,

const SIZE: u32 = T::SIZE

type Layout = <T as WitType>::Layout

type Dependencies = <T as WitType>::Dependencies

fn wit_type_name() -> Cow<'static, str>

fn wit_type_declaration() -> Cow<'static, str>

impl<T> WitType for Vec<T>

where T: WitType,

const SIZE: u32 = 8u32

type Layout = <[T] as WitType>::Layout

type Dependencies = <[T] as WitType>::Dependencies

fn wit_type_name() -> Cow<'static, str>

fn wit_type_declaration() -> Cow<'static, str>

impl<T> WitType for PhantomData<T>

const SIZE: u32 = 0u32

type Layout = HNil

type Dependencies = HNil

fn wit_type_name() -> Cow<'static, str>

fn wit_type_declaration() -> Cow<'static, str>

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

where T: WitType, E: WitType, T::Layout: Merge<E::Layout>, <T::Layout as Merge<E::Layout>>::Output: Layout,

const SIZE: u32 = _

type Layout = HCons<i8, <<T as WitType>::Layout as Merge<<E as WitType>::Layout>>::Output>

type Dependencies = HCons<T, HCons<E, HNil>>

fn wit_type_name() -> Cow<'static, str>

fn wit_type_declaration() -> Cow<'static, str>

Implementors

impl WitType for GuestPointer

const SIZE: u32 = 4u32

type Layout = HCons<i32, HNil>

type Dependencies = HNil

impl WitType for HNil

const SIZE: u32 = 0u32

type Layout = HNil

type Dependencies = HNil

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

where Head: WitType, Tail: WitType + SizeCalculation, Head::Layout: Add<Tail::Layout>, <Head::Layout as Add<Tail::Layout>>::Output: Layout,

const SIZE: u32 = _

type Layout = <<Head as WitType>::Layout as Add<<Tail as WitType>::Layout>>::Output

type Dependencies = HCons<Head, HCons<Tail, HNil>>