Trait vessels::Kind

pub trait Kind: Any + Sized + Sync + Send + Unpin + 'static {
    type ConstructItem: Serialize + DeserializeOwned + Send + Sync + Unpin + 'static;
    type ConstructError: ErrorBound;
    type ConstructFuture: Future<Output = ConstructResult<Self>> + Sync + Send + 'static;
    type DeconstructItem: Serialize + DeserializeOwned + Send + Sync + Unpin + 'static;
    type DeconstructError: ErrorBound;
    type DeconstructFuture: Future<Output = DeconstructResult<Self>> + Sync + Send + 'static;
    fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
        channel: C
    ) -> Self::ConstructFuture;
    fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
        self, 
        channel: C
    ) -> Self::DeconstructFuture;
}

A type with a bijection to over-the-wire data.

Kind is an advanced distributed object or RPC system that permits the over-the-wire serialization and deserialization of an implicitly flattened version of the complex nested structures required to produce a full type-level isomorphic representation of arbitrary composed data types.

Vessels provides Kind implementations for many primitive types from the standard library as well as futures, streams, a variety of boxed function types, and more.

Vessels also provides a derive macro that automatically generates Kind implementations for structs and enums in addition to the object macro for generating Kind implementations for trait objects of user-defined traits.

Authors of third-party crates are encouraged to derive or implement Kind or Kind providers for types their crates expose that might be useful over some form of wire boundary, be it network, IPC, or any other similar transport.

Associated Types

type ConstructItem: Serialize + DeserializeOwned + Send + Sync + Unpin + 'static

The item transmitted over the network to the construction task from deconstruction.

type ConstructError: ErrorBound

The failure condition of constructing a concrete type from communicated data.

type ConstructFuture: Future<Output = ConstructResult<Self>> + Sync + Send + 'static

The concrete future type returned by the construction process.

type DeconstructItem: Serialize + DeserializeOwned + Send + Sync + Unpin + 'static

The item transmitted over the network from the construction task to deconstruction.

type DeconstructError: ErrorBound

The failure condition of constructing a concrete type from communicated data.

type DeconstructFuture: Future<Output = DeconstructResult<Self>> + Sync + Send + 'static

The concrete future type returned by the deconstruction process. This is used to only to communicate failure of deconstruction and does not return a value.

Loading content...

Required methods

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

Constructs the Kind from the provided channel. This method should return immediately and, if necessary, move channel into some shim structure, async block, or other owned state specified by ConstructFuture.

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

Moves out of the Kind and deconstructs on to the provided channel. As with construct, this method should return immediately.

Loading content...

Implementations on Foreign Types

impl Kind for Box<dyn Rng>

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl Kind for Box<dyn Hasher>

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl Kind for Box<dyn Peer>

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl Kind for Box<dyn RawClient>

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl Kind for Box<dyn RawServer>

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl Kind for Box<dyn OrchestratorInner>

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl Kind for Box<dyn HandleInner>

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<T: Unpin + Sync + Send + 'static> Kind for [T; 0]

type ConstructItem = ()

type ConstructError = Void

type ConstructFuture = Ready<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = Void

type DeconstructFuture = Ready<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    _: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    _: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<T> Kind for [T; 1] where
    T: Kind, 

type ConstructItem = Vec<ForkHandle>

type ConstructError = WrappedError<ArrayError<T::ConstructError>>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<T::DeconstructError>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<T> Kind for [T; 2] where
    T: Kind, 

type ConstructItem = Vec<ForkHandle>

type ConstructError = WrappedError<ArrayError<T::ConstructError>>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<T::DeconstructError>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<T> Kind for [T; 3] where
    T: Kind, 

type ConstructItem = Vec<ForkHandle>

type ConstructError = WrappedError<ArrayError<T::ConstructError>>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<T::DeconstructError>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<T> Kind for [T; 4] where
    T: Kind, 

type ConstructItem = Vec<ForkHandle>

type ConstructError = WrappedError<ArrayError<T::ConstructError>>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<T::DeconstructError>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<T> Kind for [T; 5] where
    T: Kind, 

type ConstructItem = Vec<ForkHandle>

type ConstructError = WrappedError<ArrayError<T::ConstructError>>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<T::DeconstructError>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<T> Kind for [T; 6] where
    T: Kind, 

type ConstructItem = Vec<ForkHandle>

type ConstructError = WrappedError<ArrayError<T::ConstructError>>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<T::DeconstructError>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<T> Kind for [T; 7] where
    T: Kind, 

type ConstructItem = Vec<ForkHandle>

type ConstructError = WrappedError<ArrayError<T::ConstructError>>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<T::DeconstructError>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<T> Kind for [T; 8] where
    T: Kind, 

type ConstructItem = Vec<ForkHandle>

type ConstructError = WrappedError<ArrayError<T::ConstructError>>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<T::DeconstructError>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<T> Kind for [T; 9] where
    T: Kind, 

type ConstructItem = Vec<ForkHandle>

type ConstructError = WrappedError<ArrayError<T::ConstructError>>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<T::DeconstructError>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<T> Kind for [T; 10] where
    T: Kind, 

type ConstructItem = Vec<ForkHandle>

type ConstructError = WrappedError<ArrayError<T::ConstructError>>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<T::DeconstructError>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<T> Kind for [T; 11] where
    T: Kind, 

type ConstructItem = Vec<ForkHandle>

type ConstructError = WrappedError<ArrayError<T::ConstructError>>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<T::DeconstructError>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<T> Kind for [T; 12] where
    T: Kind, 

type ConstructItem = Vec<ForkHandle>

type ConstructError = WrappedError<ArrayError<T::ConstructError>>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<T::DeconstructError>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<T> Kind for [T; 13] where
    T: Kind, 

