be-generust 0.1.0

A procedural macro for writing iterators in Rust
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

use criterion::{criterion_group, criterion_main, Criterion};

mod my_map_mod {
    // use std::mem::MaybeUninit;

    enum MyMapState { S, E }

    struct MyMap<I: Iterator, R, F: FnMut(I::Item) -> R> {
        state: MyMapState,
        param_iter: I,
        param_f: F,
        // var_temp: ...
    }

    impl<I: Iterator, R, F: FnMut(I::Item) -> R> Iterator for MyMap<I, R, F> {
        type Item = R;

        fn size_hint(&self) -> (usize, Option<usize>) {
            self.iter.size_hint()
        }

        fn next(&mut self) -> Option<R> {
            loop {
                match self.state {
                    MyMapState::S => {
                        match self.param_iter.next() {
                            Some(x) => { return Some((self.param_f)(x)); }
                            None => { self.state = MyMapState::E; }
                        }
                    },
                    MyMapState::E => {
                        return None
                    }
                }
            }
        }
    }

    pub fn my_map<I: Iterator, R, F: FnMut(I::Item) -> R>(iter: I, f: F) -> impl Iterator<Item = R> {
        // let size_hint = { self.iter.size_hint() }
        // give_size_hint! { self.iter.size_hint() }
        MyMap { state: MyMapState::S, param_iter: iter, param_f: f }
    }
}

use my_map_mod::my_map;

#[giver]
fn my_map<I, F, R>(iter: I, f: F) -> R
where
    I: Iterator,
    F: FnMut(I::Item) -> R,
    R: Iterator<Item=I::Item>,
{
    for x in iter {
        give!(f(x))
    }
}

mod simp_map_mod {
    pub struct SimpMap<I: Iterator, R, F: FnMut(I::Item) -> R> {
        iter: I,
        f: F,
    }


    impl<I: Iterator, R, F: FnMut(I::Item) -> R> Iterator for SimpMap<I, R, F> {
        type Item = R;

        fn size_hint(&self) -> (usize, Option<usize>) {
            self.iter.size_hint()
        }

        fn next(&mut self) -> Option<R> {
            self.iter.next().map(&mut self.f)
        }
    }

    pub fn simp_map<I: Iterator, R, F: FnMut(I::Item) -> R>(iter: I, f: F) -> SimpMap<I, R, F> {
        SimpMap { iter, f }
    }
}

use simp_map_mod::simp_map;

fn criterion_benchmark(c: &mut Criterion) {
    c.bench_function("std map", |b| b.iter(||
        (1..1024).map(|x| x + 1).map(|x| (((x + 12) * 24) ^ 42)/x).collect::<Vec<_>>()
    ));

    c.bench_function("my map", |b| b.iter(||
        my_map(my_map(1..1024, |x| x + 1), |x| (((x + 12) * 24) ^ 42)/x).collect::<Vec<_>>()
    ));

    c.bench_function("simp map", |b| b.iter(||
        simp_map(simp_map(1..1024, |x| x + 1), |x| (((x + 12) * 24) ^ 42)/x).collect::<Vec<_>>()
    ));

    // c.bench_function("std map sum", |b| b.iter(||
    //     (1..1024).map(|x| x + 1).map(|x| x + 12 * 24 ^ 42).sum::<i64>()
    // ));

    // c.bench_function("my map sum", |b| b.iter(||
    //     my_map(my_map(1..1024, |x| x + 1), |x| x + 12 * 24 ^ 42).sum::<i64>()
    // ));

    // c.bench_function("simp map sum", |b| b.iter(||
    //     simp_map(simp_map(1..1024, |x| x + 1), |x| x + 12 * 24 ^ 42).sum::<i64>()
    // ));
}

criterion_group!(benches, criterion_benchmark);
criterion_main!(benches);