lo_ 0.3.1

A modern Rust utility library delivering modularity, performance & extras ported from JavaScript Lodash
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

/// Zips two iterators together, applying a function to each pair of elements.
///
/// Iteration stops when either iterator is exhausted.
///
/// # Example
/// ```rust
/// use lo_::zip_with;
///
/// let a = vec![1, 2, 3];
/// let b = vec![4, 5, 6];
///
/// let result: Vec<_> = zip_with(a.into_iter(), b.into_iter(), |x, y| x + y).collect();
/// assert_eq!(result, vec![5, 7, 9]);
///
/// ```
pub fn zip_with<A, B, C, I, J, F>(a: I, b: J, mut f: F) -> impl Iterator<Item = C>
where
    I: Iterator<Item = A>,
    J: Iterator<Item = B>,
    F: FnMut(A, B) -> C,
{
    a.zip(b).map(move |(x, y)| f(x, y))
}

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

    #[test]
    fn test_zip_with_basic_sum() {
        let a = vec![1, 2, 3];
        let b = vec![4, 5, 6];
        let result: Vec<_> = zip_with(a.into_iter(), b.into_iter(), |x, y| x + y).collect();
        assert_eq!(result, vec![5, 7, 9]);
    }

    #[test]
    fn test_zip_with_product() {
        let a = vec![2, 3];
        let b = vec![5, 10];
        let result: Vec<_> = zip_with(a.into_iter(), b.into_iter(), |x, y| x * y).collect();
        assert_eq!(result, vec![10, 30]);
    }

    #[test]
    fn test_zip_with_shorter_iterator() {
        let a = vec![1, 2];
        let b = vec![10, 20, 30]; // b is longer
        let result: Vec<_> = zip_with(a.into_iter(), b.into_iter(), |x, y| x + y).collect();
        assert_eq!(result, vec![11, 22]); // stops at the shorter one
    }

    #[test]
    fn test_zip_with_empty() {
        let a: Vec<i32> = vec![];
        let b: Vec<i32> = vec![1, 2];
        let result: Vec<_> = zip_with(a.into_iter(), b.into_iter(), |x, y| x + y).collect();
        assert!(result.is_empty());
    }
}