Struct Be

pub struct Be<T>(pub T);

Type wrapper for big endian bytes value

Tuple Fields

0: T

Trait Implementations

impl<T: Clone> Clone for Be<T>

fn clone(&self) -> Be<T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for Be<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: FromBeBytes<N>, const N: usize> From<[u8; N]> for Be<T>

Any type that implemented FromBeBytes can be converted to Be wrapper

fn from(data: [u8; N]) -> Self

Converts to this type from the input type.

impl<A> From<(Be<A>,)> for Be<(A,)>

fn from((Be): (Be<A>,)) -> Self

Converts to this type from the input type.

impl<A, B> From<(Be<A>, Be<B>)> for Be<(A, B)>

fn from((Be, Be): (Be<A>, Be<B>)) -> Self

Converts to this type from the input type.

impl<A, B, C> From<(Be<A>, Be<B>, Be<C>)> for Be<(A, B, C)>

fn from((Be, Be, Be): (Be<A>, Be<B>, Be<C>)) -> Self

Converts to this type from the input type.

impl<A, B, C, D> From<(Be<A>, Be<B>, Be<C>, Be<D>)> for Be<(A, B, C, D)>

fn from((Be, Be, Be, Be): (Be<A>, Be<B>, Be<C>, Be<D>)) -> Self

Converts to this type from the input type.

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

fn from((Be, Be, Be, Be, Be): (Be<A>, Be<B>, Be<C>, Be<D>, Be<E>)) -> Self

Converts to this type from the input type.

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

fn from( (Be, Be, Be, Be, Be, Be): (Be<A>, Be<B>, Be<C>, Be<D>, Be<E>, Be<F>), ) -> Self

Converts to this type from the input type.

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

fn from( (Be, Be, Be, Be, Be, Be, Be): (Be<A>, Be<B>, Be<C>, Be<D>, Be<E>, Be<F>, Be<G>), ) -> Self

Converts to this type from the input type.

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

fn from( (Be, Be, Be, Be, Be, Be, Be, Be): (Be<A>, Be<B>, Be<C>, Be<D>, Be<E>, Be<F>, Be<G>, Be<H>), ) -> Self

Converts to this type from the input type.

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

fn from( (Be, Be, Be, Be, Be, Be, Be, Be, Be): (Be<A>, Be<B>, Be<C>, Be<D>, Be<E>, Be<F>, Be<G>, Be<H>, Be<I>), ) -> Self

Converts to this type from the input type.

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

fn from( (Be, Be, Be, Be, Be, Be, Be, Be, Be, Be): (Be<A>, Be<B>, Be<C>, Be<D>, Be<E>, Be<F>, Be<G>, Be<H>, Be<I>, Be<J>), ) -> Self

Converts to this type from the input type.

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

fn from( (Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be): (Be<A>, Be<B>, Be<C>, Be<D>, Be<E>, Be<F>, Be<G>, Be<H>, Be<I>, Be<J>, Be<K>), ) -> Self

Converts to this type from the input type.

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

fn from( (Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be): (Be<A>, Be<B>, Be<C>, Be<D>, Be<E>, Be<F>, Be<G>, Be<H>, Be<I>, Be<J>, Be<K>, Be<L>), ) -> Self

Converts to this type from the input type.

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

fn from( (Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be): (Be<A>, Be<B>, Be<C>, Be<D>, Be<E>, Be<F>, Be<G>, Be<H>, Be<I>, Be<J>, Be<K>, Be<L>, Be<M>), ) -> Self

Converts to this type from the input type.

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

fn from( (Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be): (Be<A>, Be<B>, Be<C>, Be<D>, Be<E>, Be<F>, Be<G>, Be<H>, Be<I>, Be<J>, Be<K>, Be<L>, Be<M>, Be<N>), ) -> Self

Converts to this type from the input type.

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

fn from( (Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be): (Be<A>, Be<B>, Be<C>, Be<D>, Be<E>, Be<F>, Be<G>, Be<H>, Be<I>, Be<J>, Be<K>, Be<L>, Be<M>, Be<N>, Be<O>), ) -> Self

Converts to this type from the input type.

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

fn from( (Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be): (Be<A>, Be<B>, Be<C>, Be<D>, Be<E>, Be<F>, Be<G>, Be<H>, Be<I>, Be<J>, Be<K>, Be<L>, Be<M>, Be<N>, Be<O>, Be<P>), ) -> Self

Converts to this type from the input type.

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

fn from( (Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be): (Be<A>, Be<B>, Be<C>, Be<D>, Be<E>, Be<F>, Be<G>, Be<H>, Be<I>, Be<J>, Be<K>, Be<L>, Be<M>, Be<N>, Be<O>, Be<P>, Be<Q>), ) -> Self

Converts to this type from the input type.

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

fn from( (Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be): (Be<A>, Be<B>, Be<C>, Be<D>, Be<E>, Be<F>, Be<G>, Be<H>, Be<I>, Be<J>, Be<K>, Be<L>, Be<M>, Be<N>, Be<O>, Be<P>, Be<Q>, Be<R>), ) -> Self

Converts to this type from the input type.

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

fn from( (Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be): (Be<A>, Be<B>, Be<C>, Be<D>, Be<E>, Be<F>, Be<G>, Be<H>, Be<I>, Be<J>, Be<K>, Be<L>, Be<M>, Be<N>, Be<O>, Be<P>, Be<Q>, Be<R>, Be<S>), ) -> Self

Converts to this type from the input type.

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

fn from( (Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be): (Be<A>, Be<B>, Be<C>, Be<D>, Be<E>, Be<F>, Be<G>, Be<H>, Be<I>, Be<J>, Be<K>, Be<L>, Be<M>, Be<N>, Be<O>, Be<P>, Be<Q>, Be<R>, Be<S>, Be<T>), ) -> Self

Converts to this type from the input type.

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

fn from( (Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be): (Be<A>, Be<B>, Be<C>, Be<D>, Be<E>, Be<F>, Be<G>, Be<H>, Be<I>, Be<J>, Be<K>, Be<L>, Be<M>, Be<N>, Be<O>, Be<P>, Be<Q>, Be<R>, Be<S>, Be<T>, Be<U>), ) -> Self

Converts to this type from the input type.

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

fn from( (Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be): (Be<A>, Be<B>, Be<C>, Be<D>, Be<E>, Be<F>, Be<G>, Be<H>, Be<I>, Be<J>, Be<K>, Be<L>, Be<M>, Be<N>, Be<O>, Be<P>, Be<Q>, Be<R>, Be<S>, Be<T>, Be<U>, Be<V>), ) -> Self

Converts to this type from the input type.

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

fn from( (Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be): (Be<A>, Be<B>, Be<C>, Be<D>, Be<E>, Be<F>, Be<G>, Be<H>, Be<I>, Be<J>, Be<K>, Be<L>, Be<M>, Be<N>, Be<O>, Be<P>, Be<Q>, Be<R>, Be<S>, Be<T>, Be<U>, Be<V>, Be<W>), ) -> Self

Converts to this type from the input type.

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

fn from( (Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be): (Be<A>, Be<B>, Be<C>, Be<D>, Be<E>, Be<F>, Be<G>, Be<H>, Be<I>, Be<J>, Be<K>, Be<L>, Be<M>, Be<N>, Be<O>, Be<P>, Be<Q>, Be<R>, Be<S>, Be<T>, Be<U>, Be<V>, Be<W>, Be<X>), ) -> Self

Converts to this type from the input type.

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y> From<(Be<A>, Be<B>, Be<C>, Be<D>, Be<E>, Be<F>, Be<G>, Be<H>, Be<I>, Be<J>, Be<K>, Be<L>, Be<M>, Be<N>, Be<O>, Be<P>, Be<Q>, Be<R>, Be<S>, Be<T>, Be<U>, Be<V>, Be<W>, Be<X>, Be<Y>)> for Be<(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)>

fn from( (Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be): (Be<A>, Be<B>, Be<C>, Be<D>, Be<E>, Be<F>, Be<G>, Be<H>, Be<I>, Be<J>, Be<K>, Be<L>, Be<M>, Be<N>, Be<O>, Be<P>, Be<Q>, Be<R>, Be<S>, Be<T>, Be<U>, Be<V>, Be<W>, Be<X>, Be<Y>), ) -> Self

Converts to this type from the input type.

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> From<(Be<A>, Be<B>, Be<C>, Be<D>, Be<E>, Be<F>, Be<G>, Be<H>, Be<I>, Be<J>, Be<K>, Be<L>, Be<M>, Be<N>, Be<O>, Be<P>, Be<Q>, Be<R>, Be<S>, Be<T>, Be<U>, Be<V>, Be<W>, Be<X>, Be<Y>, Be<Z>)> for Be<(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)>

fn from( (Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be, Be): (Be<A>, Be<B>, Be<C>, Be<D>, Be<E>, Be<F>, Be<G>, Be<H>, Be<I>, Be<J>, Be<K>, Be<L>, Be<M>, Be<N>, Be<O>, Be<P>, Be<Q>, Be<R>, Be<S>, Be<T>, Be<U>, Be<V>, Be<W>, Be<X>, Be<Y>, Be<Z>), ) -> Self

Converts to this type from the input type.

impl<TY, A, const NU: usize, const AN: usize> From<P1<[TY; NU], AN>> for Be<(A,)>

where TY: Copy + Default, Be<A>: From<[TY; AN]>,

fn from(data: P1<[TY; NU], AN>) -> Self

Converts to this type from the input type.

impl<TY, A, B, C, D, E, F, G, H, I, J, const NU: usize, const AN: usize, const BN: usize, const CN: usize, const DN: usize, const EN: usize, const FN: usize, const GN: usize, const HN: usize, const IN: usize, const JN: usize> From<P10<[TY; NU], AN, BN, CN, DN, EN, FN, GN, HN, IN, JN>> for Be<(A, B, C, D, E, F, G, H, I, J)>

