Trait ConstructFromEmoji 

pub trait ConstructFromEmoji<A, I>
where
    I: Iterator<Item = u8>,
{
    // Required method
    fn construct_from_emoji(
        byte_stream: &mut DecodeEmojiToBytes<I>,
    ) -> Result<A, FromEmojiError>
       where Self: Sized;
}

A trait representing things that can be constructed from Emoji

Required Methods

fn construct_from_emoji( byte_stream: &mut DecodeEmojiToBytes<I>, ) -> Result<A, FromEmojiError>

where Self: Sized,

Implementations on Foreign Types

impl<I> ConstructFromEmoji<bool, I> for bool

where I: Iterator<Item = u8>,

fn construct_from_emoji( byte_stream: &mut DecodeEmojiToBytes<I>, ) -> Result<bool, FromEmojiError>

impl<I> ConstructFromEmoji<char, I> for char

where I: Iterator<Item = u8>,

fn construct_from_emoji( byte_stream: &mut DecodeEmojiToBytes<I>, ) -> Result<char, FromEmojiError>

impl<I> ConstructFromEmoji<f32, I> for f32

where I: Iterator<Item = u8>,

fn construct_from_emoji( byte_stream: &mut DecodeEmojiToBytes<I>, ) -> Result<f32, FromEmojiError>

impl<I> ConstructFromEmoji<f64, I> for f64

where I: Iterator<Item = u8>,

fn construct_from_emoji( byte_stream: &mut DecodeEmojiToBytes<I>, ) -> Result<f64, FromEmojiError>

impl<I> ConstructFromEmoji<i8, I> for i8

where I: Iterator<Item = u8>,

fn construct_from_emoji( byte_stream: &mut DecodeEmojiToBytes<I>, ) -> Result<i8, FromEmojiError>

impl<I> ConstructFromEmoji<i16, I> for i16

where I: Iterator<Item = u8>,

fn construct_from_emoji( byte_stream: &mut DecodeEmojiToBytes<I>, ) -> Result<i16, FromEmojiError>

impl<I> ConstructFromEmoji<i32, I> for i32

where I: Iterator<Item = u8>,

fn construct_from_emoji( byte_stream: &mut DecodeEmojiToBytes<I>, ) -> Result<i32, FromEmojiError>

impl<I> ConstructFromEmoji<i64, I> for i64

where I: Iterator<Item = u8>,

fn construct_from_emoji( byte_stream: &mut DecodeEmojiToBytes<I>, ) -> Result<i64, FromEmojiError>

impl<I> ConstructFromEmoji<i128, I> for i128

where I: Iterator<Item = u8>,

fn construct_from_emoji( byte_stream: &mut DecodeEmojiToBytes<I>, ) -> Result<i128, FromEmojiError>

impl<I> ConstructFromEmoji<u8, I> for u8

where I: Iterator<Item = u8>,

fn construct_from_emoji( byte_stream: &mut DecodeEmojiToBytes<I>, ) -> Result<u8, FromEmojiError>

impl<I> ConstructFromEmoji<u16, I> for u16

where I: Iterator<Item = u8>,

fn construct_from_emoji( byte_stream: &mut DecodeEmojiToBytes<I>, ) -> Result<u16, FromEmojiError>

impl<I> ConstructFromEmoji<u32, I> for u32

where I: Iterator<Item = u8>,

fn construct_from_emoji( byte_stream: &mut DecodeEmojiToBytes<I>, ) -> Result<u32, FromEmojiError>

impl<I> ConstructFromEmoji<u64, I> for u64

where I: Iterator<Item = u8>,

fn construct_from_emoji( byte_stream: &mut DecodeEmojiToBytes<I>, ) -> Result<u64, FromEmojiError>

impl<I> ConstructFromEmoji<u128, I> for u128

where I: Iterator<Item = u8>,

fn construct_from_emoji( byte_stream: &mut DecodeEmojiToBytes<I>, ) -> Result<u128, FromEmojiError>

impl<I> ConstructFromEmoji<(), I> for ()

where I: Iterator<Item = u8>,

fn construct_from_emoji( _: &mut DecodeEmojiToBytes<I>, ) -> Result<(), FromEmojiError>

