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

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

    result
}

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

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

        let result = uniq_keys(&[&map]);
        assert_eq!(result.len(), 2);
        assert!(result.contains(&"a"));
        assert!(result.contains(&"b"));
    }

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

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

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

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

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

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

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

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

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

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

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