type ConstructItem = Vec<ForkHandle>

type ConstructError = WrappedError<ArrayError<T::ConstructError>>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<T::DeconstructError>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<T> Kind for [T; 14] where
    T: Kind, 

type ConstructItem = Vec<ForkHandle>

type ConstructError = WrappedError<ArrayError<T::ConstructError>>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<T::DeconstructError>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<T> Kind for [T; 15] where
    T: Kind, 

type ConstructItem = Vec<ForkHandle>

type ConstructError = WrappedError<ArrayError<T::ConstructError>>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<T::DeconstructError>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<T> Kind for [T; 16] where
    T: Kind, 

type ConstructItem = Vec<ForkHandle>

type ConstructError = WrappedError<ArrayError<T::ConstructError>>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<T::DeconstructError>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<T> Kind for [T; 17] where
    T: Kind, 

type ConstructItem = Vec<ForkHandle>

type ConstructError = WrappedError<ArrayError<T::ConstructError>>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<T::DeconstructError>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<T> Kind for [T; 18] where
    T: Kind, 

type ConstructItem = Vec<ForkHandle>

type ConstructError = WrappedError<ArrayError<T::ConstructError>>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<T::DeconstructError>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<T> Kind for [T; 19] where
    T: Kind, 

type ConstructItem = Vec<ForkHandle>

type ConstructError = WrappedError<ArrayError<T::ConstructError>>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<T::DeconstructError>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<T> Kind for [T; 20] where
    T: Kind, 

type ConstructItem = Vec<ForkHandle>

type ConstructError = WrappedError<ArrayError<T::ConstructError>>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<T::DeconstructError>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<T> Kind for [T; 21] where
    T: Kind, 

type ConstructItem = Vec<ForkHandle>

type ConstructError = WrappedError<ArrayError<T::ConstructError>>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<T::DeconstructError>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<T> Kind for [T; 22] where
    T: Kind, 

type ConstructItem = Vec<ForkHandle>

type ConstructError = WrappedError<ArrayError<T::ConstructError>>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<T::DeconstructError>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<T> Kind for [T; 23] where
    T: Kind, 

type ConstructItem = Vec<ForkHandle>

type ConstructError = WrappedError<ArrayError<T::ConstructError>>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<T::DeconstructError>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<T> Kind for [T; 24] where
    T: Kind, 

type ConstructItem = Vec<ForkHandle>

type ConstructError = WrappedError<ArrayError<T::ConstructError>>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<T::DeconstructError>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<T> Kind for [T; 25] where
    T: Kind, 

type ConstructItem = Vec<ForkHandle>

type ConstructError = WrappedError<ArrayError<T::ConstructError>>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<T::DeconstructError>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<T> Kind for [T; 26] where
    T: Kind, 

type ConstructItem = Vec<ForkHandle>

type ConstructError = WrappedError<ArrayError<T::ConstructError>>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<T::DeconstructError>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<T> Kind for [T; 27] where
    T: Kind, 

type ConstructItem = Vec<ForkHandle>

type ConstructError = WrappedError<ArrayError<T::ConstructError>>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<T::DeconstructError>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<T> Kind for [T; 28] where
    T: Kind, 

type ConstructItem = Vec<ForkHandle>

type ConstructError = WrappedError<ArrayError<T::ConstructError>>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<T::DeconstructError>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<T> Kind for [T; 29] where
    T: Kind, 

type ConstructItem = Vec<ForkHandle>

type ConstructError = WrappedError<ArrayError<T::ConstructError>>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<T::DeconstructError>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<T> Kind for [T; 30] where
    T: Kind, 

type ConstructItem = Vec<ForkHandle>

type ConstructError = WrappedError<ArrayError<T::ConstructError>>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<T::DeconstructError>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<T> Kind for [T; 31] where
    T: Kind, 

type ConstructItem = Vec<ForkHandle>

type ConstructError = WrappedError<ArrayError<T::ConstructError>>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<T::DeconstructError>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<T> Kind for [T; 32] where
    T: Kind, 

type ConstructItem = Vec<ForkHandle>

type ConstructError = WrappedError<ArrayError<T::ConstructError>>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<T::DeconstructError>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<T> Kind for BinaryHeap<T> where
    T: Kind + Ord, 

type ConstructItem = Vec<ForkHandle>

type ConstructError = WrappedError<T::ConstructError>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<T::DeconstructError>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<T> Kind for BTreeSet<T> where
    T: Kind + Ord, 

type ConstructItem = Vec<ForkHandle>

type ConstructError = WrappedError<T::ConstructError>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<T::DeconstructError>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<T> Kind for HashSet<T> where
    T: Kind + Hash + Eq, 

type ConstructItem = Vec<ForkHandle>

type ConstructError = WrappedError<T::ConstructError>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<T::DeconstructError>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<T> Kind for LinkedList<T> where
    T: Kind, 

type ConstructItem = Vec<ForkHandle>

type ConstructError = WrappedError<T::ConstructError>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<T::DeconstructError>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<T> Kind for Vec<T> where
    T: Kind, 

type ConstructItem = Vec<ForkHandle>

type ConstructError = WrappedError<T::ConstructError>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<T::DeconstructError>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<T> Kind for VecDeque<T> where
    T: Kind, 

type ConstructItem = Vec<ForkHandle>

type ConstructError = WrappedError<T::ConstructError>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<T::DeconstructError>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<K, V> Kind for BTreeMap<K, V> where
    K: Kind + Ord,
    V: Kind, 

type ConstructItem = Vec<ForkHandle>

type ConstructError = WrappedError<<(K, V) as Kind>::ConstructError>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<<(K, V) as Kind>::DeconstructError>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<K, V> Kind for HashMap<K, V> where
    K: Kind + Eq + Hash,
    V: Kind, 

