Hashable wrappers for reference countings.
Provides hashable wrappers for [`Rc<T>`] and [`Weak<T>`] references
with the types [`HashableRc<T>`] and [`HashableWeak<T>`],
respectively. This allows use of both strong and weak reference
countings in hash-based data structures, such as [`HashMap`] or
[`HashSet`].
# Quick Start
The most common use cases are wrapping [`Rc<T>`] or [`Weak<T>`] in
[`HashableRc<T>`] or [`HashableWeak<T>`] respectively to be
contained in a hash-based container. An example of using both types
as keys in a [`HashMap`] follows.
```
use std::collections::HashMap;
use std::rc::{Rc, Weak};
use hashable_rc::{HashableRc, HashableWeak};
// Create a strong reference counting for an object.
let rc: Rc<u32> = Rc::new(42);
// Use the strong reference as a key for a HashMap.
let mut strong_map = HashMap::new();
strong_map.insert(HashableRc::new(rc.clone()), "foo");
assert_eq!(strong_map[&HashableRc::new(rc.clone())], "foo");
// Create a weak reference counting for the same object as above.
let weak: Weak<u32> = Rc::downgrade(&rc);
// Use the weak reference as a key for a HashMap.
let mut weak_map = HashMap::new();
weak_map.insert(HashableWeak::new(weak.clone()), "bar");
assert_eq!(weak_map[&HashableWeak::new(weak.clone())], "bar");
```
Insertion into other hash-based containers (such as a [`HashSet`])
follows similarly.