Struct frunk::hlist::HNil

pub struct HNil;

Represents the right-most end of a heterogeneous list

Examples

let h = h_cons(1, HNil);
let h = h.head;
assert_eq!(h, 1);

Methods

impl HNil

pub fn len(&self) -> usize where
    HNil: HList, 

Returns the length of a given HList

Examples

let h = hlist![1, "hi"];
assert_eq!(h.len(), 2);

pub fn prepend<H>(self, h: H) -> HCons<H, HNil> where
    HNil: HList, 

Prepend an item to the current HList

Examples

let h1 = hlist![1, "hi"];
let h2 = h1.prepend(true);
let (a, (b, c)) = h2.into_tuple2();
assert_eq!(a, true);
assert_eq!(b, 1);
assert_eq!(c, "hi");

pub fn sculpt<Ts, Indices>(
    self
) -> (Ts, <HNil as Sculptor<Ts, Indices>>::Remainder) where
    HNil: Sculptor<Ts, Indices>, 

Consume the current HList and return an HList with the requested shape.

sculpt allows us to extract/reshape/scult the current HList into another shape, provided that the requested shape's types are are contained within the current HList.

The Indices type parameter allows the compiler to figure out that Ts and Self can be morphed into each other.

Examples

let h = hlist![9000, "joe", 41f32, true];
let (reshaped, remainder): (Hlist![f32, i32, &str], _) = h.sculpt();
assert_eq!(reshaped, hlist![41f32, 9000, "joe"]);
assert_eq!(remainder, hlist![true]);

pub fn into_reverse(self) -> <HNil as IntoReverse>::Output where
    HNil: IntoReverse, 

Reverse the HList.

Examples

assert_eq!(hlist![].into_reverse(), hlist![]);

assert_eq!(
    hlist![1, "hello", true, 42f32].into_reverse(),
    hlist![42f32, true, "hello", 1],
)

pub fn to_ref<'a>(&'a self) -> <HNil as ToRef<'a>>::Output where
    HNil: ToRef<'a>, 

Return an HList where the contents are references to the original HList on which this method was called.

Examples

assert_eq!(hlist![].to_ref(), hlist![]);

assert_eq!(hlist![1, true].to_ref(), hlist![&1, &true]);

pub fn to_mut<'a>(&'a mut self) -> <HNil as ToMut<'a>>::Output where
    HNil: ToMut<'a>, 

Return an HList where the contents are mutable references to the original HList on which this method was called.

Examples

assert_eq!(hlist![].to_mut(), hlist![]);

assert_eq!(hlist![1, true].to_mut(), hlist![&mut 1, &mut true]);

pub fn map<F>(self, mapper: F) -> <HNil as HMappable<F>>::Output where
    HNil: HMappable<F>, 

Apply a function to each element of an HList.

This transforms some Hlist![A, B, C, ..., E] into some Hlist![T, U, V, ..., Z]. A variety of types are supported for the folder argument:

• An hlist![] of closures (one for each element).
• A single closure (for mapping an HList that is homogenous).
• A single Poly.

Examples

use ::frunk::HNil;

assert_eq!(HNil.map(HNil), HNil);

let h = hlist![1, false, 42f32];

// Sadly we need to help the compiler understand the bool type in our mapper

let mapped = h.to_ref().map(hlist![
    |&n| n + 1,
    |b: &bool| !b,
    |&f| f + 1f32]);
assert_eq!(mapped, hlist![2, true, 43f32]);

// There is also a value-consuming version that passes values to your functions
// instead of just references:

let mapped2 = h.map(hlist![
    |n| n + 3,
    |b: bool| !b,
    |f| f + 8959f32]);
assert_eq!(mapped2, hlist![4, true, 9001f32]);

pub fn foldl<Folder, Acc>(
    self,
    folder: Folder,
    acc: Acc
) -> <HNil as HFoldLeftable<Folder, Acc>>::Output where
    HNil: HFoldLeftable<Folder, Acc>, 

Perform a left fold over an HList.