where TY: Copy + Default, Be<A>: From<[TY; AN]>, Be<B>: From<[TY; BN]>, Be<C>: From<[TY; CN]>, Be<D>: From<[TY; DN]>, Be<E>: From<[TY; EN]>, Be<F>: From<[TY; FN]>, Be<G>: From<[TY; GN]>, Be<H>: From<[TY; HN]>, Be<I>: From<[TY; IN]>, Be<J>: From<[TY; JN]>,

fn from(data: P10<[TY; NU], AN, BN, CN, DN, EN, FN, GN, HN, IN, JN>) -> Self

Converts to this type from the input type.

impl<TY, A, B, C, D, E, F, G, H, I, J, K, const NU: usize, const AN: usize, const BN: usize, const CN: usize, const DN: usize, const EN: usize, const FN: usize, const GN: usize, const HN: usize, const IN: usize, const JN: usize, const KN: usize> From<P11<[TY; NU], AN, BN, CN, DN, EN, FN, GN, HN, IN, JN, KN>> for Be<(A, B, C, D, E, F, G, H, I, J, K)>

where TY: Copy + Default, Be<A>: From<[TY; AN]>, Be<B>: From<[TY; BN]>, Be<C>: From<[TY; CN]>, Be<D>: From<[TY; DN]>, Be<E>: From<[TY; EN]>, Be<F>: From<[TY; FN]>, Be<G>: From<[TY; GN]>, Be<H>: From<[TY; HN]>, Be<I>: From<[TY; IN]>, Be<J>: From<[TY; JN]>, Be<K>: From<[TY; KN]>,

fn from(data: P11<[TY; NU], AN, BN, CN, DN, EN, FN, GN, HN, IN, JN, KN>) -> Self

Converts to this type from the input type.

impl<TY, A, B, C, D, E, F, G, H, I, J, K, L, const NU: usize, const AN: usize, const BN: usize, const CN: usize, const DN: usize, const EN: usize, const FN: usize, const GN: usize, const HN: usize, const IN: usize, const JN: usize, const KN: usize, const LN: usize> From<P12<[TY; NU], AN, BN, CN, DN, EN, FN, GN, HN, IN, JN, KN, LN>> for Be<(A, B, C, D, E, F, G, H, I, J, K, L)>

where TY: Copy + Default, Be<A>: From<[TY; AN]>, Be<B>: From<[TY; BN]>, Be<C>: From<[TY; CN]>, Be<D>: From<[TY; DN]>, Be<E>: From<[TY; EN]>, Be<F>: From<[TY; FN]>, Be<G>: From<[TY; GN]>, Be<H>: From<[TY; HN]>, Be<I>: From<[TY; IN]>, Be<J>: From<[TY; JN]>, Be<K>: From<[TY; KN]>, Be<L>: From<[TY; LN]>,

fn from( data: P12<[TY; NU], AN, BN, CN, DN, EN, FN, GN, HN, IN, JN, KN, LN>, ) -> Self

Converts to this type from the input type.

impl<TY, A, B, C, D, E, F, G, H, I, J, K, L, M, const NU: usize, const AN: usize, const BN: usize, const CN: usize, const DN: usize, const EN: usize, const FN: usize, const GN: usize, const HN: usize, const IN: usize, const JN: usize, const KN: usize, const LN: usize, const MN: usize> From<P13<[TY; NU], AN, BN, CN, DN, EN, FN, GN, HN, IN, JN, KN, LN, MN>> for Be<(A, B, C, D, E, F, G, H, I, J, K, L, M)>

where TY: Copy + Default, Be<A>: From<[TY; AN]>, Be<B>: From<[TY; BN]>, Be<C>: From<[TY; CN]>, Be<D>: From<[TY; DN]>, Be<E>: From<[TY; EN]>, Be<F>: From<[TY; FN]>, Be<G>: From<[TY; GN]>, Be<H>: From<[TY; HN]>, Be<I>: From<[TY; IN]>, Be<J>: From<[TY; JN]>, Be<K>: From<[TY; KN]>, Be<L>: From<[TY; LN]>, Be<M>: From<[TY; MN]>,

fn from( data: P13<[TY; NU], AN, BN, CN, DN, EN, FN, GN, HN, IN, JN, KN, LN, MN>, ) -> Self

Converts to this type from the input type.

impl<TY, A, B, C, D, E, F, G, H, I, J, K, L, M, N, const NU: usize, const AN: usize, const BN: usize, const CN: usize, const DN: usize, const EN: usize, const FN: usize, const GN: usize, const HN: usize, const IN: usize, const JN: usize, const KN: usize, const LN: usize, const MN: usize, const NN: usize> From<P14<[TY; NU], AN, BN, CN, DN, EN, FN, GN, HN, IN, JN, KN, LN, MN, NN>> for Be<(A, B, C, D, E, F, G, H, I, J, K, L, M, N)>

where TY: Copy + Default, Be<A>: From<[TY; AN]>, Be<B>: From<[TY; BN]>, Be<C>: From<[TY; CN]>, Be<D>: From<[TY; DN]>, Be<E>: From<[TY; EN]>, Be<F>: From<[TY; FN]>, Be<G>: From<[TY; GN]>, Be<H>: From<[TY; HN]>, Be<I>: From<[TY; IN]>, Be<J>: From<[TY; JN]>, Be<K>: From<[TY; KN]>, Be<L>: From<[TY; LN]>, Be<M>: From<[TY; MN]>, Be<N>: From<[TY; NN]>,

fn from( data: P14<[TY; NU], AN, BN, CN, DN, EN, FN, GN, HN, IN, JN, KN, LN, MN, NN>, ) -> Self

Converts to this type from the input type.

impl<TY, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, const NU: usize, const AN: usize, const BN: usize, const CN: usize, const DN: usize, const EN: usize, const FN: usize, const GN: usize, const HN: usize, const IN: usize, const JN: usize, const KN: usize, const LN: usize, const MN: usize, const NN: usize, const ON: usize> From<P15<[TY; NU], AN, BN, CN, DN, EN, FN, GN, HN, IN, JN, KN, LN, MN, NN, ON>> for Be<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)>

where TY: Copy + Default, Be<A>: From<[TY; AN]>, Be<B>: From<[TY; BN]>, Be<C>: From<[TY; CN]>, Be<D>: From<[TY; DN]>, Be<E>: From<[TY; EN]>, Be<F>: From<[TY; FN]>, Be<G>: From<[TY; GN]>, Be<H>: From<[TY; HN]>, Be<I>: From<[TY; IN]>, Be<J>: From<[TY; JN]>, Be<K>: From<[TY; KN]>, Be<L>: From<[TY; LN]>, Be<M>: From<[TY; MN]>, Be<N>: From<[TY; NN]>, Be<O>: From<[TY; ON]>,

fn from( data: P15<[TY; NU], AN, BN, CN, DN, EN, FN, GN, HN, IN, JN, KN, LN, MN, NN, ON>, ) -> Self

Converts to this type from the input type.

impl<TY, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, const NU: usize, const AN: usize, const BN: usize, const CN: usize, const DN: usize, const EN: usize, const FN: usize, const GN: usize, const HN: usize, const IN: usize, const JN: usize, const KN: usize, const LN: usize, const MN: usize, const NN: usize, const ON: usize, const PN: usize> From<P16<[TY; NU], AN, BN, CN, DN, EN, FN, GN, HN, IN, JN, KN, LN, MN, NN, ON, PN>> for Be<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)>

where TY: Copy + Default, Be<A>: From<[TY; AN]>, Be<B>: From<[TY; BN]>, Be<C>: From<[TY; CN]>, Be<D>: From<[TY; DN]>, Be<E>: From<[TY; EN]>, Be<F>: From<[TY; FN]>, Be<G>: From<[TY; GN]>, Be<H>: From<[TY; HN]>, Be<I>: From<[TY; IN]>, Be<J>: From<[TY; JN]>, Be<K>: From<[TY; KN]>, Be<L>: From<[TY; LN]>, Be<M>: From<[TY; MN]>, Be<N>: From<[TY; NN]>, Be<O>: From<[TY; ON]>, Be<P>: From<[TY; PN]>,

fn from( data: P16<[TY; NU], AN, BN, CN, DN, EN, FN, GN, HN, IN, JN, KN, LN, MN, NN, ON, PN>, ) -> Self

Converts to this type from the input type.

impl<TY, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, const NU: usize, const AN: usize, const BN: usize, const CN: usize, const DN: usize, const EN: usize, const FN: usize, const GN: usize, const HN: usize, const IN: usize, const JN: usize, const KN: usize, const LN: usize, const MN: usize, const NN: usize, const ON: usize, const PN: usize, const QN: usize> From<P17<[TY; NU], AN, BN, CN, DN, EN, FN, GN, HN, IN, JN, KN, LN, MN, NN, ON, PN, QN>> for Be<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)>

where TY: Copy + Default, Be<A>: From<[TY; AN]>, Be<B>: From<[TY; BN]>, Be<C>: From<[TY; CN]>, Be<D>: From<[TY; DN]>, Be<E>: From<[TY; EN]>, Be<F>: From<[TY; FN]>, Be<G>: From<[TY; GN]>, Be<H>: From<[TY; HN]>, Be<I>: From<[TY; IN]>, Be<J>: From<[TY; JN]>, Be<K>: From<[TY; KN]>, Be<L>: From<[TY; LN]>, Be<M>: From<[TY; MN]>, Be<N>: From<[TY; NN]>, Be<O>: From<[TY; ON]>, Be<P>: From<[TY; PN]>, Be<Q>: From<[TY; QN]>,

fn from( data: P17<[TY; NU], AN, BN, CN, DN, EN, FN, GN, HN, IN, JN, KN, LN, MN, NN, ON, PN, QN>, ) -> Self

Converts to this type from the input type.

