better_collect 0.5.0

Provides a composable, declarative way to consume an iterator
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 better_collect::{
    cmp::Max,
    iter::{Find, Fold},
    prelude::*,
};

fn main() {}

#[unsafe(no_mangle)]
fn bc_tee_with_max(nums: &[i32]) -> (i32, Option<i32>) {
    nums.iter()
        .copied()
        .feed_into(i32::adding().tee(Max::new()))
}

#[unsafe(no_mangle)]
fn for_loop_wo_initial(nums: &[i32]) -> (i32, Option<i32>) {
    let mut sum = 0;
    let mut max = None;

    for &num in nums {
        sum += num;
        max = max.max(Some(num));
    }

    (sum, max)
}

#[unsafe(no_mangle)]
fn for_loop_w_initial(nums: &[i32]) -> (i32, i32) {
    let mut sum = 0;
    let mut max = i32::MIN;

    for &num in nums {
        sum += num;
        max = max.max(num);
    }

    (sum, max)
}

#[unsafe(no_mangle)]
fn fold_w_initial(nums: &[i32]) -> (i32, i32) {
    nums.iter()
        .copied()
        .fold((0, i32::MIN), |(sum, max), num| (sum + num, max.max(num)))
}

#[unsafe(no_mangle)]
unsafe fn fold_counter(nums: &[usize]) -> [usize; 1000] {
    nums.iter().fold([0; 1000], |mut counts, &num| {
        unsafe { *counts.get_unchecked_mut(num) += 1 };
        counts
    })
}

#[unsafe(no_mangle)]
unsafe fn bc_counter(nums: &[usize]) -> [usize; 1000] {
    nums.iter().feed_into(Fold::new([0; 1000], |counts, &num| {
        unsafe { *counts.get_unchecked_mut(num) += 1 };
    }))
}

#[unsafe(no_mangle)]
unsafe fn for_loop_counter(nums: &[usize]) -> [usize; 1000] {
    let mut counts = [0; 1000];

    for &num in nums {
        unsafe { *counts.get_unchecked_mut(num) += 1 };
    }

    counts
}

#[unsafe(no_mangle)]
fn iter_find_0(nums: &[i32]) -> Option<i32> {
    nums.iter().find(|&&num| num == 0).copied()
}

// Use manual `collect` because `tee_*` uses this method anyway.
// Not to mention `Find`'s `collect_then_finish` forwards to `find()`.
#[unsafe(no_mangle)]
fn bc_find_0(nums: &[i32]) -> Option<i32> {
    let mut collector = Find::new(|&num| num == 0);
    let mut nums = nums.iter();

    while let Some(&num) = nums.next()
        && collector.collect(num).is_continue()
    {}

    collector.finish()
}

#[unsafe(no_mangle)]
fn bc_sum_find(nums: &[i32]) -> (i32, Option<i32>) {
    nums.iter()
        .copied()
        .feed_into(i32::adding().tee(Find::new(|&num| num % 2 != 0)))
}

#[unsafe(no_mangle)]
fn fold_find(nums: &[i32]) -> (i32, Option<i32>) {
    nums.iter().fold((0, None), |(sum, first_odd), &num| {
        (
            sum + num,
            first_odd.or_else(|| (num % 2 != 0).then_some(num)),
        )
    })
}