hlist2 0.0.15

Compile-time heterogeneous list implementation
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

use crate::{Cons, HList};

use super::{Get, Here, Index, Prepend, There};

/// Move element out of the heterogenous list by type.
pub trait Remove<T, I>: Get<T, I>
where
    I: Index,
{
    /// Remaining part of the heterogenous list without a removed element.
    type Remainder: HList;

    /// Moves element out of the heterogenous list by type.
    ///
    /// # Examples
    ///
    /// ```
    /// use hlist2::{hlist, ops::Remove};
    ///
    /// let list = hlist![0_i32, 1_i64, false];
    /// let (a, remainder): (i64, _) = list.remove();
    /// assert_eq!(a, 1);
    /// assert_eq!(remainder, hlist![0, false]);
    /// ```
    fn remove(self) -> (T, Self::Remainder);
}

impl<Head, Tail> Remove<Head, Here> for Cons<Head, Tail>
where
    Tail: HList,
{
    type Remainder = Tail;

    fn remove(self) -> (Head, Self::Remainder) {
        let Cons(head, tail) = self;
        (head, tail)
    }
}

impl<Head, Tail, FromTail, TailIndex> Remove<FromTail, There<TailIndex>> for Cons<Head, Tail>
where
    Tail: Remove<FromTail, TailIndex>,
    TailIndex: Index,
    Tail::Remainder: Prepend,
{
    type Remainder = <Tail::Remainder as Prepend>::Output<Head>;

    fn remove(self) -> (FromTail, Self::Remainder) {
        let Cons(head, tail) = self;
        let (removed, tail) = tail.remove();
        let remainder = tail.prepend(head);
        (removed, remainder)
    }
}