Associate values at compile time - rust

Question

I want to make a graph with a safe interface:
pub struct VertexId {
id: usize,
}
pub struct Graph {
vertices: Vec<String>,
edges: Vec<(VertexId, VertexId)>,
}
impl Graph {
pub fn add_vertex(&mut self, label: String) -> VertexId {
self.vertices.push(label);
VertexId { id: self.vertices.len() - 1 }
}
pub fn add_edge(&mut self, from: VertexId, to: VertexId) {
self.edges.push((from, to));
}
}
Here, I've created a VertexId wrapper so that you can only get vertex ids from a Graph.
However, it's possible to use invalid VertexIds if you create two Graphs:
let mut a = Graph::new();
let vid = a.add_vertex("hello".to_string());
let mut b = Graph::new();
b.add_edge(vid, vid);
Is it possible to link vid to a at compile time?

Answer 1

Note: If you decide to use the following approach, you'll discover that it brings serious downsides, and - in practice - is probably not worth it.
You could make each graph instance an own type. One way to do so is to equip it with an identifier, and require that the vertices' identifier and the graph's identifier match.
I.e. you could e.g. do this (I chose the IDENTIFIER to be a const u32, but you could also use a type):
pub struct VertexId<const IDENTIFIER: u32> {
id: usize,
}
pub struct Graph<const IDENTIFIER: u32> {
vertices: Vec<String>,
edges: Vec<(VertexId<IDENTIFIER>, VertexId<IDENTIFIER>)>,
}
impl<const IDENTIFIER: u32> Graph<IDENTIFIER> {
pub fn add_vertex(&mut self, label: String) -> VertexId<IDENTIFIER> {
self.vertices.push(label);
VertexId {
id: self.vertices.len() - 1,
}
}
pub fn add_edge(&mut self, from: VertexId<IDENTIFIER>, to: VertexId<IDENTIFIER>) {
self.edges.push((from, to));
}
}
Then, each time you construct a graph, you'd have to supply an identifier. This becomes annoying pretty soon, so you might define this helper macro that infers the identifier from the line number:
macro_rules! make_graph {
() => {{
const LINE: u32 = line!();
Graph::<LINE> {
vertices: Vec::new(),
edges: Vec::new(),
}
}};
}
Then, you would not be able to add_edge vertices from a to another graph b:
let mut a = make_graph!();
let vid = a.add_vertex("hello".to_string());
let mut b = make_graph!();
// b.add_edge(vid, vid); // does not compile
Note that make_graph could lead to the same type in two different files, but with matching line numbers. This also highlights one drawback of this: As soon as you move the make_graph to another line, you get another type. You could get around this by using types as identifiers, but then you'd have to declare identifier types over and over. tl;dr; Just because you can enforce something in the type system, it is not necessarily a good idea.

Answer 2

You can use branded lifetimes. generativity implements those, but you can also do it yourself by looking how it does that.
The idea is explained well in generativity's README. The basic idea is that we make each Graph instance its own type via a lifetime, then each graph instance can have its own vertices as different types.
pub struct Graph<'id> {
id: generativity::Id<'id>,
vertices: Vec<String>,
edges: Vec<(VertexId<'id>, VertexId<'id>)>,
}
impl<'id> Graph<'id> {
pub fn new(guard: generativity::Guard<'id>) -> Self {
Self {
id: guard.into(),
vertices: Vec::new(),
edges: Vec::new(),
}
}
pub fn add_vertex(&mut self, label: String) -> VertexId<'id> {
self.vertices.push(label);
VertexId {
_id: self.id,
index: self.vertices.len() - 1,
}
}
pub fn add_edge(&mut self, from: VertexId<'id>, to: VertexId<'id>) {
self.edges.push((from, to));
}
}
#[derive(Clone, Copy)]
pub struct VertexId<'id> {
_id: generativity::Id<'id>,
index: usize,
}
fn main() {
generativity::make_guard!(graph);
let mut graph = Graph::new(graph);
let vertex = graph.add_vertex("Foo".to_owned());
dbg!(graph.get_vertex_label(vertex));
generativity::make_guard!(graph2);
let graph2 = Graph::new(graph2);
// Does not compile.
// graph2.get_vertex_label(vertex);
}
The advantages of this approach over #phimuemue's approach of using a non-lifetime generic parameters are:
This monomorphizes only once, not once per instance, reducing compile time size and code bloat.
Because the lifetime is guaranteed to be unique, you can rely on it for soundness. For example, you can use get_unchecked() for getting nodes:
impl<'id> Graph<'id> {
pub fn get_vertex_label(&self, vertex: VertexId<'id>) -> &str {
// SAFETY: The lifetime verifies this come from the same graph, and we never remove vertices.
unsafe { self.vertices.get_unchecked(vertex.index) }
}
}