textdistance 1.1.1

Lots of algorithms to compare how similar two sequences are
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
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

#![cfg(feature = "std")]
use core::hash::Hash;
use std::collections::HashMap;

/// Multiset container inspired by Python's `collections.Counter`.
pub struct Counter<K> {
    map: HashMap<K, usize>,
}

impl<K> Counter<K>
where
    K: Hash + Eq,
{
    /// make an empty Counter
    pub fn new() -> Counter<K> {
        Counter {
            map: HashMap::new(),
        }
    }

    /// Create a counter from a sequence.
    pub fn from_iter<I>(iter: I) -> Counter<K>
    where
        I: IntoIterator<Item = K>,
    {
        let mut counter = Counter::new();
        counter.update(iter);
        counter
    }

    /// Merge items from a sequence into the Counter
    pub fn update<I>(&mut self, iter: I)
    where
        I: IntoIterator<Item = K>,
    {
        for item in iter {
            let entry = self.map.entry(item).or_insert(0);
            *entry += 1;
        }
    }

    // How many items there are in total in the Counter.
    pub fn count(&self) -> usize {
        self.map.values().sum()
    }

    /// Unique elements in the set
    pub fn keys(&self) -> impl Iterator<Item = &K> {
        self.map.keys()
    }

    /// The count of things without the things
    pub fn values(&self) -> impl Iterator<Item = &usize> {
        self.map.values()
    }

    /// .
    pub fn get(&self, key: &K) -> Option<&usize> {
        self.map.get(key)
    }

    /// Merge two counters together.
    pub fn merge<'a>(&'a self, rhs: &'a Counter<K>) -> Counter<&'a K> {
        let mut result: HashMap<&K, usize> = HashMap::new();
        for (key, lhs_count) in &self.map {
            let rhs_count = rhs.map.get(key).unwrap_or(&0);
            result.insert(key, *lhs_count + rhs_count);
        }
        for (key, rhs_count) in &rhs.map {
            if !self.map.contains_key(key) {
                result.insert(key, *rhs_count);
            }
        }
        Counter { map: result }
    }

    /// How many there are common items in the given multisets.
    pub fn intersect_count(&self, rhs: &Counter<K>) -> usize {
        let mut result = 0;
        for (key, lhs_count) in &self.map {
            if let Some(rhs_count) = rhs.map.get(key) {
                result += lhs_count.min(rhs_count);
            }
        }
        result
    }

    /// How many there are items in total in both multisets.
    pub fn union_count(&self, rhs: &Counter<K>) -> usize {
        let mut result = 0;
        for (key, lhs_count) in &self.map {
            let rhs_count = rhs.map.get(key).unwrap_or(&0);
            result += lhs_count.max(rhs_count);
        }
        for (key, rhs_count) in &rhs.map {
            if !self.map.contains_key(key) {
                result += rhs_count;
            }
        }
        result
    }

    /// How many there are item in left that aren't in the right
    pub fn diff_count(&self, rhs: &Counter<K>) -> usize {
        let mut result = 0;
        for (key, lhs_count) in &self.map {
            let rhs_count = rhs.map.get(key).unwrap_or(&0);
            if lhs_count > rhs_count {
                result += lhs_count - rhs_count;
            }
        }
        result
    }
}

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

    pub fn eq<K: Hash + Eq>(lhs: &Counter<K>, rhs: &Counter<K>) -> bool {
        for (key, lhs_count) in &lhs.map {
            if let Some(rhs_count) = rhs.map.get(key) {
                if lhs_count != rhs_count {
                    return false;
                }
            } else {
                return false;
            }
        }
        for (key, rhs_count) in &rhs.map {
            if let Some(lhs_count) = lhs.map.get(key) {
                if lhs_count != rhs_count {
                    return false;
                }
            } else {
                return false;
            }
        }
        true
    }

    #[rstest]
    fn smoke() {
        let c1 = Counter::from_iter(1..=5);
        let c2 = Counter::from_iter(3..=7);
        assert!(eq(&c1, &c1));
        assert!(!eq(&c1, &c2));
        // assert!(eq(c1.intersect(&c2), &Counter::from_iter(3..=5)));
        assert!(c1.intersect_count(&c2) == 3);
        assert!(c1.union_count(&c2) == 7);
    }
}