Module frunk_core::hlist

source ·
Expand description

Module that holds HList data structures, implementations, and typeclasses.

Typically, you would want to use the hlist! macro to make it easier for you to use HList.

§Examples

use frunk_core::{hlist, HList, poly_fn};

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

// Reverse
let h1 = hlist![true, "hi"];
assert_eq!(h1.into_reverse(), hlist!["hi", true]);

// foldr (foldl also available)
let h2 = hlist![1, false, 42f32];
let folded = h2.foldr(
            hlist![|acc, i| i + acc,
                   |acc, _| if acc > 42f32 { 9000 } else { 0 },
                   |acc, f| f + acc],
            1f32
    );
assert_eq!(folded, 9001);

let h3 = hlist![9000, "joe", 41f32];
// Mapping over an HList with a polymorphic function,
// declared using the poly_fn! macro (you can choose to impl
// it manually)
let mapped = h3.map(
  poly_fn![
    |f: f32|   -> f32 { f + 1f32 },
    |i: isize| -> isize { i + 1 },
    ['a] |s: &'a str| -> &'a str { s }
  ]);
assert_eq!(mapped, hlist![9001, "joe", 42f32]);

// Plucking a value out by type
let h4 = hlist![1, "hello", true, 42f32];
let (t, remainder): (bool, _) = h4.pluck();
assert!(t);
assert_eq!(remainder, hlist![1, "hello", 42f32]);

// Resculpting an HList
let h5 = hlist![9000, "joe", 41f32, true];
let (reshaped, remainder2): (HList![f32, i32, &str], _) = h5.sculpt();
assert_eq!(reshaped, hlist![41f32, 9000, "joe"]);
assert_eq!(remainder2, hlist![true]);

Modules§

Structs§

  • HCons
    Represents the most basic non-empty HList. Its value is held in head while its tail is another HList.
  • HNil
    Represents the right-most end of a heterogeneous list

Traits§

  • HFoldLeftable
    Trait for performing a left fold over an HList
  • HFoldRightable
    Trait for performing a right fold over an HList
  • HList
    Typeclass for HList-y behaviour
  • HMappable
    Trait for mapping over an HList
  • HZippable
    Trait for zipping HLists
  • IntoTuple2
    Trait for transforming an HList into a nested tuple.
  • LiftFrom
    Indexed type conversions of T -> Self with index I. This is a generalized version of From which for example allows the caller to use default values for parts of Self and thus “fill in the blanks”.
  • LiftInto
    An indexed conversion that consumes self, and produces a T. To produce T, the index I may be used to for example “fill in the blanks”. LiftInto is the reciprocal of LiftFrom.
  • Plucker
    Trait defining extraction from a given HList
  • Sculptor
    Trait for pulling out some subset of an HList, using type inference.
  • Selector
    Trait for borrowing an HList element by type

Functions§

  • h_cons
    Takes an element and an Hlist and returns another one with the element prepended to the original list. The original list is consumed
  • lift_from
    Free function version of LiftFrom::lift_from.