type ConstructItem = Vec<ForkHandle>

type ConstructError = WrappedError<<(K, V) as Kind>::ConstructError>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<<(K, V) as Kind>::DeconstructError>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl Kind for Error

type ConstructItem = ForkHandle

type ConstructError = WrappedError<Void>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<Void>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<U: Kind + Flatten> Kind for Box<dyn Fn() -> U + Send + Sync>

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<<U as Kind>::DeconstructError>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<U: Kind + Flatten> Kind for Box<dyn FnMut() -> U + Send + Sync>

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<<U as Kind>::DeconstructError>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<U: Kind + Flatten> Kind for Box<dyn FnOnce() -> U + Send + Sync>

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<<U as Kind>::DeconstructError>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<U: Kind + Flatten> Kind for Arc<Box<dyn Fn() -> U + Send + Sync>>

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<<U as Kind>::DeconstructError>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<U: Kind + Flatten, T0> Kind for Box<dyn Fn(T0) -> U + Send + Sync> where
    T0: Kind, 

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = Vec<ForkHandle>

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<U: Kind + Flatten, T0> Kind for Box<dyn FnMut(T0) -> U + Send + Sync> where
    T0: Kind, 

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = Vec<ForkHandle>

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<U: Kind + Flatten, T0> Kind for Box<dyn FnOnce(T0) -> U + Send + Sync> where
    T0: Kind, 

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = Vec<ForkHandle>

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<U: Kind + Flatten, T0> Kind for Arc<Box<dyn Fn(T0) -> U + Send + Sync>> where
    T0: Kind, 

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = Vec<ForkHandle>

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<U: Kind + Flatten, T0, T1> Kind for Box<dyn Fn(T0, T1) -> U + Send + Sync> where
    T0: Kind,
    T1: Kind, 

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = Vec<ForkHandle>

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<U: Kind + Flatten, T0, T1> Kind for Box<dyn FnMut(T0, T1) -> U + Send + Sync> where
    T0: Kind,
    T1: Kind, 

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = Vec<ForkHandle>

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<U: Kind + Flatten, T0, T1> Kind for Box<dyn FnOnce(T0, T1) -> U + Send + Sync> where
    T0: Kind,
    T1: Kind, 

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = Vec<ForkHandle>

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<U: Kind + Flatten, T0, T1> Kind for Arc<Box<dyn Fn(T0, T1) -> U + Send + Sync>> where
    T0: Kind,
    T1: Kind, 

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = Vec<ForkHandle>

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<U: Kind + Flatten, T0, T1, T2> Kind for Box<dyn Fn(T0, T1, T2) -> U + Send + Sync> where
    T0: Kind,
    T1: Kind,
    T2: Kind, 

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = Vec<ForkHandle>

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<U: Kind + Flatten, T0, T1, T2> Kind for Box<dyn FnMut(T0, T1, T2) -> U + Send + Sync> where
    T0: Kind,
    T1: Kind,
    T2: Kind, 

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = Vec<ForkHandle>

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<U: Kind + Flatten, T0, T1, T2> Kind for Box<dyn FnOnce(T0, T1, T2) -> U + Send + Sync> where
    T0: Kind,
    T1: Kind,
    T2: Kind, 

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = Vec<ForkHandle>

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<U: Kind + Flatten, T0, T1, T2> Kind for Arc<Box<dyn Fn(T0, T1, T2) -> U + Send + Sync>> where
    T0: Kind,
    T1: Kind,
    T2: Kind, 

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = Vec<ForkHandle>

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<U: Kind + Flatten, T0, T1, T2, T3> Kind for Box<dyn Fn(T0, T1, T2, T3) -> U + Send + Sync> where
    T0: Kind,
    T1: Kind,
    T2: Kind,
    T3: Kind, 

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = Vec<ForkHandle>

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<U: Kind + Flatten, T0, T1, T2, T3> Kind for Box<dyn FnMut(T0, T1, T2, T3) -> U + Send + Sync> where
    T0: Kind,
    T1: Kind,
    T2: Kind,
    T3: Kind, 

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = Vec<ForkHandle>

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<U: Kind + Flatten, T0, T1, T2, T3> Kind for Box<dyn FnOnce(T0, T1, T2, T3) -> U + Send + Sync> where
    T0: Kind,
    T1: Kind,
    T2: Kind,
    T3: Kind, 

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = Vec<ForkHandle>

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<U: Kind + Flatten, T0, T1, T2, T3> Kind for Arc<Box<dyn Fn(T0, T1, T2, T3) -> U + Send + Sync>> where
    T0: Kind,
    T1: Kind,
    T2: Kind,
    T3: Kind, 

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = Vec<ForkHandle>

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<U: Kind + Flatten, T0, T1, T2, T3, T4> Kind for Box<dyn Fn(T0, T1, T2, T3, T4) -> U + Send + Sync> where
    T0: Kind,
    T1: Kind,
    T2: Kind,
    T3: Kind,
    T4: Kind, 

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = Vec<ForkHandle>

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<U: Kind + Flatten, T0, T1, T2, T3, T4> Kind for Box<dyn FnMut(T0, T1, T2, T3, T4) -> U + Send + Sync> where
    T0: Kind,
    T1: Kind,
    T2: Kind,
    T3: Kind,
    T4: Kind, 

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = Vec<ForkHandle>

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<U: Kind + Flatten, T0, T1, T2, T3, T4> Kind for Box<dyn FnOnce(T0, T1, T2, T3, T4) -> U + Send + Sync> where
    T0: Kind,
    T1: Kind,
    T2: Kind,
    T3: Kind,
    T4: Kind, 

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = Vec<ForkHandle>

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<U: Kind + Flatten, T0, T1, T2, T3, T4> Kind for Arc<Box<dyn Fn(T0, T1, T2, T3, T4) -> U + Send + Sync>> where
    T0: Kind,
    T1: Kind,
    T2: Kind,
    T3: Kind,
    T4: Kind, 

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = Vec<ForkHandle>

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<U: Kind + Flatten, T0, T1, T2, T3, T4, T5> Kind for Box<dyn Fn(T0, T1, T2, T3, T4, T5) -> U + Send + Sync> where
    T0: Kind,
    T1: Kind,
    T2: Kind,
    T3: Kind,
    T4: Kind,
    T5: Kind, 

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = Vec<ForkHandle>

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<U: Kind + Flatten, T0, T1, T2, T3, T4, T5> Kind for Box<dyn FnMut(T0, T1, T2, T3, T4, T5) -> U + Send + Sync> where
    T0: Kind,
    T1: Kind,
    T2: Kind,
    T3: Kind,
    T4: Kind,
    T5: Kind, 

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = Vec<ForkHandle>

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<U: Kind + Flatten, T0, T1, T2, T3, T4, T5> Kind for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5) -> U + Send + Sync> where
    T0: Kind,
    T1: Kind,
    T2: Kind,
    T3: Kind,
    T4: Kind,
    T5: Kind, 

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = Vec<ForkHandle>

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<U: Kind + Flatten, T0, T1, T2, T3, T4, T5> Kind for Arc<Box<dyn Fn(T0, T1, T2, T3, T4, T5) -> U + Send + Sync>> where
    T0: Kind,
    T1: Kind,
    T2: Kind,
    T3: Kind,
    T4: Kind,
    T5: Kind, 

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = Vec<ForkHandle>

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<U: Kind + Flatten, T0, T1, T2, T3, T4, T5, T6> Kind for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6) -> U + Send + Sync> where
    T0: Kind,
    T1: Kind,
    T2: Kind,
    T3: Kind,
    T4: Kind,
    T5: Kind,
    T6: Kind, 

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = Vec<ForkHandle>

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<U: Kind + Flatten, T0, T1, T2, T3, T4, T5, T6> Kind for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6) -> U + Send + Sync> where
    T0: Kind,
    T1: Kind,
    T2: Kind,
    T3: Kind,
    T4: Kind,
    T5: Kind,
    T6: Kind, 

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = Vec<ForkHandle>

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<U: Kind + Flatten, T0, T1, T2, T3, T4, T5, T6> Kind for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6) -> U + Send + Sync> where
    T0: Kind,
    T1: Kind,
    T2: Kind,
    T3: Kind,
    T4: Kind,
    T5: Kind,
    T6: Kind, 

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = Vec<ForkHandle>

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<U: Kind + Flatten, T0, T1, T2, T3, T4, T5, T6> Kind for Arc<Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6) -> U + Send + Sync>> where
    T0: Kind,
    T1: Kind,
    T2: Kind,
    T3: Kind,
    T4: Kind,
    T5: Kind,
    T6: Kind, 

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = Vec<ForkHandle>

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<U: Kind + Flatten, T0, T1, T2, T3, T4, T5, T6, T7> Kind for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7) -> U + Send + Sync> where
    T0: Kind,
    T1: Kind,
    T2: Kind,
    T3: Kind,
    T4: Kind,
    T5: Kind,
    T6: Kind,
    T7: Kind, 

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = Vec<ForkHandle>

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<U: Kind + Flatten, T0, T1, T2, T3, T4, T5, T6, T7> Kind for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7) -> U + Send + Sync> where
    T0: Kind,
    T1: Kind,
    T2: Kind,
    T3: Kind,
    T4: Kind,
    T5: Kind,
    T6: Kind,
    T7: Kind, 

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = Vec<ForkHandle>

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<U: Kind + Flatten, T0, T1, T2, T3, T4, T5, T6, T7> Kind for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7) -> U + Send + Sync> where
    T0: Kind,
    T1: Kind,
    T2: Kind,
    T3: Kind,
    T4: Kind,
    T5: Kind,
    T6: Kind,
    T7: Kind, 

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = Vec<ForkHandle>

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<U: Kind + Flatten, T0, T1, T2, T3, T4, T5, T6, T7> Kind for Arc<Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7) -> U + Send + Sync>> where
    T0: Kind,
    T1: Kind,
    T2: Kind,
    T3: Kind,
    T4: Kind,
    T5: Kind,
    T6: Kind,
    T7: Kind, 

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = Vec<ForkHandle>

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<U: Kind + Flatten, T0, T1, T2, T3, T4, T5, T6, T7, T8> Kind for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8) -> U + Send + Sync> where
    T0: Kind,
    T1: Kind,
    T2: Kind,
    T3: Kind,
    T4: Kind,
    T5: Kind,
    T6: Kind,
    T7: Kind,
    T8: Kind, 

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = Vec<ForkHandle>

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<U: Kind + Flatten, T0, T1, T2, T3, T4, T5, T6, T7, T8> Kind for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8) -> U + Send + Sync> where
    T0: Kind,
    T1: Kind,
    T2: Kind,
    T3: Kind,
    T4: Kind,
    T5: Kind,
    T6: Kind,
    T7: Kind,
    T8: Kind, 

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = Vec<ForkHandle>

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<U: Kind + Flatten, T0, T1, T2, T3, T4, T5, T6, T7, T8> Kind for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8) -> U + Send + Sync> where
    T0: Kind,
    T1: Kind,
    T2: Kind,
    T3: Kind,
    T4: Kind,
    T5: Kind,
    T6: Kind,
    T7: Kind,
    T8: Kind, 

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = Vec<ForkHandle>

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<U: Kind + Flatten, T0, T1, T2, T3, T4, T5, T6, T7, T8> Kind for Arc<Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8) -> U + Send + Sync>> where
    T0: Kind,
    T1: Kind,
    T2: Kind,
    T3: Kind,
    T4: Kind,
    T5: Kind,
    T6: Kind,
    T7: Kind,
    T8: Kind, 

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = Vec<ForkHandle>

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<U: Kind + Flatten, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Kind for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) -> U + Send + Sync> where
    T0: Kind,
    T1: Kind,
    T2: Kind,
    T3: Kind,
    T4: Kind,
    T5: Kind,
    T6: Kind,
    T7: Kind,
    T8: Kind,
    T9: Kind, 

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = Vec<ForkHandle>

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<U: Kind + Flatten, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Kind for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) -> U + Send + Sync> where
    T0: Kind,
    T1: Kind,
    T2: Kind,
    T3: Kind,
    T4: Kind,
    T5: Kind,
    T6: Kind,
    T7: Kind,
    T8: Kind,
    T9: Kind, 

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = Vec<ForkHandle>

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<U: Kind + Flatten, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Kind for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) -> U + Send + Sync> where
    T0: Kind,
    T1: Kind,
    T2: Kind,
    T3: Kind,
    T4: Kind,
    T5: Kind,
    T6: Kind,
    T7: Kind,
    T8: Kind,
    T9: Kind, 

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = Vec<ForkHandle>

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<U: Kind + Flatten, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Kind for Arc<Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) -> U + Send + Sync>> where
    T0: Kind,
    T1: Kind,
    T2: Kind,
    T3: Kind,
    T4: Kind,
    T5: Kind,
    T6: Kind,
    T7: Kind,
    T8: Kind,
    T9: Kind, 

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = Vec<ForkHandle>

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<U: Kind + Flatten, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Kind for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> U + Send + Sync> where
    T0: Kind,
    T1: Kind,
    T2: Kind,
    T3: Kind,
    T4: Kind,
    T5: Kind,
    T6: Kind,
    T7: Kind,
    T8: Kind,
    T9: Kind,
    T10: Kind, 

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = Vec<ForkHandle>

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<U: Kind + Flatten, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Kind for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> U + Send + Sync> where
    T0: Kind,
    T1: Kind,
    T2: Kind,
    T3: Kind,
    T4: Kind,
    T5: Kind,
    T6: Kind,
    T7: Kind,
    T8: Kind,
    T9: Kind,
    T10: Kind, 

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = Vec<ForkHandle>

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<U: Kind + Flatten, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Kind for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> U + Send + Sync> where
    T0: Kind,
    T1: Kind,
    T2: Kind,
    T3: Kind,
    T4: Kind,
    T5: Kind,
    T6: Kind,
    T7: Kind,
    T8: Kind,
    T9: Kind,
    T10: Kind, 

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = Vec<ForkHandle>

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<U: Kind + Flatten, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Kind for Arc<Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> U + Send + Sync>> where
    T0: Kind,
    T1: Kind,
    T2: Kind,
    T3: Kind,
    T4: Kind,
    T5: Kind,
    T6: Kind,
    T7: Kind,
    T8: Kind,
    T9: Kind,
    T10: Kind, 

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = Vec<ForkHandle>

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<U: Kind + Flatten, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Kind for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> U + Send + Sync> where
    T0: Kind,
    T1: Kind,
    T2: Kind,
    T3: Kind,
    T4: Kind,
    T5: Kind,
    T6: Kind,
    T7: Kind,
    T8: Kind,
    T9: Kind,
    T10: Kind,
    T11: Kind, 

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = Vec<ForkHandle>

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<U: Kind + Flatten, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Kind for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> U + Send + Sync> where
    T0: Kind,
    T1: Kind,
    T2: Kind,
    T3: Kind,
    T4: Kind,
    T5: Kind,
    T6: Kind,
    T7: Kind,
    T8: Kind,
    T9: Kind,
    T10: Kind,
    T11: Kind, 

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = Vec<ForkHandle>

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<U: Kind + Flatten, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Kind for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> U + Send + Sync> where
    T0: Kind,
    T1: Kind,
    T2: Kind,
    T3: Kind,
    T4: Kind,
    T5: Kind,
    T6: Kind,
    T7: Kind,
    T8: Kind,
    T9: Kind,
    T10: Kind,
    T11: Kind, 

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = Vec<ForkHandle>

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<U: Kind + Flatten, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Kind for Arc<Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> U + Send + Sync>> where
    T0: Kind,
    T1: Kind,
    T2: Kind,
    T3: Kind,
    T4: Kind,
    T5: Kind,
    T6: Kind,
    T7: Kind,
    T8: Kind,
    T9: Kind,
    T10: Kind,
    T11: Kind, 

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = Vec<ForkHandle>

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<U: Kind + Flatten, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Kind for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> U + Send + Sync> where
    T0: Kind,
    T1: Kind,
    T2: Kind,
    T3: Kind,
    T4: Kind,
    T5: Kind,
    T6: Kind,
    T7: Kind,
    T8: Kind,
    T9: Kind,
    T10: Kind,
    T11: Kind,
    T12: Kind, 

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = Vec<ForkHandle>

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<U: Kind + Flatten, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Kind for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> U + Send + Sync> where
    T0: Kind,
    T1: Kind,
    T2: Kind,
    T3: Kind,
    T4: Kind,
    T5: Kind,
    T6: Kind,
    T7: Kind,
    T8: Kind,
    T9: Kind,
    T10: Kind,
    T11: Kind,
    T12: Kind, 

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = Vec<ForkHandle>

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<U: Kind + Flatten, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Kind for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> U + Send + Sync> where
    T0: Kind,
    T1: Kind,
    T2: Kind,
    T3: Kind,
    T4: Kind,
    T5: Kind,
    T6: Kind,
    T7: Kind,
    T8: Kind,
    T9: Kind,
    T10: Kind,
    T11: Kind,
    T12: Kind, 

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = Vec<ForkHandle>

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<U: Kind + Flatten, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Kind for Arc<Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> U + Send + Sync>> where
    T0: Kind,
    T1: Kind,
    T2: Kind,
    T3: Kind,
    T4: Kind,
    T5: Kind,
    T6: Kind,
    T7: Kind,
    T8: Kind,
    T9: Kind,
    T10: Kind,
    T11: Kind,
    T12: Kind, 

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = Vec<ForkHandle>

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<U: Kind + Flatten, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Kind for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> U + Send + Sync> where
    T0: Kind,
    T1: Kind,
    T2: Kind,
    T3: Kind,
    T4: Kind,
    T5: Kind,
    T6: Kind,
    T7: Kind,
    T8: Kind,
    T9: Kind,
    T10: Kind,
    T11: Kind,
    T12: Kind,
    T13: Kind, 

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = Vec<ForkHandle>

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<U: Kind + Flatten, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Kind for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> U + Send + Sync> where
    T0: Kind,
    T1: Kind,
    T2: Kind,
    T3: Kind,
    T4: Kind,
    T5: Kind,
    T6: Kind,
    T7: Kind,
    T8: Kind,
    T9: Kind,
    T10: Kind,
    T11: Kind,
    T12: Kind,
    T13: Kind, 

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = Vec<ForkHandle>

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<U: Kind + Flatten, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Kind for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> U + Send + Sync> where
    T0: Kind,
    T1: Kind,
    T2: Kind,
    T3: Kind,
    T4: Kind,
    T5: Kind,
    T6: Kind,
    T7: Kind,
    T8: Kind,
    T9: Kind,
    T10: Kind,
    T11: Kind,
    T12: Kind,
    T13: Kind, 

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = Vec<ForkHandle>

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<U: Kind + Flatten, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Kind for Arc<Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> U + Send + Sync>> where
    T0: Kind,
    T1: Kind,
    T2: Kind,
    T3: Kind,
    T4: Kind,
    T5: Kind,
    T6: Kind,
    T7: Kind,
    T8: Kind,
    T9: Kind,
    T10: Kind,
    T11: Kind,
    T12: Kind,
    T13: Kind, 

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = Vec<ForkHandle>

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<U: Kind + Flatten, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Kind for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> U + Send + Sync> where
    T0: Kind,
    T1: Kind,
    T2: Kind,
    T3: Kind,
    T4: Kind,
    T5: Kind,
    T6: Kind,
    T7: Kind,
    T8: Kind,
    T9: Kind,
    T10: Kind,
    T11: Kind,
    T12: Kind,
    T13: Kind,
    T14: Kind, 

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = Vec<ForkHandle>

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<U: Kind + Flatten, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Kind for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> U + Send + Sync> where
    T0: Kind,
    T1: Kind,
    T2: Kind,
    T3: Kind,
    T4: Kind,
    T5: Kind,
    T6: Kind,
    T7: Kind,
    T8: Kind,
    T9: Kind,
    T10: Kind,
    T11: Kind,
    T12: Kind,
    T13: Kind,
    T14: Kind, 

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = Vec<ForkHandle>

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<U: Kind + Flatten, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Kind for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> U + Send + Sync> where
    T0: Kind,
    T1: Kind,
    T2: Kind,
    T3: Kind,
    T4: Kind,
    T5: Kind,
    T6: Kind,
    T7: Kind,
    T8: Kind,
    T9: Kind,
    T10: Kind,
    T11: Kind,
    T12: Kind,
    T13: Kind,
    T14: Kind, 

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = Vec<ForkHandle>

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<U: Kind + Flatten, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Kind for Arc<Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> U + Send + Sync>> where
    T0: Kind,
    T1: Kind,
    T2: Kind,
    T3: Kind,
    T4: Kind,
    T5: Kind,
    T6: Kind,
    T7: Kind,
    T8: Kind,
    T9: Kind,
    T10: Kind,
    T11: Kind,
    T12: Kind,
    T13: Kind,
    T14: Kind, 

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = Vec<ForkHandle>

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<U: Kind + Flatten, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Kind for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> U + Send + Sync> where
    T0: Kind,
    T1: Kind,
    T2: Kind,
    T3: Kind,
    T4: Kind,
    T5: Kind,
    T6: Kind,
    T7: Kind,
    T8: Kind,
    T9: Kind,
    T10: Kind,
    T11: Kind,
    T12: Kind,
    T13: Kind,
    T14: Kind,
    T15: Kind, 

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = Vec<ForkHandle>

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<U: Kind + Flatten, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Kind for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> U + Send + Sync> where
    T0: Kind,
    T1: Kind,
    T2: Kind,
    T3: Kind,
    T4: Kind,
    T5: Kind,
    T6: Kind,
    T7: Kind,
    T8: Kind,
    T9: Kind,
    T10: Kind,
    T11: Kind,
    T12: Kind,
    T13: Kind,
    T14: Kind,
    T15: Kind, 

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = Vec<ForkHandle>

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<U: Kind + Flatten, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Kind for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> U + Send + Sync> where
    T0: Kind,
    T1: Kind,
    T2: Kind,
    T3: Kind,
    T4: Kind,
    T5: Kind,
    T6: Kind,
    T7: Kind,
    T8: Kind,
    T9: Kind,
    T10: Kind,
    T11: Kind,
    T12: Kind,
    T13: Kind,
    T14: Kind,
    T15: Kind, 

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = Vec<ForkHandle>

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<U: Kind + Flatten, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Kind for Arc<Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> U + Send + Sync>> where
    T0: Kind,
    T1: Kind,
    T2: Kind,
    T3: Kind,
    T4: Kind,
    T5: Kind,
    T6: Kind,
    T7: Kind,
    T8: Kind,
    T9: Kind,
    T10: Kind,
    T11: Kind,
    T12: Kind,
    T13: Kind,
    T14: Kind,
    T15: Kind, 

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = Vec<ForkHandle>

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<T> Kind for Option<T> where
    T: Kind, 

