lowdash 0.5.3

A Lodash inspired utility library to manipulate array and object for Rust
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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

/// Collects all unique values from one or more maps into a single vector.
///
/// Iterates over each map and collects all unique values into a single vector.
///
/// # Arguments
/// * `maps` - A slice of references to maps to collect unique values from
///
/// # Returns
/// * `Vec<V>` - A vector containing all unique values from the input maps
///
/// # Examples
/// ```
/// use lowdash::uniq_values;
/// use std::collections::HashMap;
///
/// let mut map1 = HashMap::new();
/// map1.insert("a", 1);
/// map1.insert("b", 2);
///
/// let mut map2 = HashMap::new();
/// map2.insert("c", 2);
/// map2.insert("d", 3);
///
/// let result = uniq_values(&[&map1, &map2]);
/// assert_eq!(result.len(), 3);
/// assert!(result.contains(&1));
/// assert!(result.contains(&2));
/// assert!(result.contains(&3));
/// ```
pub fn uniq_values<K, V>(maps: &[&std::collections::HashMap<K, V>]) -> Vec<V>
where
    V: Clone + std::cmp::Eq + std::hash::Hash,
{
    let mut seen = std::collections::HashSet::new();
    let mut result = Vec::new();

    for map in maps {
        for value in map.values() {
            if seen.insert(value.clone()) {
                result.push(value.clone());
            }
        }
    }

    result
}

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

    #[test]
    fn test_uniq_values_single_map() {
        let mut map = HashMap::new();
        map.insert("a", 1);
        map.insert("b", 2);

        let result = uniq_values(&[&map]);
        assert_eq!(result.len(), 2);
        assert!(result.contains(&1));
        assert!(result.contains(&2));
    }

    #[test]
    fn test_uniq_values_multiple_maps() {
        let mut map1 = HashMap::new();
        map1.insert("a", 1);
        map1.insert("b", 2);

        let mut map2 = HashMap::new();
        map2.insert("c", 2);
        map2.insert("d", 3);

        let result = uniq_values(&[&map1, &map2]);
        assert_eq!(result.len(), 3);
        assert!(result.contains(&1));
        assert!(result.contains(&2));
        assert!(result.contains(&3));
    }

    #[test]
    fn test_uniq_values_empty_maps() {
        let map1: HashMap<&str, i32> = HashMap::new();
        let map2: HashMap<&str, i32> = HashMap::new();

        let result = uniq_values(&[&map1, &map2]);
        assert_eq!(result.len(), 0);
    }

    #[test]
    fn test_uniq_values_with_integers() {
        let mut map1 = HashMap::new();
        map1.insert(1, "a");
        map1.insert(2, "b");

        let mut map2 = HashMap::new();
        map2.insert(3, "b");
        map2.insert(4, "c");

        let result = uniq_values(&[&map1, &map2]);
        assert_eq!(result.len(), 3);
        assert!(result.contains(&"a"));
        assert!(result.contains(&"b"));
        assert!(result.contains(&"c"));
    }

    #[test]
    fn test_uniq_values_with_mixed_types() {
        let mut map1 = HashMap::new();
        map1.insert("a", 1);
        map1.insert("b", 2);

        let mut map2 = HashMap::new();
        map2.insert("c", 2);
        map2.insert("d", 3);

        let result = uniq_values(&[&map1, &map2]);
        assert_eq!(result.len(), 3);
        assert!(result.contains(&1));
        assert!(result.contains(&2));
        assert!(result.contains(&3));
    }
}