impl<TY, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, const NU: usize, const AN: usize, const BN: usize, const CN: usize, const DN: usize, const EN: usize, const FN: usize, const GN: usize, const HN: usize, const IN: usize, const JN: usize, const KN: usize, const LN: usize, const MN: usize, const NN: usize, const ON: usize, const PN: usize, const QN: usize, const RN: usize> From<P18<[TY; NU], AN, BN, CN, DN, EN, FN, GN, HN, IN, JN, KN, LN, MN, NN, ON, PN, QN, RN>> for Be<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)>

where TY: Copy + Default, Be<A>: From<[TY; AN]>, Be<B>: From<[TY; BN]>, Be<C>: From<[TY; CN]>, Be<D>: From<[TY; DN]>, Be<E>: From<[TY; EN]>, Be<F>: From<[TY; FN]>, Be<G>: From<[TY; GN]>, Be<H>: From<[TY; HN]>, Be<I>: From<[TY; IN]>, Be<J>: From<[TY; JN]>, Be<K>: From<[TY; KN]>, Be<L>: From<[TY; LN]>, Be<M>: From<[TY; MN]>, Be<N>: From<[TY; NN]>, Be<O>: From<[TY; ON]>, Be<P>: From<[TY; PN]>, Be<Q>: From<[TY; QN]>, Be<R>: From<[TY; RN]>,

fn from( data: P18<[TY; NU], AN, BN, CN, DN, EN, FN, GN, HN, IN, JN, KN, LN, MN, NN, ON, PN, QN, RN>, ) -> Self

Converts to this type from the input type.

impl<TY, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, const NU: usize, const AN: usize, const BN: usize, const CN: usize, const DN: usize, const EN: usize, const FN: usize, const GN: usize, const HN: usize, const IN: usize, const JN: usize, const KN: usize, const LN: usize, const MN: usize, const NN: usize, const ON: usize, const PN: usize, const QN: usize, const RN: usize, const SN: usize> From<P19<[TY; NU], AN, BN, CN, DN, EN, FN, GN, HN, IN, JN, KN, LN, MN, NN, ON, PN, QN, RN, SN>> for Be<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)>

where TY: Copy + Default, Be<A>: From<[TY; AN]>, Be<B>: From<[TY; BN]>, Be<C>: From<[TY; CN]>, Be<D>: From<[TY; DN]>, Be<E>: From<[TY; EN]>, Be<F>: From<[TY; FN]>, Be<G>: From<[TY; GN]>, Be<H>: From<[TY; HN]>, Be<I>: From<[TY; IN]>, Be<J>: From<[TY; JN]>, Be<K>: From<[TY; KN]>, Be<L>: From<[TY; LN]>, Be<M>: From<[TY; MN]>, Be<N>: From<[TY; NN]>, Be<O>: From<[TY; ON]>, Be<P>: From<[TY; PN]>, Be<Q>: From<[TY; QN]>, Be<R>: From<[TY; RN]>, Be<S>: From<[TY; SN]>,

fn from( data: P19<[TY; NU], AN, BN, CN, DN, EN, FN, GN, HN, IN, JN, KN, LN, MN, NN, ON, PN, QN, RN, SN>, ) -> Self

Converts to this type from the input type.

impl<TY, A, B, const NU: usize, const AN: usize, const BN: usize> From<P2<[TY; NU], AN, BN>> for Be<(A, B)>

where TY: Copy + Default, Be<A>: From<[TY; AN]>, Be<B>: From<[TY; BN]>,

fn from(data: P2<[TY; NU], AN, BN>) -> Self

Converts to this type from the input type.

impl<TY, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, const NU: usize, const AN: usize, const BN: usize, const CN: usize, const DN: usize, const EN: usize, const FN: usize, const GN: usize, const HN: usize, const IN: usize, const JN: usize, const KN: usize, const LN: usize, const MN: usize, const NN: usize, const ON: usize, const PN: usize, const QN: usize, const RN: usize, const SN: usize, const TN: usize> From<P20<[TY; NU], AN, BN, CN, DN, EN, FN, GN, HN, IN, JN, KN, LN, MN, NN, ON, PN, QN, RN, SN, TN>> for Be<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)>

where TY: Copy + Default, Be<A>: From<[TY; AN]>, Be<B>: From<[TY; BN]>, Be<C>: From<[TY; CN]>, Be<D>: From<[TY; DN]>, Be<E>: From<[TY; EN]>, Be<F>: From<[TY; FN]>, Be<G>: From<[TY; GN]>, Be<H>: From<[TY; HN]>, Be<I>: From<[TY; IN]>, Be<J>: From<[TY; JN]>, Be<K>: From<[TY; KN]>, Be<L>: From<[TY; LN]>, Be<M>: From<[TY; MN]>, Be<N>: From<[TY; NN]>, Be<O>: From<[TY; ON]>, Be<P>: From<[TY; PN]>, Be<Q>: From<[TY; QN]>, Be<R>: From<[TY; RN]>, Be<S>: From<[TY; SN]>, Be<T>: From<[TY; TN]>,

fn from( data: P20<[TY; NU], AN, BN, CN, DN, EN, FN, GN, HN, IN, JN, KN, LN, MN, NN, ON, PN, QN, RN, SN, TN>, ) -> Self

Converts to this type from the input type.

impl<TY, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, const NU: usize, const AN: usize, const BN: usize, const CN: usize, const DN: usize, const EN: usize, const FN: usize, const GN: usize, const HN: usize, const IN: usize, const JN: usize, const KN: usize, const LN: usize, const MN: usize, const NN: usize, const ON: usize, const PN: usize, const QN: usize, const RN: usize, const SN: usize, const TN: usize, const UN: usize> From<P21<[TY; NU], AN, BN, CN, DN, EN, FN, GN, HN, IN, JN, KN, LN, MN, NN, ON, PN, QN, RN, SN, TN, UN>> for Be<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)>

where TY: Copy + Default, Be<A>: From<[TY; AN]>, Be<B>: From<[TY; BN]>, Be<C>: From<[TY; CN]>, Be<D>: From<[TY; DN]>, Be<E>: From<[TY; EN]>, Be<F>: From<[TY; FN]>, Be<G>: From<[TY; GN]>, Be<H>: From<[TY; HN]>, Be<I>: From<[TY; IN]>, Be<J>: From<[TY; JN]>, Be<K>: From<[TY; KN]>, Be<L>: From<[TY; LN]>, Be<M>: From<[TY; MN]>, Be<N>: From<[TY; NN]>, Be<O>: From<[TY; ON]>, Be<P>: From<[TY; PN]>, Be<Q>: From<[TY; QN]>, Be<R>: From<[TY; RN]>, Be<S>: From<[TY; SN]>, Be<T>: From<[TY; TN]>, Be<U>: From<[TY; UN]>,

fn from( data: P21<[TY; NU], AN, BN, CN, DN, EN, FN, GN, HN, IN, JN, KN, LN, MN, NN, ON, PN, QN, RN, SN, TN, UN>, ) -> Self

Converts to this type from the input type.

impl<TY, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, const NU: usize, const AN: usize, const BN: usize, const CN: usize, const DN: usize, const EN: usize, const FN: usize, const GN: usize, const HN: usize, const IN: usize, const JN: usize, const KN: usize, const LN: usize, const MN: usize, const NN: usize, const ON: usize, const PN: usize, const QN: usize, const RN: usize, const SN: usize, const TN: usize, const UN: usize, const VN: usize> From<P22<[TY; NU], AN, BN, CN, DN, EN, FN, GN, HN, IN, JN, KN, LN, MN, NN, ON, PN, QN, RN, SN, TN, UN, VN>> for Be<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)>

where TY: Copy + Default, Be<A>: From<[TY; AN]>, Be<B>: From<[TY; BN]>, Be<C>: From<[TY; CN]>, Be<D>: From<[TY; DN]>, Be<E>: From<[TY; EN]>, Be<F>: From<[TY; FN]>, Be<G>: From<[TY; GN]>, Be<H>: From<[TY; HN]>, Be<I>: From<[TY; IN]>, Be<J>: From<[TY; JN]>, Be<K>: From<[TY; KN]>, Be<L>: From<[TY; LN]>, Be<M>: From<[TY; MN]>, Be<N>: From<[TY; NN]>, Be<O>: From<[TY; ON]>, Be<P>: From<[TY; PN]>, Be<Q>: From<[TY; QN]>, Be<R>: From<[TY; RN]>, Be<S>: From<[TY; SN]>, Be<T>: From<[TY; TN]>, Be<U>: From<[TY; UN]>, Be<V>: From<[TY; VN]>,

fn from( data: P22<[TY; NU], AN, BN, CN, DN, EN, FN, GN, HN, IN, JN, KN, LN, MN, NN, ON, PN, QN, RN, SN, TN, UN, VN>, ) -> Self

Converts to this type from the input type.

impl<TY, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, const NU: usize, const AN: usize, const BN: usize, const CN: usize, const DN: usize, const EN: usize, const FN: usize, const GN: usize, const HN: usize, const IN: usize, const JN: usize, const KN: usize, const LN: usize, const MN: usize, const NN: usize, const ON: usize, const PN: usize, const QN: usize, const RN: usize, const SN: usize, const TN: usize, const UN: usize, const VN: usize, const WN: usize> From<P23<[TY; NU], AN, BN, CN, DN, EN, FN, GN, HN, IN, JN, KN, LN, MN, NN, ON, PN, QN, RN, SN, TN, UN, VN, WN>> for Be<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)>

where TY: Copy + Default, Be<A>: From<[TY; AN]>, Be<B>: From<[TY; BN]>, Be<C>: From<[TY; CN]>, Be<D>: From<[TY; DN]>, Be<E>: From<[TY; EN]>, Be<F>: From<[TY; FN]>, Be<G>: From<[TY; GN]>, Be<H>: From<[TY; HN]>, Be<I>: From<[TY; IN]>, Be<J>: From<[TY; JN]>, Be<K>: From<[TY; KN]>, Be<L>: From<[TY; LN]>, Be<M>: From<[TY; MN]>, Be<N>: From<[TY; NN]>, Be<O>: From<[TY; ON]>, Be<P>: From<[TY; PN]>, Be<Q>: From<[TY; QN]>, Be<R>: From<[TY; RN]>, Be<S>: From<[TY; SN]>, Be<T>: From<[TY; TN]>, Be<U>: From<[TY; UN]>, Be<V>: From<[TY; VN]>, Be<W>: From<[TY; WN]>,

