dynamic-list 0.3.0

A powerful and efficient implementation of dynamic lists with versatile data structures, capable of storing any type!
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
61
62
63
64
65
66
67
68
69
70

#[test]
fn example_one() {
    use dynamic_list::*;
    use typenum::*;

    // Chain access:
    let array = array![1u8, "hello", true, "world"];
    assert_eq!(array.forward().next().value(), &"hello");
    assert_eq!(array.backward().value(), &"world");

    // Index access:
    let list = list![1u8, "hello", true, "world"];
    assert_eq!(Index::<U1>::index(list.forward()), &"hello");
    assert_eq!(Index::<U3>::index(list.forward()), &"world");
}

#[test]
fn example_two() {
    use dynamic_list::{list::Node, *};
    // Iterator
    trait Concat {
        fn concat(&self) -> String;
    }
    impl<V: ToString + Clone> Concat for Node<V> {
        fn concat(&self) -> String {
            self.value().to_string()
        }
    }
    impl<V: ToString + Clone, N: Concat> Concat for Node<V, N> {
        fn concat(&self) -> String {
            format!("{}{}", self.value().to_string(), self.next().concat())
        }
    }

    let list = list![1u8, "_hello", -3i32];
    assert_eq!(list.forward().concat(), "1_hello-3");
    assert_eq!(list.backward().concat(), "-3_hello1");
}

#[test]
fn example_three() {
    use dynamic_list::{list::Node, *};
    // Polymorphic trait
    trait Even {
        fn even(&self) -> usize;
    }
    impl<T: Clone + TryInto<usize>> Even for T {
        fn even(&self) -> usize {
            (self.clone().try_into().unwrap_or(1) + 1) % 2
        }
    }

    // Iterator
    trait NumberEven {
        fn evens(&self) -> usize;
    }
    impl<V: Even> NumberEven for Node<V> {
        fn evens(&self) -> usize {
            self.value().even()
        }
    }
    impl<V: Even, N: NumberEven> NumberEven for Node<V, N> {
        fn evens(&self) -> usize {
            self.value().even() + self.next().evens()
        }
    }

    let list = list![false, 1, 2u8, -3, 4isize];
    assert_eq!(list.forward().evens(), 3);
}