type ConstructItem = Option<ForkHandle>

type ConstructError = WrappedError<T::ConstructError>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<T::DeconstructError>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<T: Unpin + Sync + Send + 'static> Kind for PhantomData<T>

type ConstructItem = ()

type ConstructError = Void

type ConstructFuture = Ready<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = Void

type DeconstructFuture = Ready<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    _: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    _: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl Kind for bool

type ConstructItem = bool

type ConstructError = WrappedError<Void>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<Void>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl Kind for isize

type ConstructItem = isize

type ConstructError = WrappedError<Void>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<Void>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl Kind for i8

type ConstructItem = i8

type ConstructError = WrappedError<Void>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<Void>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl Kind for i16

type ConstructItem = i16

type ConstructError = WrappedError<Void>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<Void>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl Kind for i32

type ConstructItem = i32

type ConstructError = WrappedError<Void>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<Void>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl Kind for i64

type ConstructItem = i64

type ConstructError = WrappedError<Void>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<Void>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl Kind for i128

type ConstructItem = i128

type ConstructError = WrappedError<Void>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<Void>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl Kind for usize

type ConstructItem = usize

type ConstructError = WrappedError<Void>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<Void>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl Kind for u8

type ConstructItem = u8

type ConstructError = WrappedError<Void>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<Void>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl Kind for u16

