Trait elrond_codec::TopDecode

pub trait TopDecode: Sized {
    fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>;

    fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
        input: I, 
        c: ExitCtx, 
        exit: fn(_: ExitCtx, _: DecodeError) -> !
    ) -> Self { ... }
}

Trait that allows zero-copy read of values from an underlying API in big endian format.

'Top' stands for the fact that values are deserialized on their own, so we have the benefit of knowing their length. This is useful in many scnearios, such as not having to encode Vec length and others.

The opther optimization that can be done when deserializing top-level objects is using special functions from the underlying API that do some of the work for the deserializer. These include getting values directly as i64/u64 or wrapping them directly into an owned Box<u8>.

BigInt/BigUint handling is not included here, because these are API-dependent and would overly complicate the trait.

Required methods

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

Attempt to deserialize the value from input.

Loading content...

Provided methods

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

Version of top_decode that exits quickly in case of error. Its purpose is to create smaller implementations in cases where the application is supposed to exit directly on decode error.

Loading content...

Implementations on Foreign Types

impl<T: TopDecode> TopDecode for Box<T>

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

impl<T: NestedDecode> TopDecode for Box<[T]>

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

Quick exit for any of the contained types

impl TopDecode for String

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

impl TopDecode for Box<str>

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

impl<T: NestedDecode> TopDecode for Option<T>

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

impl TopDecode for NonZeroUsize

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

Loading content...

Implementors

impl TopDecode for ()

const TYPE_INFO: TypeInfo

fn top_decode<I: TopDecodeInput>(_: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    _: I,
    _: ExitCtx,
    _: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

impl TopDecode for bool

const TYPE_INFO: TypeInfo

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

impl TopDecode for i8

const TYPE_INFO: TypeInfo

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

impl TopDecode for i16

const TYPE_INFO: TypeInfo

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

impl TopDecode for i32

const TYPE_INFO: TypeInfo

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

impl TopDecode for i64

const TYPE_INFO: TypeInfo

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

impl TopDecode for isize

const TYPE_INFO: TypeInfo

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

impl TopDecode for u8

const TYPE_INFO: TypeInfo

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

impl TopDecode for u16

const TYPE_INFO: TypeInfo

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

impl TopDecode for u32

const TYPE_INFO: TypeInfo

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

impl TopDecode for u64

const TYPE_INFO: TypeInfo

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

impl TopDecode for usize

const TYPE_INFO: TypeInfo

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

impl<T0> TopDecode for (T0,) where
    T0: NestedDecode, 

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

impl<T0, T1> TopDecode for (T0, T1) where
    T0: NestedDecode,
    T1: NestedDecode, 

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

impl<T0, T1, T2> TopDecode for (T0, T1, T2) where
    T0: NestedDecode,
    T1: NestedDecode,
    T2: NestedDecode, 

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

impl<T0, T1, T2, T3> TopDecode for (T0, T1, T2, T3) where
    T0: NestedDecode,
    T1: NestedDecode,
    T2: NestedDecode,
    T3: NestedDecode, 

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

impl<T0, T1, T2, T3, T4> TopDecode for (T0, T1, T2, T3, T4) where
    T0: NestedDecode,
    T1: NestedDecode,
    T2: NestedDecode,
    T3: NestedDecode,
    T4: NestedDecode, 

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

impl<T0, T1, T2, T3, T4, T5> TopDecode for (T0, T1, T2, T3, T4, T5) where
    T0: NestedDecode,
    T1: NestedDecode,
    T2: NestedDecode,
    T3: NestedDecode,
    T4: NestedDecode,
    T5: NestedDecode, 

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

impl<T0, T1, T2, T3, T4, T5, T6> TopDecode for (T0, T1, T2, T3, T4, T5, T6) where
    T0: NestedDecode,
    T1: NestedDecode,
    T2: NestedDecode,
    T3: NestedDecode,
    T4: NestedDecode,
    T5: NestedDecode,
    T6: NestedDecode, 

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

impl<T0, T1, T2, T3, T4, T5, T6, T7> TopDecode for (T0, T1, T2, T3, T4, T5, T6, T7) where
    T0: NestedDecode,
    T1: NestedDecode,
    T2: NestedDecode,
    T3: NestedDecode,
    T4: NestedDecode,
    T5: NestedDecode,
    T6: NestedDecode,
    T7: NestedDecode, 

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> TopDecode for (T0, T1, T2, T3, T4, T5, T6, T7, T8) where
    T0: NestedDecode,
    T1: NestedDecode,
    T2: NestedDecode,
    T3: NestedDecode,
    T4: NestedDecode,
    T5: NestedDecode,
    T6: NestedDecode,
    T7: NestedDecode,
    T8: NestedDecode, 

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> TopDecode for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) where
    T0: NestedDecode,
    T1: NestedDecode,
    T2: NestedDecode,
    T3: NestedDecode,
    T4: NestedDecode,
    T5: NestedDecode,
    T6: NestedDecode,
    T7: NestedDecode,
    T8: NestedDecode,
    T9: NestedDecode, 

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> TopDecode for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) where
    T0: NestedDecode,
    T1: NestedDecode,
    T2: NestedDecode,
    T3: NestedDecode,
    T4: NestedDecode,
    T5: NestedDecode,
    T6: NestedDecode,
    T7: NestedDecode,
    T8: NestedDecode,
    T9: NestedDecode,
    T10: NestedDecode, 

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> TopDecode for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) where
    T0: NestedDecode,
    T1: NestedDecode,
    T2: NestedDecode,
    T3: NestedDecode,
    T4: NestedDecode,
    T5: NestedDecode,
    T6: NestedDecode,
    T7: NestedDecode,
    T8: NestedDecode,
    T9: NestedDecode,
    T10: NestedDecode,
    T11: NestedDecode, 

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> TopDecode for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) where
    T0: NestedDecode,
    T1: NestedDecode,
    T2: NestedDecode,
    T3: NestedDecode,
    T4: NestedDecode,
    T5: NestedDecode,
    T6: NestedDecode,
    T7: NestedDecode,
    T8: NestedDecode,
    T9: NestedDecode,
    T10: NestedDecode,
    T11: NestedDecode,
    T12: NestedDecode, 

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> TopDecode for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) where
    T0: NestedDecode,
    T1: NestedDecode,
    T2: NestedDecode,
    T3: NestedDecode,
    T4: NestedDecode,
    T5: NestedDecode,
    T6: NestedDecode,
    T7: NestedDecode,
    T8: NestedDecode,
    T9: NestedDecode,
    T10: NestedDecode,
    T11: NestedDecode,
    T12: NestedDecode,
    T13: NestedDecode, 

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> TopDecode for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) where
    T0: NestedDecode,
    T1: NestedDecode,
    T2: NestedDecode,
    T3: NestedDecode,
    T4: NestedDecode,
    T5: NestedDecode,
    T6: NestedDecode,
    T7: NestedDecode,
    T8: NestedDecode,
    T9: NestedDecode,
    T10: NestedDecode,
    T11: NestedDecode,
    T12: NestedDecode,
    T13: NestedDecode,
    T14: NestedDecode, 

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> TopDecode for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) where
    T0: NestedDecode,
    T1: NestedDecode,
    T2: NestedDecode,
    T3: NestedDecode,
    T4: NestedDecode,
    T5: NestedDecode,
    T6: NestedDecode,
    T7: NestedDecode,
    T8: NestedDecode,
    T9: NestedDecode,
    T10: NestedDecode,
    T11: NestedDecode,
    T12: NestedDecode,
    T13: NestedDecode,
    T14: NestedDecode,
    T15: NestedDecode, 

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