fn from( data: P23<[TY; NU], AN, BN, CN, DN, EN, FN, GN, HN, IN, JN, KN, LN, MN, NN, ON, PN, QN, RN, SN, TN, UN, VN, WN>, ) -> Self

Converts to this type from the input type.

impl<TY, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, const NU: usize, const AN: usize, const BN: usize, const CN: usize, const DN: usize, const EN: usize, const FN: usize, const GN: usize, const HN: usize, const IN: usize, const JN: usize, const KN: usize, const LN: usize, const MN: usize, const NN: usize, const ON: usize, const PN: usize, const QN: usize, const RN: usize, const SN: usize, const TN: usize, const UN: usize, const VN: usize, const WN: usize, const XN: usize> From<P24<[TY; NU], AN, BN, CN, DN, EN, FN, GN, HN, IN, JN, KN, LN, MN, NN, ON, PN, QN, RN, SN, TN, UN, VN, WN, XN>> for Be<(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 TY: Copy + Default, Be<A>: From<[TY; AN]>, Be<B>: From<[TY; BN]>, Be<C>: From<[TY; CN]>, Be<D>: From<[TY; DN]>, Be<E>: From<[TY; EN]>, Be<F>: From<[TY; FN]>, Be<G>: From<[TY; GN]>, Be<H>: From<[TY; HN]>, Be<I>: From<[TY; IN]>, Be<J>: From<[TY; JN]>, Be<K>: From<[TY; KN]>, Be<L>: From<[TY; LN]>, Be<M>: From<[TY; MN]>, Be<N>: From<[TY; NN]>, Be<O>: From<[TY; ON]>, Be<P>: From<[TY; PN]>, Be<Q>: From<[TY; QN]>, Be<R>: From<[TY; RN]>, Be<S>: From<[TY; SN]>, Be<T>: From<[TY; TN]>, Be<U>: From<[TY; UN]>, Be<V>: From<[TY; VN]>, Be<W>: From<[TY; WN]>, Be<X>: From<[TY; XN]>,

fn from( data: P24<[TY; NU], AN, BN, CN, DN, EN, FN, GN, HN, IN, JN, KN, LN, MN, NN, ON, PN, QN, RN, SN, TN, UN, VN, WN, XN>, ) -> Self

Converts to this type from the input type.

impl<TY, 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, const NU: usize, const AN: usize, const BN: usize, const CN: usize, const DN: usize, const EN: usize, const FN: usize, const GN: usize, const HN: usize, const IN: usize, const JN: usize, const KN: usize, const LN: usize, const MN: usize, const NN: usize, const ON: usize, const PN: usize, const QN: usize, const RN: usize, const SN: usize, const TN: usize, const UN: usize, const VN: usize, const WN: usize, const XN: usize, const YN: usize> From<P25<[TY; NU], AN, BN, CN, DN, EN, FN, GN, HN, IN, JN, KN, LN, MN, NN, ON, PN, QN, RN, SN, TN, UN, VN, WN, XN, YN>> for Be<(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 TY: Copy + Default, Be<A>: From<[TY; AN]>, Be<B>: From<[TY; BN]>, Be<C>: From<[TY; CN]>, Be<D>: From<[TY; DN]>, Be<E>: From<[TY; EN]>, Be<F>: From<[TY; FN]>, Be<G>: From<[TY; GN]>, Be<H>: From<[TY; HN]>, Be<I>: From<[TY; IN]>, Be<J>: From<[TY; JN]>, Be<K>: From<[TY; KN]>, Be<L>: From<[TY; LN]>, Be<M>: From<[TY; MN]>, Be<N>: From<[TY; NN]>, Be<O>: From<[TY; ON]>, Be<P>: From<[TY; PN]>, Be<Q>: From<[TY; QN]>, Be<R>: From<[TY; RN]>, Be<S>: From<[TY; SN]>, Be<T>: From<[TY; TN]>, Be<U>: From<[TY; UN]>, Be<V>: From<[TY; VN]>, Be<W>: From<[TY; WN]>, Be<X>: From<[TY; XN]>, Be<Y>: From<[TY; YN]>,

fn from( data: P25<[TY; NU], AN, BN, CN, DN, EN, FN, GN, HN, IN, JN, KN, LN, MN, NN, ON, PN, QN, RN, SN, TN, UN, VN, WN, XN, YN>, ) -> Self

Converts to this type from the input type.

impl<TY, 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, const NU: usize, const AN: usize, const BN: usize, const CN: usize, const DN: usize, const EN: usize, const FN: usize, const GN: usize, const HN: usize, const IN: usize, const JN: usize, const KN: usize, const LN: usize, const MN: usize, const NN: usize, const ON: usize, const PN: usize, const QN: usize, const RN: usize, const SN: usize, const TN: usize, const UN: usize, const VN: usize, const WN: usize, const XN: usize, const YN: usize, const ZN: usize> From<P26<[TY; NU], AN, BN, CN, DN, EN, FN, GN, HN, IN, JN, KN, LN, MN, NN, ON, PN, QN, RN, SN, TN, UN, VN, WN, XN, YN, ZN>> for Be<(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 TY: Copy + Default, Be<A>: From<[TY; AN]>, Be<B>: From<[TY; BN]>, Be<C>: From<[TY; CN]>, Be<D>: From<[TY; DN]>, Be<E>: From<[TY; EN]>, Be<F>: From<[TY; FN]>, Be<G>: From<[TY; GN]>, Be<H>: From<[TY; HN]>, Be<I>: From<[TY; IN]>, Be<J>: From<[TY; JN]>, Be<K>: From<[TY; KN]>, Be<L>: From<[TY; LN]>, Be<M>: From<[TY; MN]>, Be<N>: From<[TY; NN]>, Be<O>: From<[TY; ON]>, Be<P>: From<[TY; PN]>, Be<Q>: From<[TY; QN]>, Be<R>: From<[TY; RN]>, Be<S>: From<[TY; SN]>, Be<T>: From<[TY; TN]>, Be<U>: From<[TY; UN]>, Be<V>: From<[TY; VN]>, Be<W>: From<[TY; WN]>, Be<X>: From<[TY; XN]>, Be<Y>: From<[TY; YN]>, Be<Z>: From<[TY; ZN]>,

fn from( data: P26<[TY; NU], AN, BN, CN, DN, EN, FN, GN, HN, IN, JN, KN, LN, MN, NN, ON, PN, QN, RN, SN, TN, UN, VN, WN, XN, YN, ZN>, ) -> Self

Converts to this type from the input type.

impl<TY, A, B, C, const NU: usize, const AN: usize, const BN: usize, const CN: usize> From<P3<[TY; NU], AN, BN, CN>> for Be<(A, B, C)>

where TY: Copy + Default, Be<A>: From<[TY; AN]>, Be<B>: From<[TY; BN]>, Be<C>: From<[TY; CN]>,

fn from(data: P3<[TY; NU], AN, BN, CN>) -> Self

Converts to this type from the input type.

impl<TY, A, B, C, D, const NU: usize, const AN: usize, const BN: usize, const CN: usize, const DN: usize> From<P4<[TY; NU], AN, BN, CN, DN>> for Be<(A, B, C, D)>

where TY: Copy + Default, Be<A>: From<[TY; AN]>, Be<B>: From<[TY; BN]>, Be<C>: From<[TY; CN]>, Be<D>: From<[TY; DN]>,

fn from(data: P4<[TY; NU], AN, BN, CN, DN>) -> Self

Converts to this type from the input type.

impl<TY, A, B, C, D, E, const NU: usize, const AN: usize, const BN: usize, const CN: usize, const DN: usize, const EN: usize> From<P5<[TY; NU], AN, BN, CN, DN, EN>> for Be<(A, B, C, D, E)>

where TY: Copy + Default, Be<A>: From<[TY; AN]>, Be<B>: From<[TY; BN]>, Be<C>: From<[TY; CN]>, Be<D>: From<[TY; DN]>, Be<E>: From<[TY; EN]>,

fn from(data: P5<[TY; NU], AN, BN, CN, DN, EN>) -> Self

Converts to this type from the input type.

impl<TY, A, B, C, D, E, F, const NU: usize, const AN: usize, const BN: usize, const CN: usize, const DN: usize, const EN: usize, const FN: usize> From<P6<[TY; NU], AN, BN, CN, DN, EN, FN>> for Be<(A, B, C, D, E, F)>

where TY: Copy + Default, Be<A>: From<[TY; AN]>, Be<B>: From<[TY; BN]>, Be<C>: From<[TY; CN]>, Be<D>: From<[TY; DN]>, Be<E>: From<[TY; EN]>, Be<F>: From<[TY; FN]>,

fn from(data: P6<[TY; NU], AN, BN, CN, DN, EN, FN>) -> Self

Converts to this type from the input type.

impl<TY, A, B, C, D, E, F, G, const NU: usize, const AN: usize, const BN: usize, const CN: usize, const DN: usize, const EN: usize, const FN: usize, const GN: usize> From<P7<[TY; NU], AN, BN, CN, DN, EN, FN, GN>> for Be<(A, B, C, D, E, F, G)>

where TY: Copy + Default, Be<A>: From<[TY; AN]>, Be<B>: From<[TY; BN]>, Be<C>: From<[TY; CN]>, Be<D>: From<[TY; DN]>, Be<E>: From<[TY; EN]>, Be<F>: From<[TY; FN]>, Be<G>: From<[TY; GN]>,

fn from(data: P7<[TY; NU], AN, BN, CN, DN, EN, FN, GN>) -> Self

Converts to this type from the input type.

impl<TY, A, B, C, D, E, F, G, H, const NU: usize, const AN: usize, const BN: usize, const CN: usize, const DN: usize, const EN: usize, const FN: usize, const GN: usize, const HN: usize> From<P8<[TY; NU], AN, BN, CN, DN, EN, FN, GN, HN>> for Be<(A, B, C, D, E, F, G, H)>

where TY: Copy + Default, Be<A>: From<[TY; AN]>, Be<B>: From<[TY; BN]>, Be<C>: From<[TY; CN]>, Be<D>: From<[TY; DN]>, Be<E>: From<[TY; EN]>, Be<F>: From<[TY; FN]>, Be<G>: From<[TY; GN]>, Be<H>: From<[TY; HN]>,

fn from(data: P8<[TY; NU], AN, BN, CN, DN, EN, FN, GN, HN>) -> Self

Converts to this type from the input type.

impl<TY, A, B, C, D, E, F, G, H, I, const NU: usize, const AN: usize, const BN: usize, const CN: usize, const DN: usize, const EN: usize, const FN: usize, const GN: usize, const HN: usize, const IN: usize> From<P9<[TY; NU], AN, BN, CN, DN, EN, FN, GN, HN, IN>> for Be<(A, B, C, D, E, F, G, H, I)>

where TY: Copy + Default, Be<A>: From<[TY; AN]>, Be<B>: From<[TY; BN]>, Be<C>: From<[TY; CN]>, Be<D>: From<[TY; DN]>, Be<E>: From<[TY; EN]>, Be<F>: From<[TY; FN]>, Be<G>: From<[TY; GN]>, Be<H>: From<[TY; HN]>, Be<I>: From<[TY; IN]>,

fn from(data: P9<[TY; NU], AN, BN, CN, DN, EN, FN, GN, HN, IN>) -> Self

Converts to this type from the input type.

impl<TY, A, const AN: usize> From<T1<[TY; AN]>> for Be<(A,)>

where Be<A>: From<[TY; AN]>,

fn from(data: T1<[TY; AN]>) -> Self

Converts to this type from the input type.

impl<TY, A, B, C, D, E, F, G, H, I, J, const AN: usize, const BN: usize, const CN: usize, const DN: usize, const EN: usize, const FN: usize, const GN: usize, const HN: usize, const IN: usize, const JN: usize> From<T10<[TY; AN], [TY; BN], [TY; CN], [TY; DN], [TY; EN], [TY; FN], [TY; GN], [TY; HN], [TY; IN], [TY; JN]>> for Be<(A, B, C, D, E, F, G, H, I, J)>

where Be<A>: From<[TY; AN]>, Be<B>: From<[TY; BN]>, Be<C>: From<[TY; CN]>, Be<D>: From<[TY; DN]>, Be<E>: From<[TY; EN]>, Be<F>: From<[TY; FN]>, Be<G>: From<[TY; GN]>, Be<H>: From<[TY; HN]>, Be<I>: From<[TY; IN]>, Be<J>: From<[TY; JN]>,

fn from( data: T10<[TY; AN], [TY; BN], [TY; CN], [TY; DN], [TY; EN], [TY; FN], [TY; GN], [TY; HN], [TY; IN], [TY; JN]>, ) -> Self

Converts to this type from the input type.

impl<TY, A, B, C, D, E, F, G, H, I, J, K, const AN: usize, const BN: usize, const CN: usize, const DN: usize, const EN: usize, const FN: usize, const GN: usize, const HN: usize, const IN: usize, const JN: usize, const KN: usize> From<T11<[TY; AN], [TY; BN], [TY; CN], [TY; DN], [TY; EN], [TY; FN], [TY; GN], [TY; HN], [TY; IN], [TY; JN], [TY; KN]>> for Be<(A, B, C, D, E, F, G, H, I, J, K)>

where Be<A>: From<[TY; AN]>, Be<B>: From<[TY; BN]>, Be<C>: From<[TY; CN]>, Be<D>: From<[TY; DN]>, Be<E>: From<[TY; EN]>, Be<F>: From<[TY; FN]>, Be<G>: From<[TY; GN]>, Be<H>: From<[TY; HN]>, Be<I>: From<[TY; IN]>, Be<J>: From<[TY; JN]>, Be<K>: From<[TY; KN]>,

fn from( data: T11<[TY; AN], [TY; BN], [TY; CN], [TY; DN], [TY; EN], [TY; FN], [TY; GN], [TY; HN], [TY; IN], [TY; JN], [TY; KN]>, ) -> Self

Converts to this type from the input type.

impl<TY, A, B, C, D, E, F, G, H, I, J, K, L, const AN: usize, const BN: usize, const CN: usize, const DN: usize, const EN: usize, const FN: usize, const GN: usize, const HN: usize, const IN: usize, const JN: usize, const KN: usize, const LN: usize> From<T12<[TY; AN], [TY; BN], [TY; CN], [TY; DN], [TY; EN], [TY; FN], [TY; GN], [TY; HN], [TY; IN], [TY; JN], [TY; KN], [TY; LN]>> for Be<(A, B, C, D, E, F, G, H, I, J, K, L)>

where Be<A>: From<[TY; AN]>, Be<B>: From<[TY; BN]>, Be<C>: From<[TY; CN]>, Be<D>: From<[TY; DN]>, Be<E>: From<[TY; EN]>, Be<F>: From<[TY; FN]>, Be<G>: From<[TY; GN]>, Be<H>: From<[TY; HN]>, Be<I>: From<[TY; IN]>, Be<J>: From<[TY; JN]>, Be<K>: From<[TY; KN]>, Be<L>: From<[TY; LN]>,

fn from( data: T12<[TY; AN], [TY; BN], [TY; CN], [TY; DN], [TY; EN], [TY; FN], [TY; GN], [TY; HN], [TY; IN], [TY; JN], [TY; KN], [TY; LN]>, ) -> Self

Converts to this type from the input type.

impl<TY, A, B, C, D, E, F, G, H, I, J, K, L, M, const AN: usize, const BN: usize, const CN: usize, const DN: usize, const EN: usize, const FN: usize, const GN: usize, const HN: usize, const IN: usize, const JN: usize, const KN: usize, const LN: usize, const MN: usize> From<T13<[TY; AN], [TY; BN], [TY; CN], [TY; DN], [TY; EN], [TY; FN], [TY; GN], [TY; HN], [TY; IN], [TY; JN], [TY; KN], [TY; LN], [TY; MN]>> for Be<(A, B, C, D, E, F, G, H, I, J, K, L, M)>

where Be<A>: From<[TY; AN]>, Be<B>: From<[TY; BN]>, Be<C>: From<[TY; CN]>, Be<D>: From<[TY; DN]>, Be<E>: From<[TY; EN]>, Be<F>: From<[TY; FN]>, Be<G>: From<[TY; GN]>, Be<H>: From<[TY; HN]>, Be<I>: From<[TY; IN]>, Be<J>: From<[TY; JN]>, Be<K>: From<[TY; KN]>, Be<L>: From<[TY; LN]>, Be<M>: From<[TY; MN]>,

fn from( data: T13<[TY; AN], [TY; BN], [TY; CN], [TY; DN], [TY; EN], [TY; FN], [TY; GN], [TY; HN], [TY; IN], [TY; JN], [TY; KN], [TY; LN], [TY; MN]>, ) -> Self

Converts to this type from the input type.

impl<TY, A, B, C, D, E, F, G, H, I, J, K, L, M, N, const AN: usize, const BN: usize, const CN: usize, const DN: usize, const EN: usize, const FN: usize, const GN: usize, const HN: usize, const IN: usize, const JN: usize, const KN: usize, const LN: usize, const MN: usize, const NN: usize> From<T14<[TY; AN], [TY; BN], [TY; CN], [TY; DN], [TY; EN], [TY; FN], [TY; GN], [TY; HN], [TY; IN], [TY; JN], [TY; KN], [TY; LN], [TY; MN], [TY; NN]>> for Be<(A, B, C, D, E, F, G, H, I, J, K, L, M, N)>

where Be<A>: From<[TY; AN]>, Be<B>: From<[TY; BN]>, Be<C>: From<[TY; CN]>, Be<D>: From<[TY; DN]>, Be<E>: From<[TY; EN]>, Be<F>: From<[TY; FN]>, Be<G>: From<[TY; GN]>, Be<H>: From<[TY; HN]>, Be<I>: From<[TY; IN]>, Be<J>: From<[TY; JN]>, Be<K>: From<[TY; KN]>, Be<L>: From<[TY; LN]>, Be<M>: From<[TY; MN]>, Be<N>: From<[TY; NN]>,

fn from( data: T14<[TY; AN], [TY; BN], [TY; CN], [TY; DN], [TY; EN], [TY; FN], [TY; GN], [TY; HN], [TY; IN], [TY; JN], [TY; KN], [TY; LN], [TY; MN], [TY; NN]>, ) -> Self

Converts to this type from the input type.

impl<TY, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, const AN: usize, const BN: usize, const CN: usize, const DN: usize, const EN: usize, const FN: usize, const GN: usize, const HN: usize, const IN: usize, const JN: usize, const KN: usize, const LN: usize, const MN: usize, const NN: usize, const ON: usize> From<T15<[TY; AN], [TY; BN], [TY; CN], [TY; DN], [TY; EN], [TY; FN], [TY; GN], [TY; HN], [TY; IN], [TY; JN], [TY; KN], [TY; LN], [TY; MN], [TY; NN], [TY; ON]>> for Be<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)>

where Be<A>: From<[TY; AN]>, Be<B>: From<[TY; BN]>, Be<C>: From<[TY; CN]>, Be<D>: From<[TY; DN]>, Be<E>: From<[TY; EN]>, Be<F>: From<[TY; FN]>, Be<G>: From<[TY; GN]>, Be<H>: From<[TY; HN]>, Be<I>: From<[TY; IN]>, Be<J>: From<[TY; JN]>, Be<K>: From<[TY; KN]>, Be<L>: From<[TY; LN]>, Be<M>: From<[TY; MN]>, Be<N>: From<[TY; NN]>, Be<O>: From<[TY; ON]>,

fn from( data: T15<[TY; AN], [TY; BN], [TY; CN], [TY; DN], [TY; EN], [TY; FN], [TY; GN], [TY; HN], [TY; IN], [TY; JN], [TY; KN], [TY; LN], [TY; MN], [TY; NN], [TY; ON]>, ) -> Self

Converts to this type from the input type.

impl<TY, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, const AN: usize, const BN: usize, const CN: usize, const DN: usize, const EN: usize, const FN: usize, const GN: usize, const HN: usize, const IN: usize, const JN: usize, const KN: usize, const LN: usize, const MN: usize, const NN: usize, const ON: usize, const PN: usize> From<T16<[TY; AN], [TY; BN], [TY; CN], [TY; DN], [TY; EN], [TY; FN], [TY; GN], [TY; HN], [TY; IN], [TY; JN], [TY; KN], [TY; LN], [TY; MN], [TY; NN], [TY; ON], [TY; PN]>> for Be<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)>

where Be<A>: From<[TY; AN]>, Be<B>: From<[TY; BN]>, Be<C>: From<[TY; CN]>, Be<D>: From<[TY; DN]>, Be<E>: From<[TY; EN]>, Be<F>: From<[TY; FN]>, Be<G>: From<[TY; GN]>, Be<H>: From<[TY; HN]>, Be<I>: From<[TY; IN]>, Be<J>: From<[TY; JN]>, Be<K>: From<[TY; KN]>, Be<L>: From<[TY; LN]>, Be<M>: From<[TY; MN]>, Be<N>: From<[TY; NN]>, Be<O>: From<[TY; ON]>, Be<P>: From<[TY; PN]>,

fn from( data: T16<[TY; AN], [TY; BN], [TY; CN], [TY; DN], [TY; EN], [TY; FN], [TY; GN], [TY; HN], [TY; IN], [TY; JN], [TY; KN], [TY; LN], [TY; MN], [TY; NN], [TY; ON], [TY; PN]>, ) -> Self

Converts to this type from the input type.

impl<TY, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, const AN: usize, const BN: usize, const CN: usize, const DN: usize, const EN: usize, const FN: usize, const GN: usize, const HN: usize, const IN: usize, const JN: usize, const KN: usize, const LN: usize, const MN: usize, const NN: usize, const ON: usize, const PN: usize, const QN: usize> From<T17<[TY; AN], [TY; BN], [TY; CN], [TY; DN], [TY; EN], [TY; FN], [TY; GN], [TY; HN], [TY; IN], [TY; JN], [TY; KN], [TY; LN], [TY; MN], [TY; NN], [TY; ON], [TY; PN], [TY; QN]>> for Be<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)>