impl<I> ConstructFromEmoji<String, I> for String

where I: Iterator<Item = u8>,

fn construct_from_emoji( byte_stream: &mut DecodeEmojiToBytes<I>, ) -> Result<String, FromEmojiError>

impl<I> ConstructFromEmoji<Uuid, I> for Uuid

where I: Iterator<Item = u8>,

fn construct_from_emoji( byte_stream: &mut DecodeEmojiToBytes<I>, ) -> Result<Uuid, FromEmojiError>

impl<I, A> ConstructFromEmoji<Option<A>, I> for Option<A>

where I: Iterator<Item = u8>, A: ConstructFromEmoji<A, I>,

fn construct_from_emoji( byte_stream: &mut DecodeEmojiToBytes<I>, ) -> Result<Option<A>, FromEmojiError>

impl<I, A> ConstructFromEmoji<(A,), I> for (A,)

where I: Iterator<Item = u8>, A: ConstructFromEmoji<A, I>,

fn construct_from_emoji( byte_stream: &mut DecodeEmojiToBytes<I>, ) -> Result<(A,), FromEmojiError>

impl<I, A> ConstructFromEmoji<Vec<A>, I> for Vec<A>

where I: Iterator<Item = u8>, A: ConstructFromEmoji<A, I>,

fn construct_from_emoji( byte_stream: &mut DecodeEmojiToBytes<I>, ) -> Result<Vec<A>, FromEmojiError>

impl<I, A, B> ConstructFromEmoji<Result<A, B>, I> for Result<A, B>

where I: Iterator<Item = u8>, A: ConstructFromEmoji<A, I>, B: ConstructFromEmoji<B, I>,

fn construct_from_emoji( byte_stream: &mut DecodeEmojiToBytes<I>, ) -> Result<Result<A, B>, FromEmojiError>

impl<I, A, const S: usize> ConstructFromEmoji<[A; S], I> for [A; S]

where I: Iterator<Item = u8>, A: ConstructFromEmoji<A, I>,

fn construct_from_emoji( byte_stream: &mut DecodeEmojiToBytes<I>, ) -> Result<[A; S], FromEmojiError>

impl<Iter, A, B> ConstructFromEmoji<(A, B), Iter> for (A, B)

where Iter: Iterator<Item = u8>, A: ConstructFromEmoji<A, Iter>, B: ConstructFromEmoji<B, Iter>,

fn construct_from_emoji( byte_stream: &mut DecodeEmojiToBytes<Iter>, ) -> Result<(A, B), FromEmojiError>

impl<Iter, A, B, C> ConstructFromEmoji<(A, B, C), Iter> for (A, B, C)

where Iter: Iterator<Item = u8>, A: ConstructFromEmoji<A, Iter>, B: ConstructFromEmoji<B, Iter>, C: ConstructFromEmoji<C, Iter>,

fn construct_from_emoji( byte_stream: &mut DecodeEmojiToBytes<Iter>, ) -> Result<(A, B, C), FromEmojiError>

impl<Iter, A, B, C, D> ConstructFromEmoji<(A, B, C, D), Iter> for (A, B, C, D)

where Iter: Iterator<Item = u8>, A: ConstructFromEmoji<A, Iter>, B: ConstructFromEmoji<B, Iter>, C: ConstructFromEmoji<C, Iter>, D: ConstructFromEmoji<D, Iter>,

fn construct_from_emoji( byte_stream: &mut DecodeEmojiToBytes<Iter>, ) -> Result<(A, B, C, D), FromEmojiError>

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

where Iter: Iterator<Item = u8>, A: ConstructFromEmoji<A, Iter>, B: ConstructFromEmoji<B, Iter>, C: ConstructFromEmoji<C, Iter>, D: ConstructFromEmoji<D, Iter>, E: ConstructFromEmoji<E, Iter>,

fn construct_from_emoji( byte_stream: &mut DecodeEmojiToBytes<Iter>, ) -> Result<(A, B, C, D, E), FromEmojiError>

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

where Iter: Iterator<Item = u8>, A: ConstructFromEmoji<A, Iter>, B: ConstructFromEmoji<B, Iter>, C: ConstructFromEmoji<C, Iter>, D: ConstructFromEmoji<D, Iter>, E: ConstructFromEmoji<E, Iter>, F: ConstructFromEmoji<F, Iter>,

