Struct frunk::hlist::HNil

source ·

pub struct HNil;

Expand description

Represents the right-most end of a heterogeneous list

§Examples

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

Implementations§

source §

impl HNil

source

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

Returns the length of a given HList

§Examples

use frunk_core::hlist;

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

source

pub fn is_empty(&self) -> bool
where HNil: HList,

Returns whether a given HList is empty

§Examples

use frunk_core::hlist;

let h = hlist![];
assert!(h.is_empty());

source

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

Prepend an item to the current HList

§Examples

use frunk_core::hlist;

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");

source

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/sculpt 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

use frunk_core::{hlist, HList};

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]);

source

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

Reverse the HList.

§Examples

use frunk_core::hlist;

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

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

source

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

use frunk_core::hlist;

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

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

source

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

use frunk_core::hlist;

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

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

source

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;
use frunk_core::hlist;

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]);

source

pub fn zip<Other>(self, other: Other) -> <HNil as HZippable<Other>>::Zipped
where HNil: HZippable<Other>,

Zip two HLists together.

This zips a HList![A1, B1, ..., C1] with a HList![A2, B2, ..., C2] to make a HList![(A1, A2), (B1, B2), ..., (C1, C2)]

§Example

use frunk::HNil;
use frunk_core::hlist;

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

let h1 = hlist![1, false, 42f32];
let h2 = hlist![true, "foo", 2];

let zipped = h1.zip(h2);
assert_eq!(zipped, hlist![
    (1, true),
    (false, "foo"),
    (42f32, 2),
]);

source

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).
A single Poly.

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

use frunk_core::hlist;

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)

source

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.
A single Poly.

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

use frunk_core::hlist;

let nil = hlist![];

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

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

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

assert_eq!(9001, folded)

source

pub fn extend<Other>(self, other: Other) -> <HNil as Add<Other>>::Output
where HNil: Add<Other>, Other: HList,

Extend the contents of this HList with another HList

This exactly the same as the Add impl.

§Examples

use frunk_core::hlist;

let first = hlist![0u8, 1u16];
let second = hlist![2u32, 3u64];

assert_eq!(first.extend(second), hlist![0u8, 1u16, 2u32, 3u64]);