frunk 0.4.4

Frunk provides developers with a number of functional programming tools like HList, Coproduct, Generic, LabelledGeneric, Validated, Monoid, Semigroup and friends.
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

#![feature(test)]
#![allow(dead_code, unused)]

#[macro_use]
extern crate frunk;
#[macro_use]
extern crate frunk_core;
#[macro_use]
extern crate frunk_proc_macros;
extern crate test;

use frunk::labelled::Transmogrifier;
use std::convert::From;
use test::Bencher;

#[derive(LabelledGeneric)]
struct Inner5 {
    v: isize,
}

#[derive(LabelledGeneric)]
struct Inner4 {
    v: Inner5,
}

#[derive(LabelledGeneric)]
struct Inner3 {
    v: Inner4,
}
#[derive(LabelledGeneric)]
struct Inner2 {
    v: Inner3,
}

#[derive(LabelledGeneric)]
struct Outer {
    v: Inner2,
}

impl Outer {
    fn new() -> Outer {
        Outer {
            v: Inner2 {
                v: Inner3 {
                    v: Inner4 { v: Inner5 { v: 3 } },
                },
            },
        }
    }
}

#[bench]
fn normal_path_read_value(b: &mut Bencher) {
    b.iter(|| {
        let o = Outer::new();
        let v = o.v.v.v.v.v;
        let r = v + 1;
        r
    })
}

#[bench]
fn lens_path_read_value(b: &mut Bencher) {
    let p = path!(v.v.v.v.v);
    b.iter(|| {
        let o = Outer::new();
        let v = p.get(o);
        let r = v + 1;
        r
    })
}

#[bench]
fn normal_path_read_ref(b: &mut Bencher) {
    b.iter(|| {
        let o = Outer::new();
        let v = &o.v.v.v.v.v;
        let r = v + 1;
        r
    })
}

#[bench]
fn lens_path_read_ref(b: &mut Bencher) {
    let p = path!(v.v.v.v.v);
    b.iter(|| {
        let o = Outer::new();
        let v = p.get(&o);
        let r = v + 1;
        r
    })
}

#[bench]
fn normal_path_read_mut(b: &mut Bencher) {
    b.iter(|| {
        let mut o = Outer::new();
        let v = &mut o.v.v.v.v.v;
        *v = 999;
        let r = *v + 1;
        r
    })
}

#[bench]
fn lens_path_read_mut(b: &mut Bencher) {
    let p = path!(v.v.v.v.v);
    b.iter(|| {
        let mut o = Outer::new();
        *p.get(&mut o) = 9999;
        let r = p.get(&o) + 1;
        r
    })
}