where Be<A>: From<[TY; AN]>, Be<B>: From<[TY; BN]>, Be<C>: From<[TY; CN]>, Be<D>: From<[TY; DN]>, Be<E>: From<[TY; EN]>, Be<F>: From<[TY; FN]>, Be<G>: From<[TY; GN]>, Be<H>: From<[TY; HN]>, Be<I>: From<[TY; IN]>, Be<J>: From<[TY; JN]>, Be<K>: From<[TY; KN]>, Be<L>: From<[TY; LN]>, Be<M>: From<[TY; MN]>, Be<N>: From<[TY; NN]>, Be<O>: From<[TY; ON]>, Be<P>: From<[TY; PN]>, Be<Q>: From<[TY; QN]>,

fn from( data: T17<[TY; AN], [TY; BN], [TY; CN], [TY; DN], [TY; EN], [TY; FN], [TY; GN], [TY; HN], [TY; IN], [TY; JN], [TY; KN], [TY; LN], [TY; MN], [TY; NN], [TY; ON], [TY; PN], [TY; QN]>, ) -> Self

Converts to this type from the input type.

impl<TY, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, const AN: usize, const BN: usize, const CN: usize, const DN: usize, const EN: usize, const FN: usize, const GN: usize, const HN: usize, const IN: usize, const JN: usize, const KN: usize, const LN: usize, const MN: usize, const NN: usize, const ON: usize, const PN: usize, const QN: usize, const RN: usize> From<T18<[TY; AN], [TY; BN], [TY; CN], [TY; DN], [TY; EN], [TY; FN], [TY; GN], [TY; HN], [TY; IN], [TY; JN], [TY; KN], [TY; LN], [TY; MN], [TY; NN], [TY; ON], [TY; PN], [TY; QN], [TY; RN]>> for Be<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)>

