sqnc 1.0.0

Traits and adaptors for 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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

use crate::traits::*;
use core::iter;

/// A sequence that maps the values of an underlying sequence.
///
/// This struct is created by [`Sequence::map()`]. See its documentation for
/// more.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Map<Seq, F>(Seq, F);

impl<Seq, F> Map<Seq, F> {
    #[inline]
    pub(crate) fn new(sequence: Seq, f: F) -> Self {
        Self(sequence, f)
    }
}

impl<'this, Seq, F, B> SequenceTypes<'this> for Map<Seq, F>
where
    Seq: SequenceTypes<'this>,
    F: Fn(Seq::Item) -> B,
{
    type Item = B;
    type Iter = iter::Map<Seq::Iter, &'this F>;
}

impl<Seq, F, B> Sequence for Map<Seq, F>
where
    Seq: Sequence,
    F: for<'a> Fn(<Seq as SequenceTypes<'a>>::Item) -> B,
{
    #[inline]
    fn len(&self) -> usize {
        self.0.len()
    }

    #[inline]
    fn is_empty(&self) -> bool {
        self.0.is_empty()
    }

    #[inline]
    fn get(&self, index: usize) -> Option<B> {
        self.0.get(index).map(&self.1)
    }

    #[inline]
    fn rget(&self, rindex: usize) -> Option<B> {
        self.0.rget(rindex).map(&self.1)
    }

    #[inline]
    fn first(&self) -> Option<B> {
        self.0.first().map(&self.1)
    }

    #[inline]
    fn last(&self) -> Option<B> {
        self.0.last().map(&self.1)
    }

    #[inline]
    fn iter(&self) -> iter::Map<<Seq as SequenceTypes<'_>>::Iter, &'_ F> {
        self.0.iter().map(&self.1)
    }
}

#[cfg(test)]
mod tests {
    use super::Map;
    use crate::traits::*;

    #[test]
    fn len() {
        let x = Map::new(2..5, |v| v + 2);
        assert_eq!(x.len(), 3);
    }

    #[test]
    fn is_empty() {
        let x = Map::new(2..5, |v| v + 2);
        assert_eq!(x.is_empty(), false);
        let y = Map::new(2..2, |v: usize| v + 2);
        assert_eq!(y.is_empty(), true);
    }

    #[test]
    fn get() {
        let x = Map::new(2..5, |v| v + 2);
        assert_eq!(x.get(0), Some(4));
        assert_eq!(x.get(1), Some(5));
        assert_eq!(x.get(2), Some(6));
        assert_eq!(x.get(3), None);
    }

    #[test]
    fn rget() {
        let x = Map::new(2..5, |v| v + 2);
        assert_eq!(x.rget(0), Some(6));
        assert_eq!(x.rget(1), Some(5));
        assert_eq!(x.rget(2), Some(4));
        assert_eq!(x.rget(3), None);
    }

    #[test]
    fn first() {
        let x = Map::new(2..5, |v| v + 2);
        assert_eq!(x.first(), Some(4));
        let y = Map::new(2..2, |v: usize| v + 2);
        assert_eq!(y.first(), None);
    }

    #[test]
    fn last() {
        let x = Map::new(2..5, |v| v + 2);
        assert_eq!(x.last(), Some(6));
        let y = Map::new(2..2, |v: usize| v + 2);
        assert_eq!(y.last(), None);
    }

    #[test]
    fn iter() {
        let x = Map::new(2..5, |v| v + 2);
        assert!(x.iter().eq(4..7));
    }
}