fn construct_from_emoji( byte_stream: &mut DecodeEmojiToBytes<Iter>, ) -> Result<(A, B, C, D, E, F), FromEmojiError>

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

where Iter: Iterator<Item = u8>, A: ConstructFromEmoji<A, Iter>, B: ConstructFromEmoji<B, Iter>, C: ConstructFromEmoji<C, Iter>, D: ConstructFromEmoji<D, Iter>, E: ConstructFromEmoji<E, Iter>, F: ConstructFromEmoji<F, Iter>, G: ConstructFromEmoji<G, Iter>,

fn construct_from_emoji( byte_stream: &mut DecodeEmojiToBytes<Iter>, ) -> Result<(A, B, C, D, E, F, G), FromEmojiError>

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

where Iter: Iterator<Item = u8>, A: ConstructFromEmoji<A, Iter>, B: ConstructFromEmoji<B, Iter>, C: ConstructFromEmoji<C, Iter>, D: ConstructFromEmoji<D, Iter>, E: ConstructFromEmoji<E, Iter>, F: ConstructFromEmoji<F, Iter>, G: ConstructFromEmoji<G, Iter>, H: ConstructFromEmoji<H, Iter>,

fn construct_from_emoji( byte_stream: &mut DecodeEmojiToBytes<Iter>, ) -> Result<(A, B, C, D, E, F, G, H), FromEmojiError>

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

where Iter: Iterator<Item = u8>, A: ConstructFromEmoji<A, Iter>, B: ConstructFromEmoji<B, Iter>, C: ConstructFromEmoji<C, Iter>, D: ConstructFromEmoji<D, Iter>, E: ConstructFromEmoji<E, Iter>, F: ConstructFromEmoji<F, Iter>, G: ConstructFromEmoji<G, Iter>, H: ConstructFromEmoji<H, Iter>, I: ConstructFromEmoji<I, Iter>,

fn construct_from_emoji( byte_stream: &mut DecodeEmojiToBytes<Iter>, ) -> Result<(A, B, C, D, E, F, G, H, I), FromEmojiError>

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

where Iter: Iterator<Item = u8>, A: ConstructFromEmoji<A, Iter>, B: ConstructFromEmoji<B, Iter>, C: ConstructFromEmoji<C, Iter>, D: ConstructFromEmoji<D, Iter>, E: ConstructFromEmoji<E, Iter>, F: ConstructFromEmoji<F, Iter>, G: ConstructFromEmoji<G, Iter>, H: ConstructFromEmoji<H, Iter>, I: ConstructFromEmoji<I, Iter>, J: ConstructFromEmoji<J, Iter>,

fn construct_from_emoji( byte_stream: &mut DecodeEmojiToBytes<Iter>, ) -> Result<(A, B, C, D, E, F, G, H, I, J), FromEmojiError>

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

where Iter: Iterator<Item = u8>, A: ConstructFromEmoji<A, Iter>, B: ConstructFromEmoji<B, Iter>, C: ConstructFromEmoji<C, Iter>, D: ConstructFromEmoji<D, Iter>, E: ConstructFromEmoji<E, Iter>, F: ConstructFromEmoji<F, Iter>, G: ConstructFromEmoji<G, Iter>, H: ConstructFromEmoji<H, Iter>, I: ConstructFromEmoji<I, Iter>, J: ConstructFromEmoji<J, Iter>, K: ConstructFromEmoji<K, Iter>,

fn construct_from_emoji( byte_stream: &mut DecodeEmojiToBytes<Iter>, ) -> Result<(A, B, C, D, E, F, G, H, I, J, K), FromEmojiError>

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

where Iter: Iterator<Item = u8>, A: ConstructFromEmoji<A, Iter>, B: ConstructFromEmoji<B, Iter>, C: ConstructFromEmoji<C, Iter>, D: ConstructFromEmoji<D, Iter>, E: ConstructFromEmoji<E, Iter>, F: ConstructFromEmoji<F, Iter>, G: ConstructFromEmoji<G, Iter>, H: ConstructFromEmoji<H, Iter>, I: ConstructFromEmoji<I, Iter>, J: ConstructFromEmoji<J, Iter>, K: ConstructFromEmoji<K, Iter>, L: ConstructFromEmoji<L, Iter>,

