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
55
56
57
58
59
60

use crate::{Cons, HList, Nil};

use super::{Index, ManyIndex, Remove};

/// Move many elements out of the heterogenous list by their types.
pub trait RemoveMany<T, I>: HList
where
    T: HList,
    I: ManyIndex,
{
    /// Remaining part of the heterogenous list without removed elements.
    type Remainder: HList;

    /// Moves many elements out of the heterogenous list by their types.
    ///
    /// # Examples
    ///
    /// ```
    /// use hlist2::{hlist, HList, ops::RemoveMany};
    ///
    /// let list = hlist![1, 2.0, true, "hello world"];
    /// let (list, remainder): (HList![f32, i32, &str], _) = list.remove_many();
    /// assert_eq!(list, hlist![2.0, 1, "hello world"]);
    /// assert_eq!(remainder, hlist![true]);
    /// ```
    fn remove_many(self) -> (T, Self::Remainder);
}

impl<T> RemoveMany<Nil, Nil> for T
where
    T: HList,
{
    type Remainder = Self;

    fn remove_many(self) -> (Nil, Self::Remainder) {
        (Nil, self)
    }
}

impl<Head, Tail, OtherHead, OtherTail, IndexHead, IndexTail>
    RemoveMany<Cons<OtherHead, OtherTail>, Cons<IndexHead, IndexTail>> for Cons<Head, Tail>
where
    OtherTail: HList,
    IndexHead: Index,
    IndexTail: ManyIndex,
    Self: Remove<OtherHead, IndexHead>,
    <Self as Remove<OtherHead, IndexHead>>::Remainder: RemoveMany<OtherTail, IndexTail>,
{
    type Remainder = <<Self as Remove<OtherHead, IndexHead>>::Remainder as RemoveMany<
        OtherTail,
        IndexTail,
    >>::Remainder;

    fn remove_many(self) -> (Cons<OtherHead, OtherTail>, Self::Remainder) {
        let (head, remainder) = self.remove();
        let (tail, remainder) = remainder.remove_many();
        let list = Cons(head, tail);
        (list, remainder)
    }
}