type ConstructItem = u16

type ConstructError = WrappedError<Void>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<Void>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl Kind for u32

type ConstructItem = u32

type ConstructError = WrappedError<Void>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<Void>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl Kind for u64

type ConstructItem = u64

type ConstructError = WrappedError<Void>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<Void>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl Kind for u128

type ConstructItem = u128

type ConstructError = WrappedError<Void>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<Void>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl Kind for f32

type ConstructItem = f32

type ConstructError = WrappedError<Void>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<Void>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl Kind for f64

type ConstructItem = f64

type ConstructError = WrappedError<Void>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<Void>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl Kind for char

type ConstructItem = char

type ConstructError = WrappedError<Void>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<Void>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl Kind for CString

type ConstructItem = CString

type ConstructError = WrappedError<Void>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<Void>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl Kind for String

type ConstructItem = String

type ConstructError = WrappedError<Void>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<Void>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl Kind for Ipv4Addr

type ConstructItem = Ipv4Addr

type ConstructError = WrappedError<Void>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<Void>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl Kind for SocketAddrV4

type ConstructItem = SocketAddrV4

type ConstructError = WrappedError<Void>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<Void>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl Kind for SocketAddrV6

type ConstructItem = SocketAddrV6

type ConstructError = WrappedError<Void>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<Void>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl Kind for SocketAddr

