ids 0.1.4

This library provides several data structures, inspired by Bagwell's Ideal Hash Trees, with an automatic copy-on-write implementation, analogous that of Clojure, to maximize performance. It is compatible with `no_std` code, but does require `alloc`.
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

#![cfg(feature = "serde")]

use core::{
    hash::{BuildHasher, Hash},
    marker::PhantomData,
};

use serde::{
    de::{MapAccess, Visitor},
    ser::SerializeMap,
    Deserialize, Serialize, Serializer,
};

use crate::hash_map::HashMap;

impl<K: Eq + Hash + Serialize, V: Serialize, H: BuildHasher, const F: usize> Serialize
    for HashMap<K, V, H, F>
{
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let mut ser = serializer.serialize_map(Some(self.len()))?;
        for (key, value) in self.iter() {
            ser.serialize_entry(key, value)?;
        }
        ser.end()
    }
}

impl<
        'de,
        K: Eq + Hash + Clone + Deserialize<'de> + 'de,
        V: Clone + Deserialize<'de> + 'de,
        H: BuildHasher + Default + 'de,
        const F: usize,
    > Deserialize<'de> for HashMap<K, V, H, F>
{
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        struct HashMapVisitor<
            'de,
            K: Eq + Hash + Deserialize<'de>,
            V: Deserialize<'de>,
            H: BuildHasher,
            const F: usize,
        >(PhantomData<&'de HashMap<K, V, H, F>>);

        impl<
                'de,
                K: Eq + Hash + Clone + Deserialize<'de>,
                V: Clone + Deserialize<'de>,
                H: BuildHasher + Default,
                const F: usize,
            > Visitor<'de> for HashMapVisitor<'de, K, V, H, F>
        {
            type Value = HashMap<K, V, H, F>;

            fn expecting(&self, formatter: &mut core::fmt::Formatter) -> core::fmt::Result {
                formatter.write_str("a map")
            }

            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
            where
                A: MapAccess<'de>,
            {
                let mut hm = HashMap::new(Default::default());
                while let Some((key, value)) = map.next_entry()? {
                    hm.insert(key, value);
                }
                Ok(hm)
            }
        }

        deserializer.deserialize_map(HashMapVisitor(PhantomData))
    }
}