fn construct_from_emoji( byte_stream: &mut DecodeEmojiToBytes<Iter>, ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L), FromEmojiError>

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

where Iter: Iterator<Item = u8>, A: ConstructFromEmoji<A, Iter>, B: ConstructFromEmoji<B, Iter>, C: ConstructFromEmoji<C, Iter>, D: ConstructFromEmoji<D, Iter>, E: ConstructFromEmoji<E, Iter>, F: ConstructFromEmoji<F, Iter>, G: ConstructFromEmoji<G, Iter>, H: ConstructFromEmoji<H, Iter>, I: ConstructFromEmoji<I, Iter>, J: ConstructFromEmoji<J, Iter>, K: ConstructFromEmoji<K, Iter>, L: ConstructFromEmoji<L, Iter>, M: ConstructFromEmoji<M, Iter>,

fn construct_from_emoji( byte_stream: &mut DecodeEmojiToBytes<Iter>, ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M), FromEmojiError>

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

where Iter: Iterator<Item = u8>, A: ConstructFromEmoji<A, Iter>, B: ConstructFromEmoji<B, Iter>, C: ConstructFromEmoji<C, Iter>, D: ConstructFromEmoji<D, Iter>, E: ConstructFromEmoji<E, Iter>, F: ConstructFromEmoji<F, Iter>, G: ConstructFromEmoji<G, Iter>, H: ConstructFromEmoji<H, Iter>, I: ConstructFromEmoji<I, Iter>, J: ConstructFromEmoji<J, Iter>, K: ConstructFromEmoji<K, Iter>, L: ConstructFromEmoji<L, Iter>, M: ConstructFromEmoji<M, Iter>, N: ConstructFromEmoji<N, Iter>,

fn construct_from_emoji( byte_stream: &mut DecodeEmojiToBytes<Iter>, ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N), FromEmojiError>

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

where Iter: Iterator<Item = u8>, A: ConstructFromEmoji<A, Iter>, B: ConstructFromEmoji<B, Iter>, C: ConstructFromEmoji<C, Iter>, D: ConstructFromEmoji<D, Iter>, E: ConstructFromEmoji<E, Iter>, F: ConstructFromEmoji<F, Iter>, G: ConstructFromEmoji<G, Iter>, H: ConstructFromEmoji<H, Iter>, I: ConstructFromEmoji<I, Iter>, J: ConstructFromEmoji<J, Iter>, K: ConstructFromEmoji<K, Iter>, L: ConstructFromEmoji<L, Iter>, M: ConstructFromEmoji<M, Iter>, N: ConstructFromEmoji<N, Iter>, O: ConstructFromEmoji<O, Iter>,

fn construct_from_emoji( byte_stream: &mut DecodeEmojiToBytes<Iter>, ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O), FromEmojiError>

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

where Iter: Iterator<Item = u8>, A: ConstructFromEmoji<A, Iter>, B: ConstructFromEmoji<B, Iter>, C: ConstructFromEmoji<C, Iter>, D: ConstructFromEmoji<D, Iter>, E: ConstructFromEmoji<E, Iter>, F: ConstructFromEmoji<F, Iter>, G: ConstructFromEmoji<G, Iter>, H: ConstructFromEmoji<H, Iter>, I: ConstructFromEmoji<I, Iter>, J: ConstructFromEmoji<J, Iter>, K: ConstructFromEmoji<K, Iter>, L: ConstructFromEmoji<L, Iter>, M: ConstructFromEmoji<M, Iter>, N: ConstructFromEmoji<N, Iter>, O: ConstructFromEmoji<O, Iter>, P: ConstructFromEmoji<P, Iter>,

fn construct_from_emoji( byte_stream: &mut DecodeEmojiToBytes<Iter>, ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), FromEmojiError>

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

