Struct typsy::hlist::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

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

pub fn get(&self) -> &T

pub 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::Remainder>

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

pub fn get(&self) -> &U

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

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

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

impl<'a, F, T: 'a> Any<'a, F, ()> for Cons<T, Nil> where
    F: CallOnce<(&'a T,), Output = bool>, 

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

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

pub fn any(&'a self, mut 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>, 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub 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::Output

pub 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

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

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

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

Returns a copy of the value.

pub 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::Output>

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

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

type HList = Self

pub fn into_hlist(self) -> Self::HList

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

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

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

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

Formats the value using the given formatter.

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

pub 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>

pub 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>, 

pub fn deep_transform_from(list: L) -> Self

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

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

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

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

Feeds this value into the given Hasher.

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

Feeds a slice of this type into the given Hasher.

impl<T, R: CoProd, C, N, M> IntoSubset<CoCons<T, R>, Cons<PhantomData<N>, M>> for C where
    C: Access<T, N>,
    C::Remainder: IntoSubset<R, M>, 

type Remainder = <C::Remainder as IntoSubset<R, M>>::Remainder

pub fn into_subset(self) -> Result<CoCons<T, R>, Self::Remainder>

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>, 

pub fn into_superset(self) -> C

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

type Output = Cons<F::Output, Nil>

pub 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::Output, R::Output>

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

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

type Output = Cons<F::Output, Nil>

pub 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::Output, R::Output>

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

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

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

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

This method returns an Ordering between self and other.

#[must_use]pub fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]pub fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

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

pub fn eq(&self, other: &Cons<T, R>) -> bool

This method tests for self and other values to be equal, and is used by ==.

pub fn ne(&self, other: &Cons<T, R>) -> bool

This method tests for !=.

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

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

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

pub fn lt(&self, other: &Cons<T, R>) -> bool

This method tests less than (for self and other) and is used by the < operator.

pub fn le(&self, other: &Cons<T, R>) -> bool

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

pub fn gt(&self, other: &Cons<T, R>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

pub fn ge(&self, other: &Cons<T, R>) -> bool

This method 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::Value

type Remainder = Cons<T, R::Remainder>

pub 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

pub 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::Remainder: Split<S, M>, 

type Remainder = <Self::Remainder as Split<S, M>>::Remainder

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

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

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

impl<T, R> Transform for Cons<T, R> where
    Self: AnonType, 

type Canon = Self

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

pub fn into_canon(self) -> Self::Canon

pub fn transform<O: Transform, N>(self) -> O where
    Self::Canon: Shuffle<O::Canon, N>, 

pub 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>

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

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

type Output = R::Output

type Error = CoCons<E, R::Error>

pub fn try_fold(self, acc: A, mut 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>

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

impl<A, F, T, R: HList, 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>, 

type Output = R::Output

type Error = CoCons<E, R::Error>

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

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

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

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

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

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

pub 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::Output>

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