moirai-iter 0.6.1

Parallel and async iterator combinators for Moirai concurrency library
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

use super::super::{FoldConsumer, ParallelIterator};
use std::ops::ControlFlow;

#[inline]
pub(super) fn seq_mutate_state<I, Init, T, F>(iter: I, init: Init, mut op: F) -> T
where
    I: ParallelIterator,
    Init: FnOnce() -> T,
    F: FnMut(&mut T, I::Item),
{
    iter.seq_fold(init(), |mut state, item| {
        op(&mut state, item);
        state
    })
}

#[inline]
pub(super) fn seq_try_mutate_state<I, Init, T, F, E>(
    iter: I,
    init: Init,
    mut op: F,
) -> Result<(), E>
where
    I: ParallelIterator,
    Init: FnOnce() -> T,
    F: FnMut(&mut T, I::Item) -> Result<(), E>,
{
    let folded = iter.seq_try_fold((init(), Ok(())), |(mut state, _), item| {
        match op(&mut state, item) {
            Ok(()) => ControlFlow::Continue((state, Ok(()))),
            Err(error) => ControlFlow::Break((state, Err(error))),
        }
    });
    let (_, outcome) = match folded {
        ControlFlow::Continue(state) | ControlFlow::Break(state) => state,
    };

    outcome
}

#[inline]
pub(super) fn reassociated_fold<I, O, Empty, Single, Combine>(
    iter: I,
    empty: Empty,
    single: Single,
    combine: Combine,
) -> O
where
    I: ParallelIterator,
    O: Send,
    Empty: Fn() -> O + Send + Sync + Clone,
    Single: Fn(I::Item) -> O + Send + Sync + Clone,
    Combine: Fn(O, O) -> O + Send + Sync + Clone,
{
    iter.drive(FoldConsumer::new(
        empty,
        {
            let single = single.clone();
            let combine_step = combine.clone();
            move |accumulator: O, item: I::Item| combine_step(accumulator, single(item))
        },
        combine,
    ))
    .into_value()
}