type ConstructItem = SocketAddr

type ConstructError = WrappedError<Void>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<Void>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl Kind for SystemTime

type ConstructItem = SystemTime

type ConstructError = WrappedError<Void>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<Void>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl Kind for Ipv6Addr

type ConstructItem = Ipv6Addr

type ConstructError = WrappedError<Void>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<Void>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl Kind for Duration

type ConstructItem = Duration

type ConstructError = WrappedError<Void>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<Void>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl Kind for NonZeroU8

type ConstructItem = NonZeroU8

type ConstructError = WrappedError<Void>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<Void>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl Kind for NonZeroU16

type ConstructItem = NonZeroU16

type ConstructError = WrappedError<Void>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<Void>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl Kind for NonZeroU32

type ConstructItem = NonZeroU32

type ConstructError = WrappedError<Void>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<Void>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl Kind for NonZeroU64

type ConstructItem = NonZeroU64

type ConstructError = WrappedError<Void>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<Void>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl Kind for NonZeroUsize

type ConstructItem = NonZeroUsize

type ConstructError = WrappedError<Void>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<Void>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl Kind for NonZeroI8

type ConstructItem = NonZeroI8

type ConstructError = WrappedError<Void>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<Void>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl Kind for NonZeroI16

type ConstructItem = NonZeroI16