where Be<A>: From<[TY; AN]>, Be<B>: From<[TY; BN]>, Be<C>: From<[TY; CN]>, Be<D>: From<[TY; DN]>, Be<E>: From<[TY; EN]>, Be<F>: From<[TY; FN]>, Be<G>: From<[TY; GN]>, Be<H>: From<[TY; HN]>, Be<I>: From<[TY; IN]>, Be<J>: From<[TY; JN]>, Be<K>: From<[TY; KN]>, Be<L>: From<[TY; LN]>, Be<M>: From<[TY; MN]>, Be<N>: From<[TY; NN]>, Be<O>: From<[TY; ON]>, Be<P>: From<[TY; PN]>, Be<Q>: From<[TY; QN]>, Be<R>: From<[TY; RN]>,

fn from( data: T18<[TY; AN], [TY; BN], [TY; CN], [TY; DN], [TY; EN], [TY; FN], [TY; GN], [TY; HN], [TY; IN], [TY; JN], [TY; KN], [TY; LN], [TY; MN], [TY; NN], [TY; ON], [TY; PN], [TY; QN], [TY; RN]>, ) -> Self

Converts to this type from the input type.

impl<TY, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, const AN: usize, const BN: usize, const CN: usize, const DN: usize, const EN: usize, const FN: usize, const GN: usize, const HN: usize, const IN: usize, const JN: usize, const KN: usize, const LN: usize, const MN: usize, const NN: usize, const ON: usize, const PN: usize, const QN: usize, const RN: usize, const SN: usize> From<T19<[TY; AN], [TY; BN], [TY; CN], [TY; DN], [TY; EN], [TY; FN], [TY; GN], [TY; HN], [TY; IN], [TY; JN], [TY; KN], [TY; LN], [TY; MN], [TY; NN], [TY; ON], [TY; PN], [TY; QN], [TY; RN], [TY; SN]>> for Be<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)>

where Be<A>: From<[TY; AN]>, Be<B>: From<[TY; BN]>, Be<C>: From<[TY; CN]>, Be<D>: From<[TY; DN]>, Be<E>: From<[TY; EN]>, Be<F>: From<[TY; FN]>, Be<G>: From<[TY; GN]>, Be<H>: From<[TY; HN]>, Be<I>: From<[TY; IN]>, Be<J>: From<[TY; JN]>, Be<K>: From<[TY; KN]>, Be<L>: From<[TY; LN]>, Be<M>: From<[TY; MN]>, Be<N>: From<[TY; NN]>, Be<O>: From<[TY; ON]>, Be<P>: From<[TY; PN]>, Be<Q>: From<[TY; QN]>, Be<R>: From<[TY; RN]>, Be<S>: From<[TY; SN]>,

fn from( data: T19<[TY; AN], [TY; BN], [TY; CN], [TY; DN], [TY; EN], [TY; FN], [TY; GN], [TY; HN], [TY; IN], [TY; JN], [TY; KN], [TY; LN], [TY; MN], [TY; NN], [TY; ON], [TY; PN], [TY; QN], [TY; RN], [TY; SN]>, ) -> Self

Converts to this type from the input type.

impl<TY, A, B, const AN: usize, const BN: usize> From<T2<[TY; AN], [TY; BN]>> for Be<(A, B)>

where Be<A>: From<[TY; AN]>, Be<B>: From<[TY; BN]>,

fn from(data: T2<[TY; AN], [TY; BN]>) -> Self

Converts to this type from the input type.

impl<TY, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, const AN: usize, const BN: usize, const CN: usize, const DN: usize, const EN: usize, const FN: usize, const GN: usize, const HN: usize, const IN: usize, const JN: usize, const KN: usize, const LN: usize, const MN: usize, const NN: usize, const ON: usize, const PN: usize, const QN: usize, const RN: usize, const SN: usize, const TN: usize> From<T20<[TY; AN], [TY; BN], [TY; CN], [TY; DN], [TY; EN], [TY; FN], [TY; GN], [TY; HN], [TY; IN], [TY; JN], [TY; KN], [TY; LN], [TY; MN], [TY; NN], [TY; ON], [TY; PN], [TY; QN], [TY; RN], [TY; SN], [TY; TN]>> for Be<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)>

where Be<A>: From<[TY; AN]>, Be<B>: From<[TY; BN]>, Be<C>: From<[TY; CN]>, Be<D>: From<[TY; DN]>, Be<E>: From<[TY; EN]>, Be<F>: From<[TY; FN]>, Be<G>: From<[TY; GN]>, Be<H>: From<[TY; HN]>, Be<I>: From<[TY; IN]>, Be<J>: From<[TY; JN]>, Be<K>: From<[TY; KN]>, Be<L>: From<[TY; LN]>, Be<M>: From<[TY; MN]>, Be<N>: From<[TY; NN]>, Be<O>: From<[TY; ON]>, Be<P>: From<[TY; PN]>, Be<Q>: From<[TY; QN]>, Be<R>: From<[TY; RN]>, Be<S>: From<[TY; SN]>, Be<T>: From<[TY; TN]>,

