stringmetrics 2.2.2

Rust library for approximate string matching
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

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

const SOMESTR: &str = "This is a new string with some amount of length";

pub fn bench_str(c: &mut Criterion) {
    let bb_str = SOMESTR;
    let bb_string = black_box(String::from(SOMESTR));

    c.bench_function("Iterate string chars", |b| {
        b.iter(|| black_box(bb_string.chars().count()))
    });
    c.bench_function("Iterate string bytes", |b| {
        b.iter(|| black_box(bb_string.bytes().count()))
    });
    c.bench_function("Iterate string asref chars", |b| {
        b.iter(|| AsRef::<str>::as_ref(black_box(&bb_string)).chars().count())
    });
    c.bench_function("Iterate str chars", |b| {
        b.iter(|| black_box(bb_str.chars().count()))
    });
    c.bench_function("Iterate str bytes", |b| {
        b.iter(|| black_box(bb_str.bytes().count()))
    });
    c.bench_function("Iterate str asref chars", |b| {
        b.iter(|| AsRef::<str>::as_ref(black_box(&bb_str)).chars().count())
    });
}

/// Test iterating a vector collection of chars vs. reconstructing the iterator
pub fn bench_collected(c: &mut Criterion) {
    let bb_str = SOMESTR;
    let vv: Vec<char> = bb_str.chars().collect();

    // We want a fair test so we loop within the benchmark here
    // Constructing the vector takes time, we just want to see if it iterates
    // faster
    c.bench_function("Collect chars", |b| {
        b.iter(|| {
            black_box(bb_str.chars().collect::<Vec<char>>());
        })
    });
    c.bench_function("Iterate collected chars", |b| {
        b.iter(|| {
            black_box(vv.iter().count());
        })
    });
    c.bench_function("Iterate collected chars deref", |b| {
        b.iter(|| {
            black_box(vv.iter().map(|x| *x).count());
        })
    });
    c.bench_function("Iterate uncollected chars", |b| {
        b.iter(|| {
            black_box(bb_str.chars().count());
        })
    });
    c.bench_function("Iterate uncollected bytes", |b| {
        b.iter(|| {
            black_box(bb_str.bytes().count());
        })
    });
}

// pub fn bench_iter_items(c: &mut Criterion) {
//     let bb_str = SOMESTR;
//     let vv: Vec<char> = bb_str.chars().collect();

//     // We want a fair test so we loop within the benchmark here
//     // Constructing the vector takes time, we just want to see if it iterates
//     // faster
//     c.bench_function("Collect chars", |b| {
//         b.iter(|| {
//             black_box(bb_str.chars().collect::<Vec<char>>());
//         })
//     });
//     c.bench_function("Iterate collected chars", |b| {
//         b.iter(|| {
//             black_box(vv.iter().count());
//         })
//     });
//     c.bench_function("Iterate collected chars deref", |b| {
//         b.iter(|| {
//             black_box(vv.iter().map(|x| *x).count());
//         })
//     });
//     c.bench_function("Iterate uncollected chars", |b| {
//         b.iter(|| {
//             black_box(bb_str.chars().count());
//         })
//     });
//     c.bench_function("Iterate uncollected bytes", |b| {
//         b.iter(|| {
//             black_box(bb_str.bytes().count());
//         })
//     });
// }

// #[inline]

criterion_group!(
    iter_bench,
    // bench_str,
    bench_collected
);
criterion_main!(iter_bench);