Struct frunk_core::hlist::HCons

pub struct HCons<H, T> {
    pub head: H,
    pub tail: T,
}

Represents the most basic non-empty HList. Its value is held in head while its tail is another HList.

Fields

head: H

tail: T

Methods

impl<H, T> HCons<H, T>

fn pop(self) -> (H, T)

Returns the head of the list and the tail of the list as a tuple2. The original list is consumed

Examples

let h = hlist!("hi");
let (h, tail) = h.pop();
assert_eq!(h, "hi");
assert_eq!(tail, HNil);

Trait Implementations

impl<H: PartialEq, T: PartialEq> PartialEq for HCons<H, T>

fn eq(&self, __arg_0: &HCons<H, T>) -> bool

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

fn ne(&self, __arg_0: &HCons<H, T>) -> bool

This method tests for !=.

impl<H: Debug, T: Debug> Debug for HCons<H, T>

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<H: Eq, T: Eq> Eq for HCons<H, T>

impl<H: Clone, T: Clone> Clone for HCons<H, T>

fn clone(&self) -> HCons<H, T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<H: Copy, T: Copy> Copy for HCons<H, T>

impl<H: PartialOrd, T: PartialOrd> PartialOrd for HCons<H, T>

fn partial_cmp(&self, __arg_0: &HCons<H, T>) -> Option<Ordering>

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

fn lt(&self, __arg_0: &HCons<H, T>) -> bool

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

fn le(&self, __arg_0: &HCons<H, T>) -> bool

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

fn gt(&self, __arg_0: &HCons<H, T>) -> bool

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

fn ge(&self, __arg_0: &HCons<H, T>) -> bool

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

impl<H: Ord, T: Ord> Ord for HCons<H, T>

fn cmp(&self, __arg_0: &HCons<H, T>) -> Ordering

This method returns an Ordering between self and other.

impl<H, T: HList> HList for HCons<H, T>

fn length(&self) -> u32

Returns the length of a given HList

fn prepend<H>(self, h: H) -> HCons<H, Self>

Prepends an item to the current HList

impl<H, T, RHS> Add<RHS> for HCons<H, T> where T: Add<RHS>, RHS: HList

type Output = HCons<H, T::Output>

The resulting type after applying the + operator

fn add(self, rhs: RHS) -> Self::Output

The method for the + operator

impl<T, Tail> Selector<T, Here> for HCons<T, Tail>

fn get(&self) -> &T

Allows you to retrieve a unique type from an HList

impl<Head, Tail, FromTail, TailIndex> Selector<FromTail, There<TailIndex>> for HCons<Head, Tail> where Tail: Selector<FromTail, TailIndex>

fn get(&self) -> &FromTail

Allows you to retrieve a unique type from an HList

impl<T, Tail> Plucker<T, Here> for HCons<T, Tail>

Implementation when the pluck target is in head

type Remainder = Tail

What is left after you pluck the target from the Self

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

Returns the target with the remainder of the list in a pair

impl<Head, Tail, FromTail, TailIndex> Plucker<FromTail, There<TailIndex>> for HCons<Head, Tail> where Tail: Plucker<FromTail, TailIndex>

Implementation when the pluck target is in the tail

type Remainder = HCons<Head, Tail::Remainder>

What is left after you pluck the target from the Self

fn pluck(self) -> (FromTail, Self::Remainder)

Returns the target with the remainder of the list in a pair

impl<THead, TTail, SHead, STail, IndexHead, IndexTail> Sculptor<HCons<THead, TTail>, HCons<IndexHead, IndexTail>> for HCons<SHead, STail> where HCons<SHead, STail>: Plucker<THead, IndexHead>,
        HCons<SHead, STail>::Remainder: Sculptor<TTail, IndexTail>

Implementation for when we have a non-empty HCons target

Indices is HCons here because the compiler is being asked to figure out the Index for Plucking the first item of type THead out of Self and the rest (IndexTail) is for the Plucker's remainder induce.

type Remainder = HCons<SHead, STail>::Remainder::Remainder

fn sculpt(self) -> (HCons<THead, TTail>, Self::Remainder)

Consumes the current HList and returns an HList with the requested shape.

impl<H, Tail> IntoReverse for HCons<H, Tail> where Tail: IntoReverse,
        Tail::Output: Add<HCons<H, HNil>>

type Output = Tail::Output::Output

fn into_reverse(self) -> Self::Output

Reverses a given data structure.

impl<F, MapperHeadR, MapperTail, H, Tail> HMappable<HCons<F, MapperTail>> for HCons<H, Tail> where F: FnOnce(H) -> MapperHeadR,
        Tail: HMappable<MapperTail>

type Output = HCons<MapperHeadR, Tail::Output>

fn map(self, mapper: HCons<F, MapperTail>) -> Self::Output

Maps over the current data structure using functions stored in another data structure.

impl<F, FolderHeadR, FolderTail, H, Tail, Init> HFoldRightable<HCons<F, FolderTail>, Init> for HCons<H, Tail> where Tail: HFoldRightable<FolderTail, Init>,
        F: FnOnce(H, Tail::Output) -> FolderHeadR

type Output = FolderHeadR

fn foldr(self, folder: HCons<F, FolderTail>, init: Init) -> Self::Output

foldr over a data structure

impl<F, FolderHeadR, FolderTail, H, Tail, Acc> HFoldLeftable<HCons<F, FolderTail>, Acc> for HCons<H, Tail> where Tail: HFoldLeftable<FolderTail, FolderHeadR>,
        F: FnOnce(Acc, H) -> FolderHeadR

type Output = Tail::Output

fn foldl(self, folder: HCons<F, FolderTail>, acc: Acc) -> Self::Output

foldl over a data structure

impl<T1, T2> IntoTuple2 for HCons<T1, HCons<T2, HNil>>

type HeadType = T1

The 0 element in the output tuple

type TailOutput = T2

The 1 element in the output tuple

fn into_tuple2(self) -> (Self::HeadType, Self::TailOutput)

Turns an HList into nested Tuple2s, which are less troublesome to pattern match and have a nicer type signature.

impl<T, Tail> IntoTuple2 for HCons<T, Tail> where Tail: IntoTuple2

type HeadType = T

The 0 element in the output tuple

type TailOutput = (Tail::HeadType, Tail::TailOutput)

The 1 element in the output tuple

fn into_tuple2(self) -> (Self::HeadType, Self::TailOutput)

Turns an HList into nested Tuple2s, which are less troublesome to pattern match and have a nicer type signature.

impl<Label, Value, Tail> IntoUnlabelled for HCons<Field<Label, Value>, Tail> where Tail: IntoUnlabelled

Implementation when we have a non-empty HCons holding a label in its head

type Output = HCons<Value, Tail::Output>

fn into_unlabelled(self) -> Self::Output

Turns the current HList into an unlabelled on.