type ConstructError = WrappedError<Void>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<Void>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl Kind for NonZeroI32

type ConstructItem = NonZeroI32

type ConstructError = WrappedError<Void>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<Void>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl Kind for NonZeroI64

type ConstructItem = NonZeroI64

type ConstructError = WrappedError<Void>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<Void>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl Kind for NonZeroIsize

type ConstructItem = NonZeroIsize

type ConstructError = WrappedError<Void>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<Void>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<T, E> Kind for Result<T, E> where
    T: Kind,
    E: Kind, 

type ConstructItem = Result<ForkHandle, ForkHandle>

type ConstructError = WrappedError<ResultError<T::ConstructError, E::ConstructError>>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<ResultError<T::DeconstructError, E::DeconstructError>>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<T> Kind for (T,) where
    T: Kind, 

type ConstructItem = ForkHandle

type ConstructError = WrappedError<T::ConstructError>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<T::DeconstructError>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<T0, T1> Kind for (T0, T1) where
    T0: Kind,
    T1: Kind, 

type ConstructItem = Vec<ForkHandle>

type ConstructError = WrappedError<Void>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

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

type ConstructItem = Vec<ForkHandle>

type ConstructError = WrappedError<Void>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

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

type ConstructItem = Vec<ForkHandle>

type ConstructError = WrappedError<Void>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

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

