Struct frunk_core::hlist::HNil [−][src]
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);Run
Methods
impl HNil
[src]
impl HNil
pub fn len(&self) -> usize where
Self: HList,
[src]
pub fn len(&self) -> usize where
Self: HList,
pub fn prepend<H>(self, h: H) -> HCons<H, Self> where
Self: HList,
[src]
pub fn prepend<H>(self, h: H) -> HCons<H, Self> where
Self: 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");Run
pub fn sculpt<Ts, Indices>(self) -> (Ts, Self::Remainder) where
Self: Sculptor<Ts, Indices>,
[src]
pub fn sculpt<Ts, Indices>(self) -> (Ts, Self::Remainder) where
Self: 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]);Run
pub fn into_reverse(self) -> Self::Output where
Self: IntoReverse,
[src]
pub fn into_reverse(self) -> Self::Output where
Self: 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], )Run
pub fn to_ref<'a>(&'a self) -> Self::Output where
Self: ToRef<'a>,
[src]
pub fn to_ref<'a>(&'a self) -> Self::Output where
Self: 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]);Run
pub fn map<F>(self, mapper: F) -> Self::Output where
Self: HMappable<F>,
[src]
pub fn map<F>(self, mapper: F) -> Self::Output where
Self: 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]);Run
pub fn foldl<Folder, Acc>(self, folder: Folder, acc: Acc) -> Self::Output where
Self: HFoldLeftable<Folder, Acc>,
[src]
pub fn foldl<Folder, Acc>(self, folder: Folder, acc: Acc) -> Self::Output where
Self: 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); accRun
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)Run
pub fn foldr<Folder, Init>(self, folder: Folder, init: Init) -> Self::Output where
Self: HFoldRightable<Folder, Init>,
[src]
pub fn foldr<Folder, Init>(self, folder: Folder, init: Init) -> Self::Output where
Self: 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 Option
s 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
andHNil
. - Substitute each
h_cons
with a function, and substituteHNil
withinit
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))...)))Run
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)Run
Trait Implementations
impl PartialEq for HNil
[src]
impl PartialEq for HNil
fn eq(&self, other: &HNil) -> bool
[src]
fn eq(&self, other: &HNil) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl Debug for HNil
[src]
impl Debug for HNil
fn fmt(&self, f: &mut Formatter) -> Result
[src]
fn fmt(&self, f: &mut Formatter) -> Result
Formats the value using the given formatter. Read more
impl Eq for HNil
[src]
impl Eq for HNil
impl Clone for HNil
[src]
impl Clone for HNil
fn clone(&self) -> HNil
[src]
fn clone(&self) -> HNil
Returns a copy of the value. Read more
fn clone_from(&mut self, source: &Self)
1.0.0[src]
fn clone_from(&mut self, source: &Self)
Performs copy-assignment from source
. Read more
impl Copy for HNil
[src]
impl Copy for HNil
impl PartialOrd for HNil
[src]
impl PartialOrd for HNil
fn partial_cmp(&self, other: &HNil) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &HNil) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
fn gt(&self, other: &Rhs) -> bool
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl Ord for HNil
[src]
impl Ord for HNil
fn cmp(&self, other: &HNil) -> Ordering
[src]
fn cmp(&self, other: &HNil) -> Ordering
This method returns an Ordering
between self
and other
. Read more
fn max(self, other: Self) -> Self
1.21.0[src]
fn max(self, other: Self) -> Self
Compares and returns the maximum of two values. Read more
fn min(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
Compares and returns the minimum of two values. Read more
impl Hash for HNil
[src]
impl Hash for HNil
fn hash<__H: Hasher>(&self, state: &mut __H)
[src]
fn hash<__H: Hasher>(&self, state: &mut __H)
Feeds this value into the given [Hasher
]. Read more
fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
Feeds a slice of this type into the given [Hasher
]. Read more
impl HList for HNil
[src]
impl HList for HNil
const LEN: usize
LEN: usize = 0
Returns the length of a given HList type without making use of any references, or in fact, any values at all. Read more
fn static_len() -> usize
[src]
fn static_len() -> usize
: 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. Read more
fn length(&self) -> u32
[src]
fn length(&self) -> u32
: Please use len() or static_len() instead.
fn len(&self) -> usize
[src]
fn len(&self) -> usize
Returns the length of a given HList Read more
fn prepend<H>(self, h: H) -> HCons<H, Self>
[src]
fn prepend<H>(self, h: H) -> HCons<H, Self>
Prepends an item to the current HList Read more
impl<RHS> Add<RHS> for HNil where
RHS: HList,
[src]
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
[src]
fn add(self, rhs: RHS) -> RHS
Performs the +
operation.
impl<Source> Sculptor<HNil, HNil> for Source
[src]
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, Self::Remainder)
[src]
fn sculpt(self) -> (HNil, Self::Remainder)
Consumes the current HList and returns an HList with the requested shape. Read more
impl IntoReverse for HNil
[src]
impl IntoReverse for HNil
impl<F> HMappable<F> for HNil
[src]
impl<F> HMappable<F> for HNil
type Output = HNil
fn map(self, _: F) -> Self::Output
[src]
fn map(self, _: F) -> Self::Output
Apply a function to each element of an HList. Read more
impl<F, Init> HFoldRightable<F, Init> for HNil
[src]
impl<F, Init> HFoldRightable<F, Init> for HNil
type Output = Init
fn foldr(self, _: F, i: Init) -> Self::Output
[src]
fn foldr(self, _: F, i: Init) -> Self::Output
Perform a right fold over an HList. Read more
impl<'a> ToRef<'a> for HNil
[src]
impl<'a> ToRef<'a> for HNil
impl<F, Acc> HFoldLeftable<F, Acc> for HNil
[src]
impl<F, Acc> HFoldLeftable<F, Acc> for HNil
type Output = Acc
fn foldl(self, _: F, acc: Acc) -> Self::Output
[src]
fn foldl(self, _: F, acc: Acc) -> Self::Output
Perform a left fold over an HList. Read more
impl<T> Into<Vec<T>> for HNil
[src]
impl<T> Into<Vec<T>> for HNil
impl Default for HNil
[src]
impl Default for HNil
impl<Choices> CoproductSubsetter<CNil, HNil> for Choices
[src]
impl<Choices> CoproductSubsetter<CNil, HNil> for Choices
type Remainder = Self
fn subset(self) -> Result<CNil, Self::Remainder>
[src]
fn subset(self) -> Result<CNil, Self::Remainder>
Extract a subset of the possible types in a coproduct (or get the remaining possibilities) Read more
impl CoproductEmbedder<CNil, HNil> for CNil
[src]
impl CoproductEmbedder<CNil, HNil> for CNil
impl<Head, Tail> CoproductEmbedder<Coproduct<Head, Tail>, HNil> for CNil where
CNil: CoproductEmbedder<Tail, HNil>,
[src]
impl<Head, Tail> CoproductEmbedder<Coproduct<Head, Tail>, HNil> for CNil where
CNil: CoproductEmbedder<Tail, HNil>,
fn embed(self) -> Coproduct<Head, Tail>
[src]
fn embed(self) -> Coproduct<Head, Tail>
Convert a coproduct into another that can hold its variants. Read more
impl IntoUnlabelled for HNil
[src]
impl IntoUnlabelled for HNil
Implementation for HNil
type Output = HNil
fn into_unlabelled(self) -> Self::Output
[src]
fn into_unlabelled(self) -> Self::Output
Turns the current HList into an unlabelled one. Read more
impl IntoValueLabelled for HNil
[src]
impl IntoValueLabelled for HNil
type Output = HNil
fn into_value_labelled(self) -> Self::Output
[src]
fn into_value_labelled(self) -> Self::Output
Turns the current HList into a value-labelled one. Read more
impl From<()> for HNil
[src]
impl From<()> for HNil