This transforms some Hlist![A, B, C, ..., E] into a single value by visiting all of the elements in left-to-right order. A variety of types are supported for the mapper argument:

• An hlist![] of closures (one for each element).
• A single closure (for folding an HList that is homogenous).

The accumulator can freely change type over the course of the call. When called with a list of N functions, an expanded form of the implementation with type annotations might look something like this:

let acc: Acc0 = init_value;
let acc: Acc1 = f1(acc, x1);
let acc: Acc2 = f2(acc, x2);
let acc: Acc3 = f3(acc, x3);
...
let acc: AccN = fN(acc, xN);
acc

Examples

let nil = hlist![];

assert_eq!(nil.foldl(hlist![], 0), 0);

let h = hlist![1, false, 42f32];

let folded = h.to_ref().foldl(
    hlist![
        |acc, &i| i + acc,
        |acc, b: &bool| if !b && acc > 42 { 9000f32 } else { 0f32 },
        |acc, &f| f + acc
    ],
    1
);

assert_eq!(42f32, folded);

// There is also a value-consuming version that passes values to your folding
// functions instead of just references:

let folded2 = h.foldl(
    hlist![
        |acc, i| i + acc,
        |acc, b: bool| if !b && acc > 42 { 9000f32 } else { 0f32 },
        |acc, f| f + acc
    ],
    8918
);

assert_eq!(9042f32, folded2)

pub fn foldr<Folder, Init>(
    self,
    folder: Folder,
    init: Init
) -> <HNil as HFoldRightable<Folder, Init>>::Output where
    HNil: HFoldRightable<Folder, Init>, 

Perform a right fold over an HList.

This transforms some Hlist![A, B, C, ..., E] into a single value by visiting all of the elements in reverse order. A variety of types are supported for the mapper argument:

• An hlist![] of closures (one for each element).
• A single closure (for folding an HList that is homogenous), taken by reference.

The accumulator can freely change type over the course of the call.

Comparison to foldl

While the order of element traversal in foldl may seem more natural, foldr does have its use cases, in particular when it is used to build something that reflects the structure of the original HList (such as folding an HList of Options into an Option of an HList). An implementation of such a function using foldl will tend to reverse the list, while foldr will tend to preserve its order.

The reason for this is because foldr performs what is known as "structural induction;" it can be understood as follows:

• Write out the HList in terms of h_cons and HNil.
• Substitute each h_cons with a function, and substitute HNil with init

the list:
    h_cons(x1, h_cons(x2, h_cons(x3, ...h_cons(xN, HNil))...)))

becomes:
       f1( x1,    f2( x2,    f3( x3, ...   fN( xN, init))...)))

Examples

let nil = hlist![];

assert_eq!(nil.foldr(hlist![], 0), 0);

let h = hlist![1, false, 42f32];

let folded = h.foldr(
    hlist![
        |i, acc| i + acc,
        |b: bool, acc| if !b && acc > 42f32 { 9000 } else { 0 },
        |f, acc| f + acc
    ],
    1f32
);

assert_eq!(9001, folded)

Trait Implementations

impl IntoValueLabelled for HNil

type Output = HNil

fn into_value_labelled(self) -> <HNil as IntoValueLabelled>::Output

Turns the current HList into a value-labelled one.

impl PartialEq<HNil> for HNil

fn eq(&self, other: &HNil) -> bool

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

#[must_use]

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

This method tests for !=.

impl IntoUnlabelled for HNil

Implementation for HNil

type Output = HNil

fn into_unlabelled(self) -> <HNil as IntoUnlabelled>::Output

Turns the current HList into an unlabelled one.

impl<F, Acc> HFoldLeftable<F, Acc> for HNil

type Output = Acc

fn foldl(self, F, acc: Acc) -> <HNil as HFoldLeftable<F, Acc>>::Output

Perform a left fold over an HList.

impl HList for HNil

const LEN: usize

Returns the length of a given HList type without making use of any references, or in fact, any values at all.

fn static_len() -> usize

Deprecated since 0.1.31:

Please use LEN instead