where Iter: Iterator<Item = u8>, A: ConstructFromEmoji<A, Iter>, B: ConstructFromEmoji<B, Iter>, C: ConstructFromEmoji<C, Iter>, D: ConstructFromEmoji<D, Iter>, E: ConstructFromEmoji<E, Iter>, F: ConstructFromEmoji<F, Iter>, G: ConstructFromEmoji<G, Iter>, H: ConstructFromEmoji<H, Iter>, I: ConstructFromEmoji<I, Iter>, J: ConstructFromEmoji<J, Iter>, K: ConstructFromEmoji<K, Iter>, L: ConstructFromEmoji<L, Iter>, M: ConstructFromEmoji<M, Iter>, N: ConstructFromEmoji<N, Iter>, O: ConstructFromEmoji<O, Iter>, P: ConstructFromEmoji<P, Iter>, Q: ConstructFromEmoji<Q, Iter>,

fn construct_from_emoji( byte_stream: &mut DecodeEmojiToBytes<Iter>, ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q), FromEmojiError>

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

where Iter: Iterator<Item = u8>, A: ConstructFromEmoji<A, Iter>, B: ConstructFromEmoji<B, Iter>, C: ConstructFromEmoji<C, Iter>, D: ConstructFromEmoji<D, Iter>, E: ConstructFromEmoji<E, Iter>, F: ConstructFromEmoji<F, Iter>, G: ConstructFromEmoji<G, Iter>, H: ConstructFromEmoji<H, Iter>, I: ConstructFromEmoji<I, Iter>, J: ConstructFromEmoji<J, Iter>, K: ConstructFromEmoji<K, Iter>, L: ConstructFromEmoji<L, Iter>, M: ConstructFromEmoji<M, Iter>, N: ConstructFromEmoji<N, Iter>, O: ConstructFromEmoji<O, Iter>, P: ConstructFromEmoji<P, Iter>, Q: ConstructFromEmoji<Q, Iter>, R: ConstructFromEmoji<R, Iter>,

fn construct_from_emoji( byte_stream: &mut DecodeEmojiToBytes<Iter>, ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R), FromEmojiError>

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

where Iter: Iterator<Item = u8>, A: ConstructFromEmoji<A, Iter>, B: ConstructFromEmoji<B, Iter>, C: ConstructFromEmoji<C, Iter>, D: ConstructFromEmoji<D, Iter>, E: ConstructFromEmoji<E, Iter>, F: ConstructFromEmoji<F, Iter>, G: ConstructFromEmoji<G, Iter>, H: ConstructFromEmoji<H, Iter>, I: ConstructFromEmoji<I, Iter>, J: ConstructFromEmoji<J, Iter>, K: ConstructFromEmoji<K, Iter>, L: ConstructFromEmoji<L, Iter>, M: ConstructFromEmoji<M, Iter>, N: ConstructFromEmoji<N, Iter>, O: ConstructFromEmoji<O, Iter>, P: ConstructFromEmoji<P, Iter>, Q: ConstructFromEmoji<Q, Iter>, R: ConstructFromEmoji<R, Iter>, S: ConstructFromEmoji<S, Iter>,

fn construct_from_emoji( byte_stream: &mut DecodeEmojiToBytes<Iter>, ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), FromEmojiError>

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

where Iter: Iterator<Item = u8>, A: ConstructFromEmoji<A, Iter>, B: ConstructFromEmoji<B, Iter>, C: ConstructFromEmoji<C, Iter>, D: ConstructFromEmoji<D, Iter>, E: ConstructFromEmoji<E, Iter>, F: ConstructFromEmoji<F, Iter>, G: ConstructFromEmoji<G, Iter>, H: ConstructFromEmoji<H, Iter>, I: ConstructFromEmoji<I, Iter>, J: ConstructFromEmoji<J, Iter>, K: ConstructFromEmoji<K, Iter>, L: ConstructFromEmoji<L, Iter>, M: ConstructFromEmoji<M, Iter>, N: ConstructFromEmoji<N, Iter>, O: ConstructFromEmoji<O, Iter>, P: ConstructFromEmoji<P, Iter>, Q: ConstructFromEmoji<Q, Iter>, R: ConstructFromEmoji<R, Iter>, S: ConstructFromEmoji<S, Iter>, T: ConstructFromEmoji<T, Iter>,

