Archery
Archery is a rust library that offers a way to abstraction over Rc
and Arc
smart pointers. This allows you to create data structures where the pointer type is parameterizable, so you can avoid the overhead of Arc
when you don’t need to share data across threads.
In languages that supports higher-kinded polymorphism this would be simple to achieve without any library, but rust does not support that yet. To mimic higher-kinded polymorphism Archery implements the approach suggested by Joshua Liebow-Feeser in “Rust has higher kinded types already… sort of”. While other approaches exist, they seem to always offer poor ergonomics for the user.
Setup
To use Archery add the following to your Cargo.toml
:
[dependencies]
archery = "<version>"
Using Archery
Archery defines a SharedPointer
that receives the kind of pointer as a type parameter. This gives you a convenient and ergonomic way to abstract the pointer type away.
Example
Declare a data structure with the pointer kind as a type parameter bounded by SharedPointerKind
:
use archery::*;
struct KeyValuePair<K, V, P: SharedPointerKind> {
pub key: SharedPointer<K, P>,
pub value: SharedPointer<V, P>,
}
impl<K, V, P: SharedPointerKind> KeyValuePair<K, V, P> {
fn new(key: K, value: V) -> KeyValuePair<K, V, P> {
KeyValuePair {
key: SharedPointer::new(key),
value: SharedPointer::new(value),
}
}
}
To use it just plug-in the kind of pointer you want:
let pair: KeyValuePair<_, _, RcK> =
KeyValuePair::new("António Variações", 1944);
assert_eq!(*pair.value, 1944);
Limitations
Currently it is not possible to have unsized types inside a SharedPointer
. As a workaround you can put the unsized type inside a Box
.
Alternative approaches
An alternative to the approach taken by Archery is to use traits with associated types to encode type-level functions. This has been suggested multiple times, but offers ugly ergonomics (see here and here).