fn from( data: T20<[TY; AN], [TY; BN], [TY; CN], [TY; DN], [TY; EN], [TY; FN], [TY; GN], [TY; HN], [TY; IN], [TY; JN], [TY; KN], [TY; LN], [TY; MN], [TY; NN], [TY; ON], [TY; PN], [TY; QN], [TY; RN], [TY; SN], [TY; TN]>, ) -> Self

Converts to this type from the input type.

impl<TY, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, const AN: usize, const BN: usize, const CN: usize, const DN: usize, const EN: usize, const FN: usize, const GN: usize, const HN: usize, const IN: usize, const JN: usize, const KN: usize, const LN: usize, const MN: usize, const NN: usize, const ON: usize, const PN: usize, const QN: usize, const RN: usize, const SN: usize, const TN: usize, const UN: usize> From<T21<[TY; AN], [TY; BN], [TY; CN], [TY; DN], [TY; EN], [TY; FN], [TY; GN], [TY; HN], [TY; IN], [TY; JN], [TY; KN], [TY; LN], [TY; MN], [TY; NN], [TY; ON], [TY; PN], [TY; QN], [TY; RN], [TY; SN], [TY; TN], [TY; UN]>> for Be<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)>

where Be<A>: From<[TY; AN]>, Be<B>: From<[TY; BN]>, Be<C>: From<[TY; CN]>, Be<D>: From<[TY; DN]>, Be<E>: From<[TY; EN]>, Be<F>: From<[TY; FN]>, Be<G>: From<[TY; GN]>, Be<H>: From<[TY; HN]>, Be<I>: From<[TY; IN]>, Be<J>: From<[TY; JN]>, Be<K>: From<[TY; KN]>, Be<L>: From<[TY; LN]>, Be<M>: From<[TY; MN]>, Be<N>: From<[TY; NN]>, Be<O>: From<[TY; ON]>, Be<P>: From<[TY; PN]>, Be<Q>: From<[TY; QN]>, Be<R>: From<[TY; RN]>, Be<S>: From<[TY; SN]>, Be<T>: From<[TY; TN]>, Be<U>: From<[TY; UN]>,

fn from( data: T21<[TY; AN], [TY; BN], [TY; CN], [TY; DN], [TY; EN], [TY; FN], [TY; GN], [TY; HN], [TY; IN], [TY; JN], [TY; KN], [TY; LN], [TY; MN], [TY; NN], [TY; ON], [TY; PN], [TY; QN], [TY; RN], [TY; SN], [TY; TN], [TY; UN]>, ) -> Self

Converts to this type from the input type.

impl<TY, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, const AN: usize, const BN: usize, const CN: usize, const DN: usize, const EN: usize, const FN: usize, const GN: usize, const HN: usize, const IN: usize, const JN: usize, const KN: usize, const LN: usize, const MN: usize, const NN: usize, const ON: usize, const PN: usize, const QN: usize, const RN: usize, const SN: usize, const TN: usize, const UN: usize, const VN: usize> From<T22<[TY; AN], [TY; BN], [TY; CN], [TY; DN], [TY; EN], [TY; FN], [TY; GN], [TY; HN], [TY; IN], [TY; JN], [TY; KN], [TY; LN], [TY; MN], [TY; NN], [TY; ON], [TY; PN], [TY; QN], [TY; RN], [TY; SN], [TY; TN], [TY; UN], [TY; VN]>> for Be<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)>

where Be<A>: From<[TY; AN]>, Be<B>: From<[TY; BN]>, Be<C>: From<[TY; CN]>, Be<D>: From<[TY; DN]>, Be<E>: From<[TY; EN]>, Be<F>: From<[TY; FN]>, Be<G>: From<[TY; GN]>, Be<H>: From<[TY; HN]>, Be<I>: From<[TY; IN]>, Be<J>: From<[TY; JN]>, Be<K>: From<[TY; KN]>, Be<L>: From<[TY; LN]>, Be<M>: From<[TY; MN]>, Be<N>: From<[TY; NN]>, Be<O>: From<[TY; ON]>, Be<P>: From<[TY; PN]>, Be<Q>: From<[TY; QN]>, Be<R>: From<[TY; RN]>, Be<S>: From<[TY; SN]>, Be<T>: From<[TY; TN]>, Be<U>: From<[TY; UN]>, Be<V>: From<[TY; VN]>,

fn from( data: T22<[TY; AN], [TY; BN], [TY; CN], [TY; DN], [TY; EN], [TY; FN], [TY; GN], [TY; HN], [TY; IN], [TY; JN], [TY; KN], [TY; LN], [TY; MN], [TY; NN], [TY; ON], [TY; PN], [TY; QN], [TY; RN], [TY; SN], [TY; TN], [TY; UN], [TY; VN]>, ) -> Self

Converts to this type from the input type.

impl<TY, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, const AN: usize, const BN: usize, const CN: usize, const DN: usize, const EN: usize, const FN: usize, const GN: usize, const HN: usize, const IN: usize, const JN: usize, const KN: usize, const LN: usize, const MN: usize, const NN: usize, const ON: usize, const PN: usize, const QN: usize, const RN: usize, const SN: usize, const TN: usize, const UN: usize, const VN: usize, const WN: usize> From<T23<[TY; AN], [TY; BN], [TY; CN], [TY; DN], [TY; EN], [TY; FN], [TY; GN], [TY; HN], [TY; IN], [TY; JN], [TY; KN], [TY; LN], [TY; MN], [TY; NN], [TY; ON], [TY; PN], [TY; QN], [TY; RN], [TY; SN], [TY; TN], [TY; UN], [TY; VN], [TY; WN]>> for Be<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)>

where Be<A>: From<[TY; AN]>, Be<B>: From<[TY; BN]>, Be<C>: From<[TY; CN]>, Be<D>: From<[TY; DN]>, Be<E>: From<[TY; EN]>, Be<F>: From<[TY; FN]>, Be<G>: From<[TY; GN]>, Be<H>: From<[TY; HN]>, Be<I>: From<[TY; IN]>, Be<J>: From<[TY; JN]>, Be<K>: From<[TY; KN]>, Be<L>: From<[TY; LN]>, Be<M>: From<[TY; MN]>, Be<N>: From<[TY; NN]>, Be<O>: From<[TY; ON]>, Be<P>: From<[TY; PN]>, Be<Q>: From<[TY; QN]>, Be<R>: From<[TY; RN]>, Be<S>: From<[TY; SN]>, Be<T>: From<[TY; TN]>, Be<U>: From<[TY; UN]>, Be<V>: From<[TY; VN]>, Be<W>: From<[TY; WN]>,

fn from( data: T23<[TY; AN], [TY; BN], [TY; CN], [TY; DN], [TY; EN], [TY; FN], [TY; GN], [TY; HN], [TY; IN], [TY; JN], [TY; KN], [TY; LN], [TY; MN], [TY; NN], [TY; ON], [TY; PN], [TY; QN], [TY; RN], [TY; SN], [TY; TN], [TY; UN], [TY; VN], [TY; WN]>, ) -> Self

Converts to this type from the input type.

