Struct Cons 

pub struct Cons<T, R> {
    pub value: T,
    pub rest: R,
}

Fields

value: T

rest: R

Trait Implementations

impl<T, R: HList> Access<T, Zero> for Cons<T, R>

type Remainder = R

fn take(self) -> (T, Self::Remainder)

fn get(&self) -> &T

fn get_mut(&mut self) -> &mut T

impl<T, U, R: Access<U, N>, N> Access<U, Succ<N>> for Cons<T, R>

type Remainder = Cons<T, <R as Access<U, N>>::Remainder>

fn take(self) -> (U, Self::Remainder)

fn get(&self) -> &U

fn get_mut(&mut self) -> &mut U

impl<'a, F, T: 'a> Any<'a, F> for Cons<T, Nil>

where F: CallOnce<(&'a T,), Output = bool>,

fn any(&'a self, f: F) -> bool

impl<'a, F, T: 'a, R> Any<'a, F> for Cons<T, R>

where F: CallMut<(&'a T,), Output = bool>, R: Any<'a, F> + NonEmpty,

fn any(&'a self, f: F) -> bool

impl<'a, F, T: 'a, N> Any<'a, F, (N, ())> for Cons<T, Nil>

where F: CallOnce<(&'a T,), N, Output = bool>,

fn any(&'a self, f: F) -> bool

impl<'a, F, T: 'a, R, N, M> Any<'a, F, (N, M)> for Cons<T, R>

where F: CallMut<(&'a T,), N, Output = bool>, R: Any<'a, F, M> + NonEmpty,

fn any(&'a self, f: F) -> bool

impl<'a, T: 'a, R: AsRef<'a>> AsRef<'a> for Cons<T, R>

type Ref = Cons<&'a T, <R as AsRef<'a>>::Ref>

type RefMut = Cons<&'a mut T, <R as AsRef<'a>>::RefMut>

fn as_ref(&'a self) -> Self::Ref

fn as_mut(&'a mut self) -> Self::RefMut

impl<Args, N, F, R: Call<Args, N>> Call<Args, Succ<N>> for Cons<F, R>

fn call(&self, args: Args) -> Self::Output

impl<Args, F: Fn(Args) -> O, O, R> Call<Args, Zero> for Cons<F, R>

fn call(&self, args: Args) -> Self::Output

impl<Args, N, F, R: CallMut<Args, N>> CallMut<Args, Succ<N>> for Cons<F, R>

fn call_mut(&mut self, args: Args) -> Self::Output

impl<Args, F: FnMut(Args) -> O, O, R> CallMut<Args, Zero> for Cons<F, R>

fn call_mut(&mut self, args: Args) -> Self::Output

impl<Args, N, F, R: CallOnce<Args, N>> CallOnce<Args, Succ<N>> for Cons<F, R>

type Output = <R as CallOnce<Args, N>>::Output

fn call_once(self, args: Args) -> Self::Output

impl<Args, F: FnOnce(Args) -> O, O, R> CallOnce<Args, Zero> for Cons<F, R>

type Output = O

fn call_once(self, args: Args) -> Self::Output

impl<T: Clone, R: Clone> Clone for Cons<T, R>

fn clone(&self) -> Cons<T, R>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T, R: Concat<L>, L: HList> Concat<L> for Cons<T, R>

type Output = Cons<T, <R as Concat<L>>::Output>

fn concat(self, other: L) -> Self::Output

impl<T, R: HList> Convert for Cons<T, R>

type HList = Cons<T, R>

fn into_hlist(self) -> Self::HList

fn from_hlist(this: Self::HList) -> Self

impl<T: Debug, R: Debug> Debug for Cons<T, R>

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

Formats the value using the given formatter.

impl<T, R> DeepTransformFrom<Cons<T, R>, ()> for Nil

fn deep_transform_from(_: Cons<T, R>) -> Self

impl<T, Rt, L: DeepTransform<Rt, Ri>, I, Ri> DeepTransformFrom<Cons<Unnamed<T>, L>, (I, Ri)> for Cons<Unnamed<T>, Rt>

fn deep_transform_from(list: Cons<Unnamed<T>, L>) -> Self

impl<T, Rt, L, I, Ti, Ri, Name> DeepTransformFrom<L, (I, Ti, Ri)> for Cons<Named<T, Name>, Rt>

where L: RemoveField<Name, I>, L::Value: DeepTransform<T, Ti>, L::Remainder: DeepTransform<Rt, Ri>,

fn deep_transform_from(list: L) -> Self

impl<T: Hash, R: Hash> Hash for Cons<T, R>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T, R, C, N, M> IntoSuperset<C, Cons<PhantomData<N>, M>> for CoCons<T, R>

where C: Access<T, N>, R: IntoSuperset<C, M>,

fn into_superset(self) -> C

impl<F: CallOnce<(T,)>, T> Map<F> for Cons<T, Nil>

type Output = Cons<<F as CallOnce<(T,)>>::Output, Nil>

fn map(self, f: F) -> Self::Output

impl<F: CallMut<(T,)>, T, R: NonEmpty + Map<F>> Map<F> for Cons<T, R>

type Output = Cons<<F as CallOnce<(T,)>>::Output, <R as Map<F>>::Output>

fn map(self, f: F) -> Self::Output

impl<F: CallOnce<(T,), N>, T, N> Map<F, (N, ())> for Cons<T, Nil>

type Output = Cons<<F as CallOnce<(T,), N>>::Output, Nil>

fn map(self, f: F) -> Self::Output

impl<F: CallMut<(T,), N>, T, R: NonEmpty + Map<F, M>, N, M> Map<F, (N, M)> for Cons<T, R>

type Output = Cons<<F as CallOnce<(T,), N>>::Output, <R as Map<F, M>>::Output>

fn map(self, f: F) -> Self::Output

impl<T: Ord, R: Ord> Ord for Cons<T, R>

fn cmp(&self, other: &Cons<T, R>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<T: PartialEq, R: PartialEq> PartialEq for Cons<T, R>

fn eq(&self, other: &Cons<T, R>) -> 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: PartialOrd, R: PartialOrd> PartialOrd for Cons<T, R>

fn partial_cmp(&self, other: &Cons<T, R>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T, Name, R: RemoveField<Name, N>, N> RemoveField<Name, Succ<N>> for Cons<T, R>

type Value = <R as RemoveField<Name, N>>::Value

type Remainder = Cons<T, <R as RemoveField<Name, N>>::Remainder>

fn remove_field(self) -> (Self::Value, Self::Remainder)

impl<T, Name, R> RemoveField<Name, Zero> for Cons<Named<T, Name>, R>

type Value = T

type Remainder = R

fn remove_field(self) -> (Self::Value, Self::Remainder)

impl<T, U, R: HList, S: HList, N, M> Split<Cons<U, S>, Cons<PhantomData<N>, M>> for Cons<T, R>

where Self: Access<U, N>, <Self as Access<U, N>>::Remainder: Split<S, M>,

type Remainder = <<Cons<T, R> as Access<U, N>>::Remainder as Split<S, M>>::Remainder

fn split(self) -> (Cons<U, S>, Self::Remainder)

impl<T, R> Transform for Cons<T, R>

where Self: AnonType,

type Canon = Cons<T, R>

fn from_canon(anon: Self::Canon) -> Self

fn into_canon(self) -> Self::Canon

fn transform<O: Transform, N>(self) -> O

where Self::Canon: Shuffle<O::Canon, N>,

fn deep_transform<O: Transform, N>(self) -> O

where Self::Canon: DeepTransform<O::Canon, N>,

impl<A, F, T, O, E> TryFold<A, F> for Cons<T, Nil>

where F: CallOnce<(A, T), Output = Result<O, E>>,

type Output = O

type Error = CoCons<E, CoNil>

fn try_fold(self, acc: A, f: F) -> Result<Self::Output, Self::Error>

impl<A, F, T, R, O, E> TryFold<A, F> for Cons<T, R>

where F: CallMut<(A, T), Output = Result<O, E>>, R: NonEmpty + TryFold<O, F> + HList,

type Output = <R as TryFold<O, F>>::Output

type Error = CoCons<E, <R as TryFold<O, F>>::Error>

fn try_fold(self, acc: A, f: F) -> Result<Self::Output, Self::Error>

impl<A, F, T, O, E, N> TryFold<A, F, (N, ())> for Cons<T, Nil>

where F: CallOnce<(A, T), N, Output = Result<O, E>>,

type Output = O

type Error = CoCons<E, CoNil>

fn try_fold(self, acc: A, f: F) -> Result<Self::Output, Self::Error>

impl<A, F, T, R, O, E, N, M> TryFold<A, F, (N, M)> for Cons<T, R>

where F: CallMut<(A, T), N, Output = Result<O, E>>, R: NonEmpty + TryFold<O, F, M> + HList,

type Output = <R as TryFold<O, F, M>>::Output

type Error = CoCons<E, <R as TryFold<O, F, M>>::Error>

fn try_fold(self, acc: A, f: F) -> Result<Self::Output, Self::Error>

impl<T, U, R: UnZip> UnZip for Cons<(T, U), R>

type Left = Cons<T, <R as UnZip>::Left>

type Right = Cons<U, <R as UnZip>::Right>

type Flipped = Cons<(U, T), <R as UnZip>::Flipped>

fn unzip(self) -> (Self::Left, Self::Right)

fn flip(self) -> Self::Flipped

impl<T, U, R: Zip<S>, S> Zip<Cons<U, S>> for Cons<T, R>

type Output = Cons<(T, U), <R as Zip<S>>::Output>

fn zip(self, other: Cons<U, S>) -> Self::Output

impl<T, R: AnonType, Name> AnonType for Cons<Named<T, Name>, R>

impl<T, R: AnonType> AnonType for Cons<Unnamed<T>, R>

impl<T: Copy, R: Copy> Copy for Cons<T, R>

impl<T: Eq, R: Eq> Eq for Cons<T, R>

impl<T, R: HList> HList for Cons<T, R>

impl<T, R: HList> NonEmpty for Cons<T, R>

impl<T, R> StructuralPartialEq for Cons<T, R>