diff --git a/scopegraphs-macros/src/label.rs b/scopegraphs-macros/src/label.rs
index 4d06fdf..badfdc3 100644
--- a/scopegraphs-macros/src/label.rs
+++ b/scopegraphs-macros/src/label.rs
@@ -28,8 +28,9 @@ pub fn impl_label(input: DeriveInput) -> TokenStream {
     }
 
     let mut variant_names = Vec::new();
+    let mut variant_numbers = Vec::new();
 
-    for variant in variants {
+    for (num, variant) in variants.into_iter().enumerate() {
         if !variant.fields.is_empty() {
             return quote_spanned!(
                 variant.span() => compile_error!("cannot derive Label for an enum with fields on variants");
@@ -37,12 +38,31 @@ pub fn impl_label(input: DeriveInput) -> TokenStream {
             .into();
         }
 
+        if variant.discriminant.is_some() {
+            return quote_spanned!(
+                variant.span() => compile_error!("cannot derive Label for an enum with custom discriminated variants. Use `Label::to_usize()`");
+            )
+                .into();
+        }
+
         variant_names.push(variant.ident);
+        variant_numbers.push(num);
     }
+    let num_variants = variant_numbers.len();
 
     let name = input.ident;
     quote! {
-        impl scopegraphs::Label for #name {
+        unsafe impl scopegraphs::Label for #name {
+            type Array<T> = [T; #num_variants];
+
+            fn to_usize(&self) -> usize {
+                match *self {
+                    #(
+                        Self::#variant_names => #variant_numbers
+                    ),*
+                }
+            }
+
             fn iter() -> impl Iterator<Item = Self> {
                 [
                     #(
diff --git a/scopegraphs/src/completeness/critical_edge.rs b/scopegraphs/src/completeness/critical_edge.rs
index 39e42e0..1572b0b 100644
--- a/scopegraphs/src/completeness/critical_edge.rs
+++ b/scopegraphs/src/completeness/critical_edge.rs
@@ -1,5 +1,5 @@
 use crate::completeness::Completeness;
-use crate::{Scope, ScopeGraph};
+use crate::{Label, Scope, ScopeGraph};
 use std::cell::RefCell;
 use std::{collections::HashSet, hash::Hash};
 
@@ -38,7 +38,7 @@ impl<LABEL: Hash + Eq> CriticalEdgeSet<LABEL> {
 /// Provides utility function to create scopes with particular open edges.
 ///
 /// Should not be called externally, but only from utility function on [`crate::ScopeGraph`].
-pub trait CriticalEdgeBasedCompleteness<LABEL, DATA>: Completeness<LABEL, DATA> {
+pub trait CriticalEdgeBasedCompleteness<LABEL: Label, DATA>: Completeness<LABEL, DATA> {
     /// Initializes a new scope with a certain set of edges that are still considered "open".
     fn init_scope_with(&self, open_edges: HashSet<LABEL>);
 }
@@ -68,7 +68,7 @@ pub struct Delay<LABEL> {
 /// Convenience alias for the type of `Result` returned from queries using [critical edge based completion](CriticalEdgeBasedCompleteness)
 pub type EdgesOrDelay<EDGES, LABEL> = Result<EDGES, Delay<LABEL>>;
 
-impl<'sg, LABEL: Hash + Eq, DATA, CMPL> ScopeGraph<'sg, LABEL, DATA, CMPL>
+impl<'sg, LABEL: Hash + Eq + Label, DATA, CMPL> ScopeGraph<'sg, LABEL, DATA, CMPL>
 where
     CMPL: CriticalEdgeBasedCompleteness<LABEL, DATA>,
 {
@@ -91,7 +91,7 @@ where
     }
 }
 
-impl<'sg, LABEL: Hash + Eq, DATA, CMPL> ScopeGraph<'sg, LABEL, DATA, CMPL>
+impl<'sg, LABEL: Hash + Eq + Label, DATA, CMPL> ScopeGraph<'sg, LABEL, DATA, CMPL>
 where
     DATA: Default,
     CMPL: CriticalEdgeBasedCompleteness<LABEL, DATA>,
diff --git a/scopegraphs/src/completeness/explicit.rs b/scopegraphs/src/completeness/explicit.rs
index 1a67507..90ddd86 100644
--- a/scopegraphs/src/completeness/explicit.rs
+++ b/scopegraphs/src/completeness/explicit.rs
@@ -19,11 +19,11 @@ use std::{collections::HashSet, hash::Hash};
 /// Returns [`Delay`] when edges are retrieved (e.g. during query resolution) for an edge that is
 /// not yet closed.
 #[derive(Debug)]
-pub struct ExplicitClose<LABEL> {
+pub struct ExplicitClose<LABEL: Label> {
     critical_edges: CriticalEdgeSet<LABEL>,
 }
 
-impl<LABEL> Default for ExplicitClose<LABEL> {
+impl<LABEL: Label> Default for ExplicitClose<LABEL> {
     fn default() -> Self {
         ExplicitClose {
             critical_edges: CriticalEdgeSet::default(),
@@ -31,7 +31,7 @@ impl<LABEL> Default for ExplicitClose<LABEL> {
     }
 }
 
-impl<LABEL> Sealed for ExplicitClose<LABEL> {}
+impl<LABEL: Label> Sealed for ExplicitClose<LABEL> {}
 
 impl<LABEL: Hash + Eq + Label, DATA> Completeness<LABEL, DATA> for ExplicitClose<LABEL> {
     fn cmpl_new_scope(&self, _: &InnerScopeGraph<LABEL, DATA>, _: Scope) {
@@ -101,7 +101,7 @@ impl<LABEL: Hash + Eq + Label, DATA> CriticalEdgeBasedCompleteness<LABEL, DATA>
     }
 }
 
-impl<LABEL: Hash + Eq> ExplicitClose<LABEL> {
+impl<LABEL: Label + Hash> ExplicitClose<LABEL> {
     /// Close a scope for a certain label
     /// // TODO: link to "closing" in concepts
     pub fn close(&self, scope: Scope, label: &LABEL) {
@@ -109,7 +109,7 @@ impl<LABEL: Hash + Eq> ExplicitClose<LABEL> {
     }
 }
 
-impl<'sg, LABEL: Hash + Eq, DATA> ScopeGraph<'sg, LABEL, DATA, ExplicitClose<LABEL>> {
+impl<'sg, LABEL: Label + Hash, DATA> ScopeGraph<'sg, LABEL, DATA, ExplicitClose<LABEL>> {
     // TODO: fix this sentence
     /// Closes an edge, (i.e., prohibit future new
     ///
@@ -120,7 +120,7 @@ impl<'sg, LABEL: Hash + Eq, DATA> ScopeGraph<'sg, LABEL, DATA, ExplicitClose<LAB
     /// # use scopegraphs::Storage;
     /// # use scopegraphs::ScopeGraph;
     ///
-    /// # #[derive(Eq, Hash, PartialEq, Label)] enum Lbl { Def }
+    /// # #[derive(Eq, Hash, PartialEq, Label, Copy, Clone)] enum Lbl { Def }
     /// # use Lbl::*;
     /// let storage = Storage::new();
     /// let mut sg = ScopeGraph::<Lbl, usize, _>::new(&storage, ExplicitClose::default());
@@ -199,7 +199,7 @@ impl<'sg, LABEL: Hash + Eq, DATA> ScopeGraph<'sg, LABEL, DATA, ExplicitClose<LAB
     }
 }
 
-impl<'sg, LABEL: Hash + Eq + Copy, DATA> ScopeGraph<'sg, LABEL, DATA, FutureCompleteness<LABEL>> {
+impl<'sg, LABEL: Label + Hash, DATA> ScopeGraph<'sg, LABEL, DATA, FutureCompleteness<LABEL>> {
     // TODO: update this example to use futures
     // TODO: fix this sentence
     /// Closes an edge, (i.e., prohibit future new
@@ -210,7 +210,7 @@ impl<'sg, LABEL: Hash + Eq + Copy, DATA> ScopeGraph<'sg, LABEL, DATA, FutureComp
     /// # use scopegraphs::ScopeGraph;
     /// # use scopegraphs_macros::Label;
     /// # use scopegraphs::Storage;
-    /// # #[derive(Eq, Hash, PartialEq, Label)] enum Lbl { Def }
+    /// # #[derive(Eq, Hash, PartialEq, Label, Copy, Clone)] enum Lbl { Def }
     /// # use Lbl::*;
     /// let storage = Storage::new();
     /// let mut sg = ScopeGraph::<Lbl, usize, _>::new(&storage, ExplicitClose::default());
diff --git a/scopegraphs/src/completeness/future.rs b/scopegraphs/src/completeness/future.rs
index 4ca9274..69eb7c0 100644
--- a/scopegraphs/src/completeness/future.rs
+++ b/scopegraphs/src/completeness/future.rs
@@ -20,12 +20,12 @@ use std::task::{Poll, Waker};
 ///
 /// Extends, and contains an instance of, [`ExplicitClose`].
 #[derive(Debug)]
-pub struct FutureCompleteness<LABEL> {
+pub struct FutureCompleteness<LABEL: Label> {
     explicit_close: ExplicitClose<LABEL>,
     wakers: RefCell<HashMap<Delay<LABEL>, Vec<Waker>>>,
 }
 
-impl<LABEL> Default for FutureCompleteness<LABEL> {
+impl<LABEL: Label> Default for FutureCompleteness<LABEL> {
     fn default() -> Self {
         Self {
             explicit_close: ExplicitClose::<LABEL>::default(),
@@ -34,7 +34,7 @@ impl<LABEL> Default for FutureCompleteness<LABEL> {
     }
 }
 
-impl<LABEL> Sealed for FutureCompleteness<LABEL> {}
+impl<LABEL: Label> Sealed for FutureCompleteness<LABEL> {}
 
 impl<LABEL: Hash + Eq + Label + Copy, DATA> Completeness<LABEL, DATA>
     for FutureCompleteness<LABEL>
@@ -94,7 +94,7 @@ impl<LABEL: Hash + Eq + Label + Copy, DATA> Completeness<LABEL, DATA>
     }
 }
 
-impl<LABEL: Hash + Eq + Copy> FutureCompleteness<LABEL> {
+impl<LABEL: Label + Hash> FutureCompleteness<LABEL> {
     pub(crate) fn close(&self, scope: Scope, label: &LABEL) {
         self.explicit_close.close(scope, label);
         for waker in self
diff --git a/scopegraphs/src/completeness/mod.rs b/scopegraphs/src/completeness/mod.rs
index 2de3dfd..43818dc 100644
--- a/scopegraphs/src/completeness/mod.rs
+++ b/scopegraphs/src/completeness/mod.rs
@@ -34,6 +34,7 @@ mod private {
 }
 
 use crate::scopegraph::{InnerScopeGraph, Scope};
+use crate::Label;
 use private::Sealed;
 
 /*** Completeness trait ***/
@@ -61,7 +62,7 @@ use private::Sealed;
 /// You cannot define your own completeness strategies to ensure that only verified implementations are available.
 // TODO: @Aron could you document this?
 #[allow(missing_docs)]
-pub trait Completeness<LABEL, DATA>: Sealed {
+pub trait Completeness<LABEL: Label, DATA>: Sealed {
     fn cmpl_new_scope(&self, inner_scope_graph: &InnerScopeGraph<LABEL, DATA>, scope: Scope);
 
     /// Should initialize a scope without possibility to extend it with edges
diff --git a/scopegraphs/src/completeness/unchecked.rs b/scopegraphs/src/completeness/unchecked.rs
index 1284b7c..f4fb334 100644
--- a/scopegraphs/src/completeness/unchecked.rs
+++ b/scopegraphs/src/completeness/unchecked.rs
@@ -1,7 +1,7 @@
 use crate::completeness::private::Sealed;
 use crate::completeness::Completeness;
 use crate::scopegraph::{InnerScopeGraph, Scope};
-use std::hash::Hash;
+use crate::Label;
 
 /// No-Op implementation of [`Completeness`].
 #[derive(Debug)]
@@ -23,7 +23,7 @@ impl UncheckedCompleteness {
     }
 }
 
-impl<LABEL: Hash + Eq, DATA> Completeness<LABEL, DATA> for UncheckedCompleteness {
+impl<LABEL: Label, DATA> Completeness<LABEL, DATA> for UncheckedCompleteness {
     fn cmpl_new_scope(&self, _: &InnerScopeGraph<LABEL, DATA>, _: Scope) {}
 
     fn cmpl_new_complete_scope(
diff --git a/scopegraphs/src/label.rs b/scopegraphs/src/label.rs
index d7685b4..f90a64d 100644
--- a/scopegraphs/src/label.rs
+++ b/scopegraphs/src/label.rs
@@ -1,7 +1,54 @@
+use std::array;
+
+pub(crate) trait ArrayInit<T> {
+    fn init_from_fn(init: impl FnMut() -> T) -> Self;
+}
+
+impl<T, const N: usize> ArrayInit<T> for [T; N] {
+    fn init_from_fn(mut init: impl FnMut() -> T) -> Self {
+        array::from_fn(|_| init())
+    }
+}
+
+unsafe impl Label for () {
+    type Array<T> = [T; 1];
+
+    fn to_usize(&self) -> usize {
+        0
+    }
+
+    fn iter() -> impl Iterator<Item = Self>
+    where
+        Self: Sized,
+    {
+        [()].into_iter()
+    }
+
+    fn iter_ref() -> impl Iterator<Item = &'static Self>
+    where
+        Self: Sized + 'static,
+    {
+        [&()].into_iter()
+    }
+}
+
 /// Represents types that can be used as labels on [`scopegraph edges`](crate::concepts::edges).
 ///
-/// Can be derived.
-pub trait Label {
+/// Can, and should, be derived using the [`Label`](scopegraphs_macros::Label) derive macro.
+///
+/// # Safety
+///
+/// This trait is unsafe to implement by yourself, as code in this library depends on the fact
+/// that [`to_usize`](Label::to_usize) returns a list of consecutive indices from 0 to [`NUM_LABELS`](Label::NUM_LABELS) - 1
+pub unsafe trait Label: Eq + Copy {
+    /// The type of an array of these labels, with one slot for each label type.
+    /// NOTE: using an associated const doesn't work without full const generics
+    #[allow(private_bounds)]
+    type Array<T>: AsRef<[T]> + AsMut<[T]> + ArrayInit<T>;
+
+    /// Convert any label to a unique usize, which m
+    fn to_usize(&self) -> usize;
+
     /// Iterate over all possible labels that this label type could be.
     fn iter() -> impl Iterator<Item = Self>
     where
diff --git a/scopegraphs/src/lib.rs b/scopegraphs/src/lib.rs
index c02b795..2d753a2 100644
--- a/scopegraphs/src/lib.rs
+++ b/scopegraphs/src/lib.rs
@@ -46,7 +46,7 @@ pub use storage::Storage;
 /// use scopegraphs::*;
 /// use scopegraphs::Label;
 ///
-/// #[derive(Label, Debug, PartialEq, Eq)]
+/// #[derive(Label, Debug, PartialEq, Eq, Copy, Clone)]
 /// pub enum Alphabet {
 ///     A,
 ///     B,
diff --git a/scopegraphs/src/render/mod.rs b/scopegraphs/src/render/mod.rs
index e92d469..7e22802 100644
--- a/scopegraphs/src/render/mod.rs
+++ b/scopegraphs/src/render/mod.rs
@@ -3,7 +3,7 @@
 //! Generally, use `sg.render_to(filename, Settings::default()` for the most basic rendering.
 
 use crate::completeness::Completeness;
-use crate::{Scope, ScopeGraph};
+use crate::{Label, Scope, ScopeGraph};
 use std::fs::File;
 use std::io;
 use std::io::Write;
@@ -75,7 +75,7 @@ pub struct EdgeTo {
 }
 
 /// Modifies how an edge label is rendered.
-pub trait RenderScopeLabel {
+pub trait RenderScopeLabel: Label {
     /// Render a single label
     fn render(&self) -> String;
 }
@@ -128,7 +128,7 @@ fn escape_text_mermaid(inp: &str) -> String {
 }
 
 impl<
-        LABEL: Clone + RenderScopeLabel,
+        LABEL: Clone + RenderScopeLabel + Label,
         DATA: RenderScopeData + Clone,
         CMPL: Completeness<LABEL, DATA>,
     > ScopeGraph<'_, LABEL, DATA, CMPL>
diff --git a/scopegraphs/src/render/traverse.rs b/scopegraphs/src/render/traverse.rs
index 93b1742..c7e6b28 100644
--- a/scopegraphs/src/render/traverse.rs
+++ b/scopegraphs/src/render/traverse.rs
@@ -14,8 +14,10 @@ pub fn traverse<'sg, LABEL: RenderScopeLabel, DATA, CMPL: Completeness<LABEL, DA
         .flat_map(|(scope, edges)| {
             (*edges)
                 .borrow()
+                .as_ref()
                 .iter()
-                .flat_map(|(lbl, edges_with_lbl)| {
+                .zip(LABEL::iter())
+                .flat_map(|(edges_with_lbl, lbl)| {
                     edges_with_lbl
                         .iter()
                         .map(|edge| Edge {
diff --git a/scopegraphs/src/resolve/lookup.rs b/scopegraphs/src/resolve/lookup.rs
index 4973f34..4720c77 100644
--- a/scopegraphs/src/resolve/lookup.rs
+++ b/scopegraphs/src/resolve/lookup.rs
@@ -89,7 +89,7 @@ where
     }
 }
 
-struct ResolutionContext<'storage, 'sg: 'rslv, 'rslv, LABEL, DATA, CMPL, DWF, LO, DEq> {
+struct ResolutionContext<'storage, 'sg: 'rslv, 'rslv, LABEL: Label, DATA, CMPL, DWF, LO, DEq> {
     all_edges: Vec<EdgeOrData<LABEL>>,
     sg: &'sg ScopeGraph<'storage, LABEL, DATA, CMPL>,
     data_wellformedness: &'rslv DWF,
@@ -106,7 +106,7 @@ type EnvCache<LABEL, ENVC> = RefCell<HashMap<EdgeOrData<LABEL>, Rc<ENVC>>>;
 impl<'storage, 'sg: 'rslv, 'rslv, LABEL, DATA, CMPL, DWF, LO, DEq>
     ResolutionContext<'storage, 'sg, 'rslv, LABEL, DATA, CMPL, DWF, LO, DEq>
 where
-    LABEL: Copy + Debug + Hash + Eq,
+    LABEL: Label + Debug + Hash,
     DATA: Debug,
     ResolvedPath<'sg, LABEL, DATA>: Hash + Eq,
     CMPL: Completeness<LABEL, DATA>,
diff --git a/scopegraphs/src/resolve/mod.rs b/scopegraphs/src/resolve/mod.rs
index 6d8f3d3..b621840 100644
--- a/scopegraphs/src/resolve/mod.rs
+++ b/scopegraphs/src/resolve/mod.rs
@@ -8,7 +8,7 @@ use std::marker::PhantomData;
 use std::rc::Rc;
 
 mod params;
-use crate::{Scope, ScopeGraph};
+use crate::{Label, Scope, ScopeGraph};
 pub use params::*;
 use scopegraphs_regular_expressions::RegexMatcher;
 
@@ -412,7 +412,7 @@ pub trait Resolve<'sg, 'rslv> {
 }
 
 /// A query over a scope graph. Read more [here](crate::concepts)
-pub struct Query<'storage, 'sg, 'rslv, LABEL, DATA, CMPL, PWF, DWF, LO, DEq> {
+pub struct Query<'storage, 'sg, 'rslv, LABEL: Label, DATA, CMPL, PWF, DWF, LO, DEq> {
     _phantom: PhantomData<&'rslv ()>,
     scope_graph: &'sg ScopeGraph<'storage, LABEL, DATA, CMPL>,
     path_wellformedness: PWF,
@@ -421,7 +421,7 @@ pub struct Query<'storage, 'sg, 'rslv, LABEL, DATA, CMPL, PWF, DWF, LO, DEq> {
     data_equivalence: DEq,
 }
 
-impl<'sg, 'storage, 'rslv, LABEL, DATA, CMPL, PWF, DWF, LO, DEq>
+impl<'sg, 'storage, 'rslv, LABEL: Label, DATA, CMPL, PWF, DWF, LO, DEq>
     Query<'sg, 'storage, 'rslv, LABEL, DATA, CMPL, PWF, DWF, LO, DEq>
 {
     /// Add a [path well-formedness](crate::concepts::path_wellformedness) to this query.
@@ -436,7 +436,7 @@ impl<'sg, 'storage, 'rslv, LABEL, DATA, CMPL, PWF, DWF, LO, DEq>
     /// # let storage = Storage::new();
     /// # let scopegraph = ScopeGraph::<Lbl, (), _>::new(&storage, unsafe{UncheckedCompleteness::new()});
     ///
-    /// #[derive(Label)]
+    /// #[derive(Label, Eq, PartialEq, Copy, Clone)]
     /// pub enum Lbl {
     ///     Lexical,
     ///     Definition
@@ -547,7 +547,7 @@ impl<'sg, 'storage, 'rslv, LABEL, DATA, CMPL, PWF, DWF, LO, DEq>
     /// # let scopegraph = ScopeGraph::<Lbl, (), _>::new(&storage, unsafe{UncheckedCompleteness::new()});
     /// use scopegraphs_macros::label_order;
     ///
-    /// #[derive(Label, Copy, Clone)]
+    /// #[derive(Label, Copy, Clone, PartialEq, Eq)]
     /// pub enum Lbl {
     ///     Lexical,
     ///     Definition
@@ -596,7 +596,7 @@ impl<'sg, 'storage, 'rslv, LABEL, DATA, CMPL, PWF, DWF, LO, DEq>
     }
 }
 
-impl<'storage, LABEL, DATA, CMPL> ScopeGraph<'storage, LABEL, DATA, CMPL> {
+impl<'storage, LABEL: Label, DATA, CMPL> ScopeGraph<'storage, LABEL, DATA, CMPL> {
     /// Build a query over the scope graph.
     pub fn query<'sg>(
         &'sg self,
diff --git a/scopegraphs/src/scopegraph.rs b/scopegraphs/src/scopegraph.rs
index f4649ec..d05eec7 100644
--- a/scopegraphs/src/scopegraph.rs
+++ b/scopegraphs/src/scopegraph.rs
@@ -1,12 +1,14 @@
-use std::cell::RefCell;
+use std::cell::{Ref, RefCell};
 use std::{
-    collections::{HashMap, HashSet},
+    collections::HashSet,
     fmt::{Debug, Formatter},
     hash::Hash,
 };
 
 use crate::completeness::{Completeness, UncheckedCompleteness};
+use crate::label::ArrayInit;
 use crate::storage::Storage;
+use crate::Label;
 
 /// Representation of scopes (nodes in the scope graph).
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
@@ -21,15 +23,39 @@ impl Debug for Scope {
 // Mutability: RefCell in Scope, not Scope in RefCell
 // Concurrency: RW-lock on edges
 
-#[derive(Debug)]
-pub struct InnerScopeGraph<'sg, LABEL, DATA> {
+pub struct InnerScopeGraph<'sg, LABEL: Label, DATA> {
     pub storage: &'sg Storage,
     #[allow(clippy::type_complexity)]
-    pub edges: RefCell<Vec<&'sg RefCell<HashMap<LABEL, HashSet<Scope>>>>>, // FIXME: BTreeMap? Vectors? Whatever?
+    pub edges: RefCell<Vec<&'sg RefCell<LABEL::Array<HashSet<Scope>>>>>, // FIXME: BTreeMap? Vectors? Whatever?
     pub data: RefCell<Vec<&'sg DATA>>,
 }
 
-impl<'sg, LABEL, DATA> InnerScopeGraph<'sg, LABEL, DATA> {
+impl<LABEL: Label + Debug, DATA: Debug> Debug for InnerScopeGraph<'_, LABEL, DATA> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        let edges = self.edges.borrow();
+
+        struct Wrapper<F>(F);
+        impl<F: Fn(&mut Formatter) -> std::fmt::Result> Debug for Wrapper<F> {
+            fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+                self.0(f)
+            }
+        }
+
+        f.debug_struct("InnerScopeGraph")
+            .field(
+                "edges",
+                &Wrapper(|f: &mut Formatter| -> std::fmt::Result {
+                    f.debug_list()
+                        .entries(edges.iter().map(|i| Ref::map(i.borrow(), |i| i.as_ref())))
+                        .finish()
+                }),
+            )
+            .field("data", &*self.data.borrow())
+            .finish()
+    }
+}
+
+impl<'sg, LABEL: Label, DATA> InnerScopeGraph<'sg, LABEL, DATA> {
     fn new(storage: &'sg Storage) -> Self {
         Self {
             storage,
@@ -47,7 +73,7 @@ impl<'sg, LABEL, DATA> InnerScopeGraph<'sg, LABEL, DATA> {
         self.edges.borrow_mut().push(
             self.storage
                 .0
-                .alloc(RefCell::new(HashMap::with_capacity(0))),
+                .alloc(RefCell::new(LABEL::Array::init_from_fn(HashSet::new))),
         );
         Scope(id)
     }
@@ -61,18 +87,14 @@ impl<'sg, LABEL, DATA> InnerScopeGraph<'sg, LABEL, DATA> {
     }
 }
 
-impl<'sg, LABEL: Hash + Eq, DATA> InnerScopeGraph<'sg, LABEL, DATA> {
+impl<'sg, LABEL: Label, DATA> InnerScopeGraph<'sg, LABEL, DATA> {
     /// Adds a new edge from `src`, to `dst`, with label `lbl` to the scope graph.
     /// After this operation, all future calls to [`InnerScopeGraph::get_edges`] on the source will contain the destination.
     pub fn add_edge(&self, src: Scope, lbl: LABEL, dst: Scope) {
         // panics if src.0 is out of bounds
         // the methods that update `ScopeGraphs` retain the invariant that each scope has an appropriate entry in this vector
         // however, panics can still happen when a scope from a different scope graph is used
-        self.edges.borrow()[src.0]
-            .borrow_mut()
-            .entry(lbl)
-            .or_default()
-            .insert(dst);
+        self.edges.borrow()[src.0].borrow_mut().as_mut()[lbl.to_usize()].insert(dst);
     }
 
     /// Returns the targets of the outgoing edges of `src` with label `lbl`.
@@ -80,11 +102,8 @@ impl<'sg, LABEL: Hash + Eq, DATA> InnerScopeGraph<'sg, LABEL, DATA> {
         // panics if scope.0 is out of bounds
         // the methods that update `ScopeGraphs` retain the invariant that each scope has an appropriate entry in this vector
         // however, panics can still happen when a scope from a different scope graph is used
-        self.edges.borrow()[scope.0]
-            .borrow()
-            .get(&lbl)
-            .into_iter()
-            .flatten()
+        self.edges.borrow()[scope.0].borrow().as_ref()[lbl.to_usize()]
+            .iter()
             .copied()
             .collect()
     }
@@ -103,13 +122,21 @@ impl<'sg, LABEL: Hash + Eq, DATA> InnerScopeGraph<'sg, LABEL, DATA> {
 /// For example, there is no support for _removing_ scopes or edges, as this usually does not happen in scope graphs.
 /// In addition, there is no data type for edges, as edges should only be traversed, but never leak outside the scope graph structure.
 /// Finally, although not made explicit, `LABEL` should be a finite, iterable set.
-#[derive(Debug)]
-pub struct ScopeGraph<'storage, LABEL, DATA, CMPL> {
+pub struct ScopeGraph<'storage, LABEL: Label, DATA, CMPL> {
     pub(crate) inner_scope_graph: InnerScopeGraph<'storage, LABEL, DATA>,
     pub(crate) completeness: CMPL,
 }
 
-impl<'storage, LABEL, DATA, CMPL> ScopeGraph<'storage, LABEL, DATA, CMPL> {
+impl<LABEL: Label + Debug, DATA: Debug, CMPL: Debug> Debug for ScopeGraph<'_, LABEL, DATA, CMPL> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("ScopeGraph")
+            .field("inner_scope_graph", &self.inner_scope_graph)
+            .field("completeness", &self.inner_scope_graph)
+            .finish()
+    }
+}
+
+impl<'storage, LABEL: Label, DATA, CMPL> ScopeGraph<'storage, LABEL, DATA, CMPL> {
     /// Creates a new, empty, scope graph.
     ///
     /// You must supply a [`Storage`] object, in which the scope graph can allocate memory,
@@ -122,7 +149,7 @@ impl<'storage, LABEL, DATA, CMPL> ScopeGraph<'storage, LABEL, DATA, CMPL> {
     }
 }
 
-impl<'sg, LABEL, DATA> ScopeGraph<'sg, LABEL, DATA, UncheckedCompleteness> {
+impl<'sg, LABEL: Label, DATA> ScopeGraph<'sg, LABEL, DATA, UncheckedCompleteness> {
     /// Creates a new scope graph with [`UncheckedCompleteness`] as its completeness validation.
     ///
     /// # Safety
@@ -133,7 +160,7 @@ impl<'sg, LABEL, DATA> ScopeGraph<'sg, LABEL, DATA, UncheckedCompleteness> {
     }
 }
 
-impl<'sg, LABEL, DATA, CMPL> ScopeGraph<'sg, LABEL, DATA, CMPL>
+impl<'sg, LABEL: Label, DATA, CMPL> ScopeGraph<'sg, LABEL, DATA, CMPL>
 where
     CMPL: Completeness<LABEL, DATA>,
 {
@@ -185,7 +212,7 @@ where
     }
 }
 
-impl<'sg, LABEL, DATA, CMPL> ScopeGraph<'sg, LABEL, DATA, CMPL>
+impl<'sg, LABEL: Label, DATA, CMPL> ScopeGraph<'sg, LABEL, DATA, CMPL>
 where
     DATA: Default,
     CMPL: Completeness<LABEL, DATA>,
diff --git a/scopegraphs/src/storage.rs b/scopegraphs/src/storage.rs
index ae67f87..d1e9046 100644
--- a/scopegraphs/src/storage.rs
+++ b/scopegraphs/src/storage.rs
@@ -1,5 +1,4 @@
 use bumpalo::Bump;
-use std::fmt::{Debug, Formatter};
 
 /// Holds data for a [`ScopeGraph`](crate::ScopeGraph). Required to construct a `ScopeGraph`.
 ///
@@ -8,12 +7,6 @@ use std::fmt::{Debug, Formatter};
 #[derive(Default)]
 pub struct Storage(pub Bump);
 
-impl Debug for Storage {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        write!(f, "<scopegraph storage>")
-    }
-}
-
 impl Storage {
     /// Creates a new storage object.
     pub fn new() -> Self {