debtmap 0.16.3

Code complexity and technical debt analyzer
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

//! Helper traits for partitioning Result iterators.
//!
//! Provides `.partition_result()` extension for both sequential
//! and parallel iterators.

use rayon::prelude::*;

/// Extension trait for partitioning Result iterators.
pub trait PartitionResult<T, E>: Iterator<Item = Result<T, E>> + Sized {
    /// Partitions iterator into successes and failures.
    ///
    /// Similar to `Iterator::partition`, but for Results.
    fn partition_result(self) -> (Vec<T>, Vec<E>) {
        self.fold((Vec::new(), Vec::new()), |(mut oks, mut errs), result| {
            match result {
                Ok(val) => oks.push(val),
                Err(err) => errs.push(err),
            }
            (oks, errs)
        })
    }
}

/// Implement for all Result iterators.
impl<T, E, I> PartitionResult<T, E> for I where I: Iterator<Item = Result<T, E>> {}

/// Extension trait for parallel Result iterators.
pub trait ParPartitionResult<T, E>: ParallelIterator<Item = Result<T, E>> {
    /// Partitions parallel iterator into successes and failures.
    fn partition_result(self) -> (Vec<T>, Vec<E>)
    where
        T: Send,
        E: Send,
    {
        self.fold(
            || (Vec::new(), Vec::new()),
            |(mut oks, mut errs), result| {
                match result {
                    Ok(val) => oks.push(val),
                    Err(err) => errs.push(err),
                }
                (oks, errs)
            },
        )
        .reduce(
            || (Vec::new(), Vec::new()),
            |(mut oks1, mut errs1), (oks2, errs2)| {
                oks1.extend(oks2);
                errs1.extend(errs2);
                (oks1, errs1)
            },
        )
    }
}

impl<T, E, I> ParPartitionResult<T, E> for I
where
    I: ParallelIterator<Item = Result<T, E>>,
    T: Send,
    E: Send,
{
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_partition_result_sequential() {
        let results = vec![Ok(1), Err("e1"), Ok(2), Ok(3), Err("e2")];

        let (successes, failures): (Vec<i32>, Vec<&str>) = results.into_iter().partition_result();

        assert_eq!(successes, vec![1, 2, 3]);
        assert_eq!(failures, vec!["e1", "e2"]);
    }

    #[test]
    fn test_partition_result_parallel() {
        let results: Vec<Result<i32, &str>> = vec![Ok(1), Err("e1"), Ok(2), Ok(3), Err("e2")];

        let (successes, failures) = results.into_par_iter().partition_result();

        assert_eq!(successes.len(), 3);
        assert_eq!(failures.len(), 2);
        assert!(successes.contains(&1));
        assert!(successes.contains(&2));
        assert!(successes.contains(&3));
    }

    #[test]
    fn test_partition_result_all_success() {
        let results = vec![Ok(1), Ok(2), Ok(3)];
        let (successes, failures): (Vec<i32>, Vec<&str>) = results.into_iter().partition_result();

        assert_eq!(successes, vec![1, 2, 3]);
        assert!(failures.is_empty());
    }

    #[test]
    fn test_partition_result_all_failures() {
        let results: Vec<Result<i32, &str>> = vec![Err("e1"), Err("e2"), Err("e3")];
        let (successes, failures) = results.into_iter().partition_result();

        assert!(successes.is_empty());
        assert_eq!(failures, vec!["e1", "e2", "e3"]);
    }
}