impl<T: NestedDecode> TopDecode for Vec<T>

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

impl<T: NestedDecode> TopDecode for [T; 1]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 2]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 3]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 4]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 5]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 6]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 7]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 8]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 9]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 10]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 11]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 12]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 13]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 14]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 15]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 16]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 17]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 18]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 19]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 20]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 21]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 22]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 23]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 24]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 25]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 26]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 27]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 28]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 29]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 30]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 31]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 32]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 33]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 34]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 35]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 36]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 37]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 38]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 39]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 40]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 41]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 42]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 43]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 44]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 45]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 46]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 47]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 48]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 49]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 50]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 51]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 52]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 53]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 54]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 55]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 56]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 57]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 58]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 59]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 60]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 61]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 62]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 63]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 64]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 65]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 66]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 67]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 68]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 69]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 70]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 71]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 72]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 73]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 74]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 75]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 76]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 77]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 78]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 79]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 80]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 81]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 82]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 83]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 84]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 85]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 86]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 87]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 88]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 89]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 90]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 91]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 92]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 93]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 94]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 95]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 96]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 97]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 98]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 99]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 100]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 101]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 102]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 103]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 104]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 105]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 106]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 107]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 108]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 109]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 110]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 111]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 112]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 113]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 114]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 115]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 116]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 117]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 118]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 119]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 120]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 121]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 122]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 123]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 124]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 125]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 126]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 127]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 128]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 129]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 130]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 131]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 132]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 133]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 134]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 135]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 136]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 137]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 138]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 139]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 140]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 141]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 142]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 143]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 144]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 145]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 146]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 147]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 148]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 149]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 150]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 151]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 152]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 153]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 154]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 155]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 156]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 157]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 158]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 159]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 160]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 161]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 162]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 163]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 164]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 165]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 166]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 167]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 168]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 169]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 170]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 171]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 172]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 173]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 174]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 175]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 176]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 177]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 178]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 179]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 180]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 181]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 182]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 183]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 184]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 185]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 186]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 187]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 188]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 189]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 190]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 191]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 192]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 193]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 194]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 195]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 196]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 197]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 198]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 199]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 200]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 201]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 202]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 203]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 204]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 205]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 206]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 207]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 208]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 209]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 210]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 211]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 212]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 213]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 214]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 215]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 216]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 217]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 218]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 219]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 220]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 221]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 222]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 223]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 224]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 225]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 226]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 227]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 228]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 229]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 230]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 231]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 232]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 233]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 234]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 235]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 236]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 237]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 238]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 239]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 240]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 241]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 242]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 243]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 244]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 245]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 246]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 247]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 248]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 249]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 250]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 251]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 252]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 253]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 254]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 255]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 256]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 384]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 512]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 768]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 1024]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 2048]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 4096]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 8192]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 16384]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

impl<T: NestedDecode> TopDecode for [T; 32768]

fn top_decode<I: TopDecodeInput>(input: I) -> Result<Self, DecodeError>

fn top_decode_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Self

fn top_decode_boxed<I: TopDecodeInput>(
    input: I
) -> Result<Box<Self>, DecodeError>

fn top_decode_boxed_or_exit<I: TopDecodeInput, ExitCtx: Clone>(
    input: I,
    c: ExitCtx,
    exit: fn(_: ExitCtx, _: DecodeError) -> !
) -> Box<Self>

Loading content...