impl<TY, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, const AN: usize, const BN: usize, const CN: usize, const DN: usize, const EN: usize, const FN: usize, const GN: usize, const HN: usize, const IN: usize, const JN: usize, const KN: usize, const LN: usize, const MN: usize, const NN: usize, const ON: usize, const PN: usize, const QN: usize, const RN: usize, const SN: usize, const TN: usize, const UN: usize, const VN: usize, const WN: usize, const XN: usize> From<T24<[TY; AN], [TY; BN], [TY; CN], [TY; DN], [TY; EN], [TY; FN], [TY; GN], [TY; HN], [TY; IN], [TY; JN], [TY; KN], [TY; LN], [TY; MN], [TY; NN], [TY; ON], [TY; PN], [TY; QN], [TY; RN], [TY; SN], [TY; TN], [TY; UN], [TY; VN], [TY; WN], [TY; XN]>> for Be<(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 Be<A>: From<[TY; AN]>, Be<B>: From<[TY; BN]>, Be<C>: From<[TY; CN]>, Be<D>: From<[TY; DN]>, Be<E>: From<[TY; EN]>, Be<F>: From<[TY; FN]>, Be<G>: From<[TY; GN]>, Be<H>: From<[TY; HN]>, Be<I>: From<[TY; IN]>, Be<J>: From<[TY; JN]>, Be<K>: From<[TY; KN]>, Be<L>: From<[TY; LN]>, Be<M>: From<[TY; MN]>, Be<N>: From<[TY; NN]>, Be<O>: From<[TY; ON]>, Be<P>: From<[TY; PN]>, Be<Q>: From<[TY; QN]>, Be<R>: From<[TY; RN]>, Be<S>: From<[TY; SN]>, Be<T>: From<[TY; TN]>, Be<U>: From<[TY; UN]>, Be<V>: From<[TY; VN]>, Be<W>: From<[TY; WN]>, Be<X>: From<[TY; XN]>,

fn from( data: T24<[TY; AN], [TY; BN], [TY; CN], [TY; DN], [TY; EN], [TY; FN], [TY; GN], [TY; HN], [TY; IN], [TY; JN], [TY; KN], [TY; LN], [TY; MN], [TY; NN], [TY; ON], [TY; PN], [TY; QN], [TY; RN], [TY; SN], [TY; TN], [TY; UN], [TY; VN], [TY; WN], [TY; XN]>, ) -> Self

Converts to this type from the input type.

impl<TY, 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, const AN: usize, const BN: usize, const CN: usize, const DN: usize, const EN: usize, const FN: usize, const GN: usize, const HN: usize, const IN: usize, const JN: usize, const KN: usize, const LN: usize, const MN: usize, const NN: usize, const ON: usize, const PN: usize, const QN: usize, const RN: usize, const SN: usize, const TN: usize, const UN: usize, const VN: usize, const WN: usize, const XN: usize, const YN: usize> From<T25<[TY; AN], [TY; BN], [TY; CN], [TY; DN], [TY; EN], [TY; FN], [TY; GN], [TY; HN], [TY; IN], [TY; JN], [TY; KN], [TY; LN], [TY; MN], [TY; NN], [TY; ON], [TY; PN], [TY; QN], [TY; RN], [TY; SN], [TY; TN], [TY; UN], [TY; VN], [TY; WN], [TY; XN], [TY; YN]>> for Be<(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 Be<A>: From<[TY; AN]>, Be<B>: From<[TY; BN]>, Be<C>: From<[TY; CN]>, Be<D>: From<[TY; DN]>, Be<E>: From<[TY; EN]>, Be<F>: From<[TY; FN]>, Be<G>: From<[TY; GN]>, Be<H>: From<[TY; HN]>, Be<I>: From<[TY; IN]>, Be<J>: From<[TY; JN]>, Be<K>: From<[TY; KN]>, Be<L>: From<[TY; LN]>, Be<M>: From<[TY; MN]>, Be<N>: From<[TY; NN]>, Be<O>: From<[TY; ON]>, Be<P>: From<[TY; PN]>, Be<Q>: From<[TY; QN]>, Be<R>: From<[TY; RN]>, Be<S>: From<[TY; SN]>, Be<T>: From<[TY; TN]>, Be<U>: From<[TY; UN]>, Be<V>: From<[TY; VN]>, Be<W>: From<[TY; WN]>, Be<X>: From<[TY; XN]>, Be<Y>: From<[TY; YN]>,

fn from( data: T25<[TY; AN], [TY; BN], [TY; CN], [TY; DN], [TY; EN], [TY; FN], [TY; GN], [TY; HN], [TY; IN], [TY; JN], [TY; KN], [TY; LN], [TY; MN], [TY; NN], [TY; ON], [TY; PN], [TY; QN], [TY; RN], [TY; SN], [TY; TN], [TY; UN], [TY; VN], [TY; WN], [TY; XN], [TY; YN]>, ) -> Self

Converts to this type from the input type.

impl<TY, 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, const AN: usize, const BN: usize, const CN: usize, const DN: usize, const EN: usize, const FN: usize, const GN: usize, const HN: usize, const IN: usize, const JN: usize, const KN: usize, const LN: usize, const MN: usize, const NN: usize, const ON: usize, const PN: usize, const QN: usize, const RN: usize, const SN: usize, const TN: usize, const UN: usize, const VN: usize, const WN: usize, const XN: usize, const YN: usize, const ZN: usize> From<T26<[TY; AN], [TY; BN], [TY; CN], [TY; DN], [TY; EN], [TY; FN], [TY; GN], [TY; HN], [TY; IN], [TY; JN], [TY; KN], [TY; LN], [TY; MN], [TY; NN], [TY; ON], [TY; PN], [TY; QN], [TY; RN], [TY; SN], [TY; TN], [TY; UN], [TY; VN], [TY; WN], [TY; XN], [TY; YN], [TY; ZN]>> for Be<(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 Be<A>: From<[TY; AN]>, Be<B>: From<[TY; BN]>, Be<C>: From<[TY; CN]>, Be<D>: From<[TY; DN]>, Be<E>: From<[TY; EN]>, Be<F>: From<[TY; FN]>, Be<G>: From<[TY; GN]>, Be<H>: From<[TY; HN]>, Be<I>: From<[TY; IN]>, Be<J>: From<[TY; JN]>, Be<K>: From<[TY; KN]>, Be<L>: From<[TY; LN]>, Be<M>: From<[TY; MN]>, Be<N>: From<[TY; NN]>, Be<O>: From<[TY; ON]>, Be<P>: From<[TY; PN]>, Be<Q>: From<[TY; QN]>, Be<R>: From<[TY; RN]>, Be<S>: From<[TY; SN]>, Be<T>: From<[TY; TN]>, Be<U>: From<[TY; UN]>, Be<V>: From<[TY; VN]>, Be<W>: From<[TY; WN]>, Be<X>: From<[TY; XN]>, Be<Y>: From<[TY; YN]>, Be<Z>: From<[TY; ZN]>,

fn from( data: T26<[TY; AN], [TY; BN], [TY; CN], [TY; DN], [TY; EN], [TY; FN], [TY; GN], [TY; HN], [TY; IN], [TY; JN], [TY; KN], [TY; LN], [TY; MN], [TY; NN], [TY; ON], [TY; PN], [TY; QN], [TY; RN], [TY; SN], [TY; TN], [TY; UN], [TY; VN], [TY; WN], [TY; XN], [TY; YN], [TY; ZN]>, ) -> Self

Converts to this type from the input type.

impl<TY, A, B, C, const AN: usize, const BN: usize, const CN: usize> From<T3<[TY; AN], [TY; BN], [TY; CN]>> for Be<(A, B, C)>

where Be<A>: From<[TY; AN]>, Be<B>: From<[TY; BN]>, Be<C>: From<[TY; CN]>,

fn from(data: T3<[TY; AN], [TY; BN], [TY; CN]>) -> Self

Converts to this type from the input type.

impl<TY, A, B, C, D, const AN: usize, const BN: usize, const CN: usize, const DN: usize> From<T4<[TY; AN], [TY; BN], [TY; CN], [TY; DN]>> for Be<(A, B, C, D)>

where Be<A>: From<[TY; AN]>, Be<B>: From<[TY; BN]>, Be<C>: From<[TY; CN]>, Be<D>: From<[TY; DN]>,

fn from(data: T4<[TY; AN], [TY; BN], [TY; CN], [TY; DN]>) -> Self

Converts to this type from the input type.

impl<TY, A, B, C, D, E, const AN: usize, const BN: usize, const CN: usize, const DN: usize, const EN: usize> From<T5<[TY; AN], [TY; BN], [TY; CN], [TY; DN], [TY; EN]>> for Be<(A, B, C, D, E)>

where Be<A>: From<[TY; AN]>, Be<B>: From<[TY; BN]>, Be<C>: From<[TY; CN]>, Be<D>: From<[TY; DN]>, Be<E>: From<[TY; EN]>,

fn from(data: T5<[TY; AN], [TY; BN], [TY; CN], [TY; DN], [TY; EN]>) -> Self

Converts to this type from the input type.

impl<TY, A, B, C, D, E, F, const AN: usize, const BN: usize, const CN: usize, const DN: usize, const EN: usize, const FN: usize> From<T6<[TY; AN], [TY; BN], [TY; CN], [TY; DN], [TY; EN], [TY; FN]>> for Be<(A, B, C, D, E, F)>

where Be<A>: From<[TY; AN]>, Be<B>: From<[TY; BN]>, Be<C>: From<[TY; CN]>, Be<D>: From<[TY; DN]>, Be<E>: From<[TY; EN]>, Be<F>: From<[TY; FN]>,

fn from( data: T6<[TY; AN], [TY; BN], [TY; CN], [TY; DN], [TY; EN], [TY; FN]>, ) -> Self

Converts to this type from the input type.

impl<TY, A, B, C, D, E, F, G, const AN: usize, const BN: usize, const CN: usize, const DN: usize, const EN: usize, const FN: usize, const GN: usize> From<T7<[TY; AN], [TY; BN], [TY; CN], [TY; DN], [TY; EN], [TY; FN], [TY; GN]>> for Be<(A, B, C, D, E, F, G)>

where Be<A>: From<[TY; AN]>, Be<B>: From<[TY; BN]>, Be<C>: From<[TY; CN]>, Be<D>: From<[TY; DN]>, Be<E>: From<[TY; EN]>, Be<F>: From<[TY; FN]>, Be<G>: From<[TY; GN]>,

fn from( data: T7<[TY; AN], [TY; BN], [TY; CN], [TY; DN], [TY; EN], [TY; FN], [TY; GN]>, ) -> Self

Converts to this type from the input type.

impl<TY, A, B, C, D, E, F, G, H, const AN: usize, const BN: usize, const CN: usize, const DN: usize, const EN: usize, const FN: usize, const GN: usize, const HN: usize> From<T8<[TY; AN], [TY; BN], [TY; CN], [TY; DN], [TY; EN], [TY; FN], [TY; GN], [TY; HN]>> for Be<(A, B, C, D, E, F, G, H)>

where Be<A>: From<[TY; AN]>, Be<B>: From<[TY; BN]>, Be<C>: From<[TY; CN]>, Be<D>: From<[TY; DN]>, Be<E>: From<[TY; EN]>, Be<F>: From<[TY; FN]>, Be<G>: From<[TY; GN]>, Be<H>: From<[TY; HN]>,

fn from( data: T8<[TY; AN], [TY; BN], [TY; CN], [TY; DN], [TY; EN], [TY; FN], [TY; GN], [TY; HN]>, ) -> Self

Converts to this type from the input type.

impl<TY, A, B, C, D, E, F, G, H, I, const AN: usize, const BN: usize, const CN: usize, const DN: usize, const EN: usize, const FN: usize, const GN: usize, const HN: usize, const IN: usize> From<T9<[TY; AN], [TY; BN], [TY; CN], [TY; DN], [TY; EN], [TY; FN], [TY; GN], [TY; HN], [TY; IN]>> for Be<(A, B, C, D, E, F, G, H, I)>

where Be<A>: From<[TY; AN]>, Be<B>: From<[TY; BN]>, Be<C>: From<[TY; CN]>, Be<D>: From<[TY; DN]>, Be<E>: From<[TY; EN]>, Be<F>: From<[TY; FN]>, Be<G>: From<[TY; GN]>, Be<H>: From<[TY; HN]>, Be<I>: From<[TY; IN]>,

fn from( data: T9<[TY; AN], [TY; BN], [TY; CN], [TY; DN], [TY; EN], [TY; FN], [TY; GN], [TY; HN], [TY; IN]>, ) -> Self

Converts to this type from the input type.

impl<T: PartialEq> PartialEq for Be<T>

fn eq(&self, other: &Be<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Eq> Eq for Be<T>

impl<T> StructuralPartialEq for Be<T>