type ConstructItem = Vec<ForkHandle>

type ConstructError = WrappedError<Void>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

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

type ConstructItem = Vec<ForkHandle>

type ConstructError = WrappedError<Void>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

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

type ConstructItem = Vec<ForkHandle>

type ConstructError = WrappedError<Void>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

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

type ConstructItem = Vec<ForkHandle>

type ConstructError = WrappedError<Void>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

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

type ConstructItem = Vec<ForkHandle>

type ConstructError = WrappedError<Void>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

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

type ConstructItem = Vec<ForkHandle>

type ConstructError = WrappedError<Void>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

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

type ConstructItem = Vec<ForkHandle>

type ConstructError = WrappedError<Void>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

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

type ConstructItem = Vec<ForkHandle>

type ConstructError = WrappedError<Void>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

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

type ConstructItem = Vec<ForkHandle>

type ConstructError = WrappedError<Void>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

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

type ConstructItem = Vec<ForkHandle>

type ConstructError = WrappedError<Void>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

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

type ConstructItem = Vec<ForkHandle>

type ConstructError = WrappedError<Void>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

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

type ConstructItem = Vec<ForkHandle>

type ConstructError = WrappedError<Void>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl Kind for ()

type ConstructItem = ()

type ConstructError = Void

type ConstructFuture = Ready<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = Void

type DeconstructFuture = Ready<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    _: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    _: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl Kind for Url

type ConstructItem = String

type ConstructError = WrappedError<ParseError>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<Void>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<T> Kind for Arc<Mutex<T>> where
    T: Kind, 

type ConstructItem = ForkHandle

type ConstructError = WrappedError<T::ConstructError>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<T::DeconstructError>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<T> Kind for Box<T> where
    T: Kind, 

type ConstructItem = ForkHandle

type ConstructError = WrappedError<T::ConstructError>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<T::DeconstructError>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

Loading content...

Implementors

impl Kind for CoreError

type ConstructItem = _DERIVE_Items

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl Kind for ConnectError

type ConstructItem = _DERIVE_Items

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl Kind for Checksum

type ConstructItem = _DERIVE_Items

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl Kind for Client

type ConstructItem = _DERIVE_Items

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl Kind for ConnectionError

type ConstructItem = _DERIVE_Items

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl Kind for ListenError

type ConstructItem = _DERIVE_Items

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl Kind for Server

type ConstructItem = _DERIVE_Items

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl Kind for CompileError

type ConstructItem = _DERIVE_Items

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl Kind for InstantiateError

type ConstructItem = _DERIVE_Items

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl Kind for Orchestrator

type ConstructItem = _DERIVE_Items

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl Kind for Handle

type ConstructItem = _DERIVE_Items

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl Kind for UnimplementedError

type ConstructItem = _DERIVE_Items

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl Kind for TransportError

type ConstructItem = _DERIVE_Items

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<T> Kind for Future<T> where
    T: Kind, 

type ConstructItem = ForkHandle

type ConstructError = T::ConstructError

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<T::DeconstructError>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<T> Kind for Stream<T> where
    T: Kind, 

type ConstructItem = Option<ForkHandle>

type ConstructError = WrappedError<T::ConstructError>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<T::DeconstructError>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<T, E> Kind for Sink<T, E> where
    T: Kind,
    E: Kind, 

type ConstructItem = ForkHandle

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ForkHandle

type DeconstructError = WrappedError<Void>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<T, E, U> Kind for SinkStream<T, E, U> where
    T: Kind,
    E: Kind,
    U: Kind, 

type ConstructItem = _DERIVE_Items

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<T: Reflected + Trait<T> + ?Sized> Kind for Shared<T> where
    Box<T>: Kind, 

type ConstructItem = ForkHandle

type ConstructError = WrappedError<<Box<T> as Kind>::ConstructError>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<<Box<T> as Kind>::DeconstructError>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<T: Kind> Kind for Module<T> where
    Vec<u8>: AsKind<Serde>,
    T: Kind, 

type ConstructItem = _DERIVE_Items

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<T: IDefault + Unpin + Sync + Send + 'static> Kind for Default<T>

type ConstructItem = ()

type ConstructError = Void

type ConstructFuture = Ready<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = Void

type DeconstructFuture = Ready<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    _: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    _: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<T: Unpin + Sync + Send + IntoIterator + FromIterator<<T as IntoIterator>::Item> + 'static> Kind for Iterator<T> where
    <T as IntoIterator>::Item: Kind,
    T::IntoIter: Unpin + Sync + Send, 

type ConstructItem = Vec<ForkHandle>

type ConstructError = WrappedError<<<T as IntoIterator>::Item as Kind>::ConstructError>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<<<T as IntoIterator>::Item as Kind>::DeconstructError>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<T: Serialize + DeserializeOwned + Sync + Send + 'static> Kind for Resource<T> where
    T: Kind, 

type ConstructItem = _DERIVE_Items

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<T: Serialize + DeserializeOwned + Sync + Send + 'static> Kind for ReifyError<T> where
    T: Kind, 

type ConstructItem = _DERIVE_Items

type ConstructError = Void

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = Void

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

impl<T: Serialize + DeserializeOwned + Sync + Send + Unpin + 'static> Kind for Serde<T>

type ConstructItem = T

type ConstructError = WrappedError<Void>

type ConstructFuture = Future<ConstructResult<Self>>

type DeconstructItem = ()

type DeconstructError = WrappedError<Void>

type DeconstructFuture = Future<DeconstructResult<Self>>

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]

Loading content...