hetseq 0.2.0

Defines traits and types to work with heterogenous sequences
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
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109


use {Foldable, Functor, List, Queue};
#[cfg(feature="nightly")]
use IntoRefIter;
#[cfg(feature="nightly")]
use std::fmt::Display;

#[cfg(not(feature="nightly"))]
mod functions {
use std::fmt::Display;
use std::ops::Add;
use HetFn;

lambda!{
    let Formatter = |arg: Display| -> String {
        format!("{}", arg)
    }
}

lambda!{
    let Extender = |item, extend: Extend<item>| -> extend {
        extend.extend(::std::iter::once(item));
        extend
    }
}

lambda!{
    let Adder<X: Copy>(x: X) = |value: Add<X>| -> value::Output {
        value + *x
    }
}

lambda!{
    let AdderBorrowed<X: Clone>(x: &'a X) = |value: Add<X>| -> value::Output {
        value + X::clone(x)
    }
}

}

#[cfg(feature="nightly")]
mod functions {
use super::*;

lambda!{
    let Formatter = |arg: Display| -> String {
        format!("{}", arg)
    }
}

lambda!{
    let Extender = |item, extend: Extend<item>| -> extend {
        extend.extend(::std::iter::once(item));
        extend
    }
}

}

use self::functions::{Formatter, Extender, Adder, AdderBorrowed};

const EXPECT: [&'static str; 3] = ["1", "2.5", "qwe"];

#[test]
fn test_macro() {
    let list_macro = hlist![1, 2.5, "qwe"];
    let list_manual = List::new().push("qwe").push(2.5).push(1);
    assert_eq!(list_macro, list_manual);

    let queue_macro = hqueue![1, 2.5, "qwe"];
    let queue_manual = Queue::new().push(1).push(2.5).push("qwe");
    assert_eq!(queue_macro, queue_manual);
}

#[test]
fn test_map_fold() {
    let queue = Queue::new().push(1).push(2.5).push("qwe");
    let queue = queue.fmap(Formatter).fold(Vec::new(), Extender);
    assert_eq!(queue, EXPECT);

    let list = List::new().push("qwe").push(2.5).push(1);
    let list = list.fmap(Formatter).fold(Vec::new(), Extender);
    assert_eq!(list, EXPECT);
}

#[cfg(feature="nightly")]
#[test]
fn test_unsize_ref_iter() {
    let list = List::new().push("qwe").push(2.5).push(1);
    let list = list
        .into_ref_iter::<ToString>()
        .map(ToString::to_string)
        .collect::<Vec<_>>();

    assert_eq!(list, EXPECT);
}


#[test]
fn text_contextual() {
    let list = hlist![2, 1];
    let list = list.fmap(Adder::new(3));
    assert_eq!(list, hlist![5, 4]);


    let list = hlist![2, 1];
    let list = list.fmap(AdderBorrowed::new(&3));
    assert_eq!(list, hlist![5, 4]);
}