fn construct_from_emoji( byte_stream: &mut DecodeEmojiToBytes<Iter>, ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T), FromEmojiError>

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

where Iter: Iterator<Item = u8>, A: ConstructFromEmoji<A, Iter>, B: ConstructFromEmoji<B, Iter>, C: ConstructFromEmoji<C, Iter>, D: ConstructFromEmoji<D, Iter>, E: ConstructFromEmoji<E, Iter>, F: ConstructFromEmoji<F, Iter>, G: ConstructFromEmoji<G, Iter>, H: ConstructFromEmoji<H, Iter>, I: ConstructFromEmoji<I, Iter>, J: ConstructFromEmoji<J, Iter>, K: ConstructFromEmoji<K, Iter>, L: ConstructFromEmoji<L, Iter>, M: ConstructFromEmoji<M, Iter>, N: ConstructFromEmoji<N, Iter>, O: ConstructFromEmoji<O, Iter>, P: ConstructFromEmoji<P, Iter>, Q: ConstructFromEmoji<Q, Iter>, R: ConstructFromEmoji<R, Iter>, S: ConstructFromEmoji<S, Iter>, T: ConstructFromEmoji<T, Iter>, U: ConstructFromEmoji<U, Iter>,

fn construct_from_emoji( byte_stream: &mut DecodeEmojiToBytes<Iter>, ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U), FromEmojiError>

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

where Iter: Iterator<Item = u8>, A: ConstructFromEmoji<A, Iter>, B: ConstructFromEmoji<B, Iter>, C: ConstructFromEmoji<C, Iter>, D: ConstructFromEmoji<D, Iter>, E: ConstructFromEmoji<E, Iter>, F: ConstructFromEmoji<F, Iter>, G: ConstructFromEmoji<G, Iter>, H: ConstructFromEmoji<H, Iter>, I: ConstructFromEmoji<I, Iter>, J: ConstructFromEmoji<J, Iter>, K: ConstructFromEmoji<K, Iter>, L: ConstructFromEmoji<L, Iter>, M: ConstructFromEmoji<M, Iter>, N: ConstructFromEmoji<N, Iter>, O: ConstructFromEmoji<O, Iter>, P: ConstructFromEmoji<P, Iter>, Q: ConstructFromEmoji<Q, Iter>, R: ConstructFromEmoji<R, Iter>, S: ConstructFromEmoji<S, Iter>, T: ConstructFromEmoji<T, Iter>, U: ConstructFromEmoji<U, Iter>, V: ConstructFromEmoji<V, Iter>,

fn construct_from_emoji( byte_stream: &mut DecodeEmojiToBytes<Iter>, ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V), FromEmojiError>

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

where Iter: Iterator<Item = u8>, A: ConstructFromEmoji<A, Iter>, B: ConstructFromEmoji<B, Iter>, C: ConstructFromEmoji<C, Iter>, D: ConstructFromEmoji<D, Iter>, E: ConstructFromEmoji<E, Iter>, F: ConstructFromEmoji<F, Iter>, G: ConstructFromEmoji<G, Iter>, H: ConstructFromEmoji<H, Iter>, I: ConstructFromEmoji<I, Iter>, J: ConstructFromEmoji<J, Iter>, K: ConstructFromEmoji<K, Iter>, L: ConstructFromEmoji<L, Iter>, M: ConstructFromEmoji<M, Iter>, N: ConstructFromEmoji<N, Iter>, O: ConstructFromEmoji<O, Iter>, P: ConstructFromEmoji<P, Iter>, Q: ConstructFromEmoji<Q, Iter>, R: ConstructFromEmoji<R, Iter>, S: ConstructFromEmoji<S, Iter>, T: ConstructFromEmoji<T, Iter>, U: ConstructFromEmoji<U, Iter>, V: ConstructFromEmoji<V, Iter>, W: ConstructFromEmoji<W, Iter>,

fn construct_from_emoji( byte_stream: &mut DecodeEmojiToBytes<Iter>, ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W), FromEmojiError>

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

