Trait destream::de::FromStream

pub trait FromStream: Send + Sized {
    type Context: Send;
    fn from_stream<'life0, 'async_trait, D: Decoder>(
        context: Self::Context, 
        decoder: &'life0 mut D
    ) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>>
    where
        D: 'async_trait,
        'life0: 'async_trait,
        Self: 'async_trait;
}

This trait describes a value which can be decoded from a stream.

Based on serde::de::Deserialize.

Associated Types

type Context: Send

The decoding context of this type, useful in situations where the stream to be decoded may be too large to hold in main memory.

Types intended to be stored entirely in main memory should use the unit context ().

Required methods

fn from_stream<'life0, 'async_trait, D: Decoder>(
    context: Self::Context,
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

Parse this value using the given Decoder.

Implementations on Foreign Types

impl FromStream for bool

type Context = ()

fn from_stream<'life0, 'async_trait, D: Decoder>(
    _context: Self::Context,
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl FromStream for i8

type Context = ()

fn from_stream<'life0, 'async_trait, D: Decoder>(
    _context: Self::Context,
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl FromStream for i16

type Context = ()

fn from_stream<'life0, 'async_trait, D: Decoder>(
    _context: Self::Context,
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl FromStream for i32

type Context = ()

fn from_stream<'life0, 'async_trait, D: Decoder>(
    _context: Self::Context,
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl FromStream for i64

type Context = ()

fn from_stream<'life0, 'async_trait, D: Decoder>(
    _context: Self::Context,
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl FromStream for u8

type Context = ()

fn from_stream<'life0, 'async_trait, D: Decoder>(
    _context: Self::Context,
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl FromStream for u16

type Context = ()

fn from_stream<'life0, 'async_trait, D: Decoder>(
    _context: Self::Context,
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl FromStream for u32

type Context = ()

fn from_stream<'life0, 'async_trait, D: Decoder>(
    _context: Self::Context,
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl FromStream for u64

type Context = ()

fn from_stream<'life0, 'async_trait, D: Decoder>(
    _context: Self::Context,
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl FromStream for f32

type Context = ()

fn from_stream<'life0, 'async_trait, D: Decoder>(
    _context: Self::Context,
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl FromStream for f64

type Context = ()

fn from_stream<'life0, 'async_trait, D: Decoder>(
    _context: Self::Context,
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl FromStream for String

type Context = ()

fn from_stream<'life0, 'async_trait, D: Decoder>(
    _context: Self::Context,
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl FromStream for isize

type Context = ()

fn from_stream<'life0, 'async_trait, D: Decoder>(
    cxt: (),
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl FromStream for usize

type Context = ()

fn from_stream<'life0, 'async_trait, D: Decoder>(
    cxt: (),
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl FromStream for Bytes

type Context = ()

fn from_stream<'life0, 'async_trait, D: Decoder>(
    __arg0: (),
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T: FromStream> FromStream for Option<T>

type Context = T::Context

fn from_stream<'life0, 'async_trait, D: Decoder>(
    context: Self::Context,
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T: Send + ?Sized> FromStream for PhantomData<T>

type Context = ()

fn from_stream<'life0, 'async_trait, D: Decoder>(
    _context: (),
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T> FromStream for BinaryHeap<T> where
    T: FromStream + Ord,
    T::Context: Copy, 

type Context = T::Context

fn from_stream<'life0, 'async_trait, D: Decoder>(
    context: Self::Context,
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T> FromStream for BTreeSet<T> where
    T: FromStream + Eq + Ord,
    T::Context: Copy, 

type Context = T::Context

fn from_stream<'life0, 'async_trait, D: Decoder>(
    context: Self::Context,
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T> FromStream for LinkedList<T> where
    T: FromStream,
    T::Context: Copy, 

type Context = T::Context

fn from_stream<'life0, 'async_trait, D: Decoder>(
    context: Self::Context,
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T, S> FromStream for HashSet<T, S> where
    T: FromStream + Eq + Hash,
    S: BuildHasher + Default + Send,
    T::Context: Copy, 

type Context = T::Context

fn from_stream<'life0, 'async_trait, D: Decoder>(
    context: Self::Context,
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T> FromStream for VecDeque<T> where
    T: FromStream,
    T::Context: Copy, 

type Context = T::Context

fn from_stream<'life0, 'async_trait, D: Decoder>(
    context: Self::Context,
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T> FromStream for Vec<T> where
    T: FromStream,
    T::Context: Copy, 

type Context = T::Context

fn from_stream<'life0, 'async_trait, D: Decoder>(
    context: Self::Context,
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T: FromStream> FromStream for [T; 0]

type Context = T::Context

fn from_stream<'life0, 'async_trait, D: Decoder>(
    context: T::Context,
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, <D as Decoder>::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T: FromStream> FromStream for [T; 1] where
    T::Context: Copy, 

type Context = T::Context

fn from_stream<'life0, 'async_trait, D: Decoder>(
    context: T::Context,
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T: FromStream> FromStream for [T; 2] where
    T::Context: Copy, 

type Context = T::Context

fn from_stream<'life0, 'async_trait, D: Decoder>(
    context: T::Context,
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T: FromStream> FromStream for [T; 3] where
    T::Context: Copy, 

type Context = T::Context

fn from_stream<'life0, 'async_trait, D: Decoder>(
    context: T::Context,
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T: FromStream> FromStream for [T; 4] where
    T::Context: Copy, 

type Context = T::Context

fn from_stream<'life0, 'async_trait, D: Decoder>(
    context: T::Context,
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T: FromStream> FromStream for [T; 5] where
    T::Context: Copy, 

type Context = T::Context

fn from_stream<'life0, 'async_trait, D: Decoder>(
    context: T::Context,
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T: FromStream> FromStream for [T; 6] where
    T::Context: Copy, 

type Context = T::Context

fn from_stream<'life0, 'async_trait, D: Decoder>(
    context: T::Context,
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T: FromStream> FromStream for [T; 7] where
    T::Context: Copy, 

type Context = T::Context

fn from_stream<'life0, 'async_trait, D: Decoder>(
    context: T::Context,
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T: FromStream> FromStream for [T; 8] where
    T::Context: Copy, 

type Context = T::Context

fn from_stream<'life0, 'async_trait, D: Decoder>(
    context: T::Context,
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T: FromStream> FromStream for [T; 9] where
    T::Context: Copy, 

type Context = T::Context

fn from_stream<'life0, 'async_trait, D: Decoder>(
    context: T::Context,
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T: FromStream> FromStream for [T; 10] where
    T::Context: Copy, 

type Context = T::Context

fn from_stream<'life0, 'async_trait, D: Decoder>(
    context: T::Context,
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T: FromStream> FromStream for [T; 11] where
    T::Context: Copy, 

type Context = T::Context

fn from_stream<'life0, 'async_trait, D: Decoder>(
    context: T::Context,
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T: FromStream> FromStream for [T; 12] where
    T::Context: Copy, 

type Context = T::Context

fn from_stream<'life0, 'async_trait, D: Decoder>(
    context: T::Context,
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T: FromStream> FromStream for [T; 13] where
    T::Context: Copy, 

type Context = T::Context

fn from_stream<'life0, 'async_trait, D: Decoder>(
    context: T::Context,
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T: FromStream> FromStream for [T; 14] where
    T::Context: Copy, 

type Context = T::Context

fn from_stream<'life0, 'async_trait, D: Decoder>(
    context: T::Context,
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T: FromStream> FromStream for [T; 15] where
    T::Context: Copy, 

type Context = T::Context

fn from_stream<'life0, 'async_trait, D: Decoder>(
    context: T::Context,
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T: FromStream> FromStream for [T; 16] where
    T::Context: Copy, 

type Context = T::Context

fn from_stream<'life0, 'async_trait, D: Decoder>(
    context: T::Context,
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T: FromStream> FromStream for [T; 17] where
    T::Context: Copy, 

type Context = T::Context

fn from_stream<'life0, 'async_trait, D: Decoder>(
    context: T::Context,
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T: FromStream> FromStream for [T; 18] where
    T::Context: Copy, 

type Context = T::Context

fn from_stream<'life0, 'async_trait, D: Decoder>(
    context: T::Context,
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T: FromStream> FromStream for [T; 19] where
    T::Context: Copy, 

type Context = T::Context

fn from_stream<'life0, 'async_trait, D: Decoder>(
    context: T::Context,
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T: FromStream> FromStream for [T; 20] where
    T::Context: Copy, 

type Context = T::Context

fn from_stream<'life0, 'async_trait, D: Decoder>(
    context: T::Context,
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T: FromStream> FromStream for [T; 21] where
    T::Context: Copy, 

type Context = T::Context

fn from_stream<'life0, 'async_trait, D: Decoder>(
    context: T::Context,
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T: FromStream> FromStream for [T; 22] where
    T::Context: Copy, 

type Context = T::Context

fn from_stream<'life0, 'async_trait, D: Decoder>(
    context: T::Context,
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T: FromStream> FromStream for [T; 23] where
    T::Context: Copy, 

type Context = T::Context

fn from_stream<'life0, 'async_trait, D: Decoder>(
    context: T::Context,
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T: FromStream> FromStream for [T; 24] where
    T::Context: Copy, 

type Context = T::Context

fn from_stream<'life0, 'async_trait, D: Decoder>(
    context: T::Context,
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T: FromStream> FromStream for [T; 25] where
    T::Context: Copy, 

type Context = T::Context

fn from_stream<'life0, 'async_trait, D: Decoder>(
    context: T::Context,
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T: FromStream> FromStream for [T; 26] where
    T::Context: Copy, 

type Context = T::Context

fn from_stream<'life0, 'async_trait, D: Decoder>(
    context: T::Context,
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T: FromStream> FromStream for [T; 27] where
    T::Context: Copy, 

type Context = T::Context

fn from_stream<'life0, 'async_trait, D: Decoder>(
    context: T::Context,
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T: FromStream> FromStream for [T; 28] where
    T::Context: Copy, 

type Context = T::Context

fn from_stream<'life0, 'async_trait, D: Decoder>(
    context: T::Context,
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T: FromStream> FromStream for [T; 29] where
    T::Context: Copy, 

type Context = T::Context

fn from_stream<'life0, 'async_trait, D: Decoder>(
    context: T::Context,
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T: FromStream> FromStream for [T; 30] where
    T::Context: Copy, 

type Context = T::Context

fn from_stream<'life0, 'async_trait, D: Decoder>(
    context: T::Context,
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T: FromStream> FromStream for [T; 31] where
    T::Context: Copy, 

type Context = T::Context

fn from_stream<'life0, 'async_trait, D: Decoder>(
    context: T::Context,
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T: FromStream> FromStream for [T; 32] where
    T::Context: Copy, 

type Context = T::Context

fn from_stream<'life0, 'async_trait, D: Decoder>(
    context: T::Context,
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T0: FromStream<Context = ()>> FromStream for (T0,)

type Context = ()

fn from_stream<'life0, 'async_trait, D: Decoder>(
    _context: (),
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T0: FromStream<Context = ()>, T1: FromStream<Context = ()>> FromStream for (T0, T1)

type Context = ()

fn from_stream<'life0, 'async_trait, D: Decoder>(
    _context: (),
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T0: FromStream<Context = ()>, T1: FromStream<Context = ()>, T2: FromStream<Context = ()>> FromStream for (T0, T1, T2)

type Context = ()

fn from_stream<'life0, 'async_trait, D: Decoder>(
    _context: (),
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T0: FromStream<Context = ()>, T1: FromStream<Context = ()>, T2: FromStream<Context = ()>, T3: FromStream<Context = ()>> FromStream for (T0, T1, T2, T3)

type Context = ()

fn from_stream<'life0, 'async_trait, D: Decoder>(
    _context: (),
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T0: FromStream<Context = ()>, T1: FromStream<Context = ()>, T2: FromStream<Context = ()>, T3: FromStream<Context = ()>, T4: FromStream<Context = ()>> FromStream for (T0, T1, T2, T3, T4)

type Context = ()

fn from_stream<'life0, 'async_trait, D: Decoder>(
    _context: (),
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T0: FromStream<Context = ()>, T1: FromStream<Context = ()>, T2: FromStream<Context = ()>, T3: FromStream<Context = ()>, T4: FromStream<Context = ()>, T5: FromStream<Context = ()>> FromStream for (T0, T1, T2, T3, T4, T5)

type Context = ()

fn from_stream<'life0, 'async_trait, D: Decoder>(
    _context: (),
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T0: FromStream<Context = ()>, T1: FromStream<Context = ()>, T2: FromStream<Context = ()>, T3: FromStream<Context = ()>, T4: FromStream<Context = ()>, T5: FromStream<Context = ()>, T6: FromStream<Context = ()>> FromStream for (T0, T1, T2, T3, T4, T5, T6)

type Context = ()

fn from_stream<'life0, 'async_trait, D: Decoder>(
    _context: (),
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T0: FromStream<Context = ()>, T1: FromStream<Context = ()>, T2: FromStream<Context = ()>, T3: FromStream<Context = ()>, T4: FromStream<Context = ()>, T5: FromStream<Context = ()>, T6: FromStream<Context = ()>, T7: FromStream<Context = ()>> FromStream for (T0, T1, T2, T3, T4, T5, T6, T7)

type Context = ()

fn from_stream<'life0, 'async_trait, D: Decoder>(
    _context: (),
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T0: FromStream<Context = ()>, T1: FromStream<Context = ()>, T2: FromStream<Context = ()>, T3: FromStream<Context = ()>, T4: FromStream<Context = ()>, T5: FromStream<Context = ()>, T6: FromStream<Context = ()>, T7: FromStream<Context = ()>, T8: FromStream<Context = ()>> FromStream for (T0, T1, T2, T3, T4, T5, T6, T7, T8)

type Context = ()

fn from_stream<'life0, 'async_trait, D: Decoder>(
    _context: (),
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T0: FromStream<Context = ()>, T1: FromStream<Context = ()>, T2: FromStream<Context = ()>, T3: FromStream<Context = ()>, T4: FromStream<Context = ()>, T5: FromStream<Context = ()>, T6: FromStream<Context = ()>, T7: FromStream<Context = ()>, T8: FromStream<Context = ()>, T9: FromStream<Context = ()>> FromStream for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)

type Context = ()

fn from_stream<'life0, 'async_trait, D: Decoder>(
    _context: (),
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T0: FromStream<Context = ()>, T1: FromStream<Context = ()>, T2: FromStream<Context = ()>, T3: FromStream<Context = ()>, T4: FromStream<Context = ()>, T5: FromStream<Context = ()>, T6: FromStream<Context = ()>, T7: FromStream<Context = ()>, T8: FromStream<Context = ()>, T9: FromStream<Context = ()>, T10: FromStream<Context = ()>> FromStream for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)

type Context = ()

fn from_stream<'life0, 'async_trait, D: Decoder>(
    _context: (),
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

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

type Context = ()

fn from_stream<'life0, 'async_trait, D: Decoder>(
    _context: (),
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

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

type Context = ()

fn from_stream<'life0, 'async_trait, D: Decoder>(
    _context: (),
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

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

type Context = ()

fn from_stream<'life0, 'async_trait, D: Decoder>(
    _context: (),
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

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

type Context = ()

fn from_stream<'life0, 'async_trait, D: Decoder>(
    _context: (),
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

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

type Context = ()

fn from_stream<'life0, 'async_trait, D: Decoder>(
    _context: (),
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<K, V> FromStream for BTreeMap<K, V> where
    K: FromStream<Context = ()> + Ord,
    V: FromStream<Context = ()>, 

type Context = ()

fn from_stream<'life0, 'async_trait, D: Decoder>(
    _context: (),
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<K, V, S> FromStream for HashMap<K, V, S> where
    K: FromStream<Context = ()> + Eq + Hash,
    V: FromStream<Context = ()>,
    S: BuildHasher + Default + Send, 

type Context = ()

fn from_stream<'life0, 'async_trait, D: Decoder>(
    _context: (),
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl FromStream for ()

type Context = ()

fn from_stream<'life0, 'async_trait, D: Decoder>(
    _context: (),
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

Implementors