Struct Cons

Source

pub struct Cons<Head, Tail>(pub Head, pub Tail)
where
    Tail: ?Sized;

Expand description

Heterogenous list with head and tail values, where tail is another heterogenous list.

Tuple Fields§

§0: Head§1: Tail

Implementations§

Source §

impl<Head, Tail> Cons<Head, Tail>

Source

pub const fn new(head: Head, tail: Tail) -> Self

Constructs a new Cons with provided head and tail values.

§Examples

use hlist2::Cons;

let list = Cons::new(1, "hello world");
assert_eq!(list, Cons(1, "hello world"));

Source

pub fn into_head(self) -> Head

Converts self into head value, discarding its tail.

§Examples

use hlist2::Cons;

let list = Cons::new(1, "hello world");
let head = list.into_head();
assert_eq!(head, 1);

Source

pub fn into_tail(self) -> Tail

Converts self into tail value, discarding its head.

§Examples

use hlist2::Cons;

let list = Cons::new(1, "hello world");
let tail = list.into_tail();
assert_eq!(tail, "hello world");

Source §

impl<Head, Tail> Cons<Head, Tail>
where Tail: ?Sized,

Source

pub const fn head(&self) -> &Head

Borrows head value of self by reference.

§Examples

use hlist2::Cons;

let list = Cons::new(1, "hello world");
let head = list.head();
assert_eq!(head, &1);

Source

pub fn head_mut(&mut self) -> &mut Head

Borrows head value of self by mutable reference.

§Examples

use hlist2::Cons;

let mut list = Cons::new(1, "hello world");
let head = list.head_mut();
*head = 2;
assert_eq!(list, Cons(2, "hello world"));

Source

pub const fn tail(&self) -> &Tail

Borrows tail value of self by reference.

§Examples

use hlist2::Cons;

let list = Cons::new(1, "hello world");
let tail = list.tail();
assert_eq!(tail, &"hello world");

Source

pub fn tail_mut(&mut self) -> &mut Tail

Borrows tail value of self by mutable reference.

§Examples

use hlist2::Cons;

let mut list = Cons::new(1, "hello world");
let tail = list.tail_mut();
*tail = "привет, мир";
assert_eq!(list, Cons(1, "привет, мир"));

Trait Implementations§

Source §

impl<Head, Tail> Append for Cons<Head, Tail>
where Tail: Append,

Source §

type Output<T> = Cons<Head, <Tail as Append>::Output<T>>

Type of heterogenous list with new element.

Source §

fn append<T>(self, value: T) -> Self::Output<T>

Appends new element to the heterogenous list. Read more

Source §

impl<Head, Tail> AsMut<Cons<Head, Tail>> for Cons<Head, Tail>
where Tail: ?Sized,

Source §

fn as_mut(&mut self) -> &mut Cons<Head, Tail>

Converts this type into a mutable reference of the (usually inferred) input type.

Source §

impl<Head, Tail> AsRef<Cons<Head, Tail>> for Cons<Head, Tail>
where Tail: ?Sized,

Source §

fn as_ref(&self) -> &Cons<Head, Tail>

Converts this type into a shared reference of the (usually inferred) input type.

Source §

impl<Head: Clone, Tail> Clone for Cons<Head, Tail>
where Tail: ?Sized + Clone,

Source §

fn clone(&self) -> Cons<Head, Tail>

Returns a duplicate of the value. Read more

1.0.0 · Source§

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

Performs copy-assignment from source. Read more

Source §

impl<Head: Debug, Tail> Debug for Cons<Head, Tail>
where Tail: ?Sized + Debug,

Source §

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

Formats the value using the given formatter. Read more

Source §

impl<Head: Default, Tail> Default for Cons<Head, Tail>
where Tail: ?Sized + Default,

Source §

fn default() -> Cons<Head, Tail>

Returns the “default value” for a type. Read more

Source §

impl<Head, Tail> Extend for Cons<Head, Tail>
where Tail: Extend,

Source §

type Output<T> = Cons<Head, <Tail as Extend>::Output<T>> where T: HList

Type of heterogenous list extended with elements of another heterogenous list.

Source §

fn extend<T>(self, list: T) -> Self::Output<T>
where T: HList,

Extends heterogenous list with another heterogenous list. Read more

Source §

impl<Head, Tail> Flatten for Cons<Head, Tail>
where Head: Extend, Tail: Flatten,

Source §

type Output = <Head as Extend>::Output<<Tail as Flatten>::Output>

Flattened heterogenous list.

Source §

fn flatten(self) -> Self::Output

Flattens a heterogenous list of heterogenous lists, removing one level of indirection. Read more

Source §

impl<A, FHead, FTail, Head, Tail> Fold<A, Cons<FHead, FTail>> for Cons<Head, Tail>
where FHead: FnOnce(A, Head) -> A, Tail: Fold<A, FTail>,

Source §

fn fold(self, init: A, folder: Cons<FHead, FTail>) -> A

Folds every element into an accumulator by applying an operation via folder, returning the final result. Read more

Source §

impl<A, F, Head, Tail> Fold<A, F> for Cons<Head, Tail>
where F: FnMut(A, Head) -> A, Tail: Fold<A, F>,

Source §

fn fold(self, init: A, folder: F) -> A

Folds every element into an accumulator by applying an operation via folder, returning the final result. Read more

Source §

impl<A, F, Head, Tail> Fold<A, Folder<F>> for Cons<Head, Tail>
where F: FoldFn<A, Head>, Tail: Fold<A, Folder<F>>,

Source §

fn fold(self, init: A, folder: Folder<F>) -> A

Folds every element into an accumulator by applying an operation via folder, returning the final result. Read more

Source §