where Iter: Iterator<Item = u8>, A: ConstructFromEmoji<A, Iter>, B: ConstructFromEmoji<B, Iter>, C: ConstructFromEmoji<C, Iter>, D: ConstructFromEmoji<D, Iter>, E: ConstructFromEmoji<E, Iter>, F: ConstructFromEmoji<F, Iter>, G: ConstructFromEmoji<G, Iter>, H: ConstructFromEmoji<H, Iter>, I: ConstructFromEmoji<I, Iter>, J: ConstructFromEmoji<J, Iter>, K: ConstructFromEmoji<K, Iter>, L: ConstructFromEmoji<L, Iter>, M: ConstructFromEmoji<M, Iter>, N: ConstructFromEmoji<N, Iter>, O: ConstructFromEmoji<O, Iter>, P: ConstructFromEmoji<P, Iter>, Q: ConstructFromEmoji<Q, Iter>, R: ConstructFromEmoji<R, Iter>, S: ConstructFromEmoji<S, Iter>, T: ConstructFromEmoji<T, Iter>, U: ConstructFromEmoji<U, Iter>, V: ConstructFromEmoji<V, Iter>, W: ConstructFromEmoji<W, Iter>, X: ConstructFromEmoji<X, Iter>,

fn construct_from_emoji( byte_stream: &mut DecodeEmojiToBytes<Iter>, ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X), FromEmojiError>

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

where Iter: Iterator<Item = u8>, A: ConstructFromEmoji<A, Iter>, B: ConstructFromEmoji<B, Iter>, C: ConstructFromEmoji<C, Iter>, D: ConstructFromEmoji<D, Iter>, E: ConstructFromEmoji<E, Iter>, F: ConstructFromEmoji<F, Iter>, G: ConstructFromEmoji<G, Iter>, H: ConstructFromEmoji<H, Iter>, I: ConstructFromEmoji<I, Iter>, J: ConstructFromEmoji<J, Iter>, K: ConstructFromEmoji<K, Iter>, L: ConstructFromEmoji<L, Iter>, M: ConstructFromEmoji<M, Iter>, N: ConstructFromEmoji<N, Iter>, O: ConstructFromEmoji<O, Iter>, P: ConstructFromEmoji<P, Iter>, Q: ConstructFromEmoji<Q, Iter>, R: ConstructFromEmoji<R, Iter>, S: ConstructFromEmoji<S, Iter>, T: ConstructFromEmoji<T, Iter>, U: ConstructFromEmoji<U, Iter>, V: ConstructFromEmoji<V, Iter>, W: ConstructFromEmoji<W, Iter>, X: ConstructFromEmoji<X, Iter>, Y: ConstructFromEmoji<Y, Iter>,

fn construct_from_emoji( byte_stream: &mut DecodeEmojiToBytes<Iter>, ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y), FromEmojiError>

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

where Iter: Iterator<Item = u8>, A: ConstructFromEmoji<A, Iter>, B: ConstructFromEmoji<B, Iter>, C: ConstructFromEmoji<C, Iter>, D: ConstructFromEmoji<D, Iter>, E: ConstructFromEmoji<E, Iter>, F: ConstructFromEmoji<F, Iter>, G: ConstructFromEmoji<G, Iter>, H: ConstructFromEmoji<H, Iter>, I: ConstructFromEmoji<I, Iter>, J: ConstructFromEmoji<J, Iter>, K: ConstructFromEmoji<K, Iter>, L: ConstructFromEmoji<L, Iter>, M: ConstructFromEmoji<M, Iter>, N: ConstructFromEmoji<N, Iter>, O: ConstructFromEmoji<O, Iter>, P: ConstructFromEmoji<P, Iter>, Q: ConstructFromEmoji<Q, Iter>, R: ConstructFromEmoji<R, Iter>, S: ConstructFromEmoji<S, Iter>, T: ConstructFromEmoji<T, Iter>, U: ConstructFromEmoji<U, Iter>, V: ConstructFromEmoji<V, Iter>, W: ConstructFromEmoji<W, Iter>, X: ConstructFromEmoji<X, Iter>, Y: ConstructFromEmoji<Y, Iter>, Z: ConstructFromEmoji<Z, Iter>,

fn construct_from_emoji( byte_stream: &mut DecodeEmojiToBytes<Iter>, ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), FromEmojiError>

Implementors