Returns the length of a given HList type without making use of any references, or in fact, any values at all.

fn length(&self) -> u32

Deprecated since 0.1.30:

Please use len() or static_len() instead.

fn len(&self) -> usize

Returns the length of a given HList

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

Prepends an item to the current HList

impl Clone for HNil

fn clone(&self) -> HNil

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<RHS> Add<RHS> for HNil where
    RHS: HList, 

type Output = RHS

The resulting type after applying the + operator.

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

Performs the + operation.

impl PartialOrd<HNil> for HNil

fn partial_cmp(&self, other: &HNil) -> Option<Ordering>

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

#[must_use]

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

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

#[must_use]

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

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

#[must_use]

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

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

#[must_use]

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

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

impl From<()> for HNil

fn from(()) -> HNil

Performs the conversion.

impl IntoReverse for HNil

type Output = HNil

fn into_reverse(self) -> <HNil as IntoReverse>::Output

Reverses a given data structure.

impl Debug for HNil

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

Formats the value using the given formatter.

impl Copy for HNil

impl Eq for HNil

impl<'a> ToMut<'a> for HNil

type Output = HNil

fn to_mut(&'a mut self) -> <HNil as ToMut<'a>>::Output

impl<'a> ToRef<'a> for HNil

type Output = HNil

fn to_ref(&'a self) -> <HNil as ToRef<'a>>::Output

impl Default for HNil

fn default() -> HNil

Returns the "default value" for a type.

impl<F, Init> HFoldRightable<F, Init> for HNil

type Output = Init

fn foldr(self, F, i: Init) -> <HNil as HFoldRightable<F, Init>>::Output

Perform a right fold over an HList.

impl CoproductEmbedder<CNil, HNil> for CNil

fn embed(self) -> CNil

Convert a coproduct into another that can hold its variants.

impl<Head, Tail> CoproductEmbedder<Coproduct<Head, Tail>, HNil> for CNil where
    CNil: CoproductEmbedder<Tail, HNil>, 

fn embed(self) -> Coproduct<Head, Tail>

Convert a coproduct into another that can hold its variants.

impl<F> HMappable<F> for HNil

type Output = HNil

fn map(self, F) -> <HNil as HMappable<F>>::Output

Apply a function to each element of an HList.

impl<T> Into<Vec<T>> for HNil

fn into(self) -> Vec<T>

Performs the conversion.

impl<SourceHead, SourceTail> Transmogrifier<HNil, HNil> for HCons<SourceHead, SourceTail>

Implementation of Transmogrifier for when the Target is empty and the Source is non-empty.

fn transmogrify(self) -> HNil

Consume this current object and return an object of the Target type.

impl Transmogrifier<HNil, HNil> for HNil

Implementation of Transmogrifier for when the Target is empty and the Source is empty.

fn transmogrify(self) -> HNil

Consume this current object and return an object of the Target type.

impl<Choices> CoproductSubsetter<CNil, HNil> for Choices

type Remainder = Choices

fn subset(
    self
) -> Result<CNil, <Choices as CoproductSubsetter<CNil, HNil>>::Remainder>

Extract a subset of the possible types in a coproduct (or get the remaining possibilities)

impl Hash for HNil

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

Feeds this value into the given [Hasher].

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

Feeds a slice of this type into the given [Hasher].

impl<Source> Sculptor<HNil, HNil> for Source

Implementation for when the target is an empty HList (HNil)

Index type is HNil because we don't need an index for finding HNil

type Remainder = Source

fn sculpt(self) -> (HNil, <Source as Sculptor<HNil, HNil>>::Remainder)

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

impl Ord for HNil

fn cmp(&self, other: &HNil) -> Ordering

This method returns an Ordering between self and other.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

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

🔬 This is a nightly-only experimental API. (clamp)

Returns max if self is greater than max, and min if self is less than min. Otherwise this will return self. Panics if min > max.

impl Semigroup for HNil

Since () + () = (), the same is true for HNil

fn combine(&self, _: &Self) -> Self

Associative operation taking which combines two values.