diff --git a/scopegraphs-lib/Cargo.toml b/scopegraphs-lib/Cargo.toml
index 53a1e4f..cbeb5de 100644
--- a/scopegraphs-lib/Cargo.toml
+++ b/scopegraphs-lib/Cargo.toml
@@ -12,3 +12,4 @@ scopegraphs-regular-expressions = {path = "../scopegraphs-regular-expressions"}
 
 [dev-dependencies]
 scopegraphs = {path = "../scopegraphs"}
+scopegraphs-macros = {path = "../scopegraphs-macros"}
diff --git a/scopegraphs-lib/src/resolve/topdown.rs b/scopegraphs-lib/src/resolve/topdown.rs
index 99d2f82..d999a78 100644
--- a/scopegraphs-lib/src/resolve/topdown.rs
+++ b/scopegraphs-lib/src/resolve/topdown.rs
@@ -3,7 +3,7 @@ use std::iter;
 
 use crate::{
     label::Label,
-    scopegraph::{Completeness, Scope},
+    scopegraph::{completeness::Completeness, Scope},
 };
 use scopegraphs_regular_expressions::RegexMatcher;
 
@@ -20,18 +20,18 @@ pub trait DataOrder<DATA>: for<'sg> Fn(&'sg DATA, &'sg DATA) -> bool {}
 impl<DATA, T> DataOrder<DATA> for T where for<'sg> T: Fn(&'sg DATA, &'sg DATA) -> bool {}
 
 #[derive(Debug, Hash, PartialEq, Eq)]
-pub enum EdgeOrData<'sg, LABEL> {
+pub enum EdgeOrData<LABEL> {
     Data,
-    Edge(&'sg LABEL),
+    Edge(LABEL),
 }
 
 // custom implementation not to impose LABEL: Copy
-impl<LABEL> Clone for EdgeOrData<'_, LABEL> {
+impl<LABEL: Copy> Clone for EdgeOrData<LABEL> {
     fn clone(&self) -> Self {
         *self
     }
 }
-impl<LABEL> Copy for EdgeOrData<'_, LABEL> {}
+impl<LABEL: Copy> Copy for EdgeOrData<LABEL> {}
 
 pub fn resolve<'sg: 'query, 'query, LABEL, DATA, CMPL>(
     sg: &'sg mut ScopeGraph<LABEL, DATA, CMPL>,
@@ -42,13 +42,13 @@ pub fn resolve<'sg: 'query, 'query, LABEL, DATA, CMPL>(
     source: Scope,
 ) -> Env<'sg, LABEL, DATA>
 where
-    LABEL: Label<'sg> + Copy + 'sg,
+    LABEL: Label + Copy,
     CMPL: Completeness<LABEL, DATA>,
     for<'a> CMPL::GetEdgesResult<'a>: Iterator<Item = Scope>,
     ResolvedPath<'sg, LABEL, DATA>: Hash + Eq,
     Path<LABEL>: Clone,
 {
-    let all_edges: Vec<EdgeOrData<LABEL>> = LABEL::iter_ref()
+    let all_edges: Vec<EdgeOrData<LABEL>> = LABEL::iter()
         .map(EdgeOrData::Edge)
         .chain(iter::once(EdgeOrData::Data))
         .collect();
@@ -65,7 +65,7 @@ where
 }
 
 struct ResolutionContext<'sg: 'query, 'query, LABEL, DATA, CMPL, DWF, LO, DO> {
-    all_edges: Vec<EdgeOrData<'query, LABEL>>,
+    all_edges: Vec<EdgeOrData<LABEL>>,
     sg: &'sg ScopeGraph<LABEL, DATA, CMPL>,
     data_wellformedness: &'query DWF,
     label_order: &'query LO,
@@ -95,7 +95,7 @@ where
             .copied()
             .filter(|e| match *e {
                 EdgeOrData::Data => path_wellformedness.is_accepting(),
-                EdgeOrData::Edge(label) => path_wellformedness.accepts([label]),
+                EdgeOrData::Edge(label) => path_wellformedness.accepts([&label]),
             })
             .collect();
 
@@ -105,7 +105,7 @@ where
     fn resolve_edges(
         &self,
         path_wellformedness: &mut impl for<'a> RegexMatcher<&'a LABEL>,
-        edges: &[EdgeOrData<'query, LABEL>],
+        edges: &[EdgeOrData<LABEL>],
         path: &Path<LABEL>,
     ) -> Env<'sg, LABEL, DATA> {
         let max = self.max(edges);
@@ -122,8 +122,8 @@ where
     fn resolve_shadow(
         &self,
         path_wellformedness: &mut impl for<'a> RegexMatcher<&'a LABEL>,
-        edge: EdgeOrData<'query, LABEL>,
-        edges: &[EdgeOrData<'query, LABEL>],
+        edge: EdgeOrData<LABEL>,
+        edges: &[EdgeOrData<LABEL>],
         path: &Path<LABEL>,
     ) -> Env<'sg, LABEL, DATA> {
         let mut env = Env::new();
@@ -143,11 +143,11 @@ where
     fn resolve_edge(
         &self,
         path_wellformedness: &mut impl for<'a> RegexMatcher<&'a LABEL>,
-        edge: EdgeOrData<'query, LABEL>,
+        edge: EdgeOrData<LABEL>,
         path: &Path<LABEL>,
     ) -> Env<'sg, LABEL, DATA> {
         match edge {
-            EdgeOrData::Edge(label) => self.resolve_label(path_wellformedness, *label, path),
+            EdgeOrData::Edge(label) => self.resolve_label(path_wellformedness, label, path),
             EdgeOrData::Data => self.resolve_data(path),
         }
     }
@@ -180,7 +180,7 @@ where
         }
     }
 
-    fn max(&self, edges: &[EdgeOrData<'query, LABEL>]) -> Vec<EdgeOrData<'query, LABEL>> {
+    fn max(&self, edges: &[EdgeOrData<LABEL>]) -> Vec<EdgeOrData<LABEL>> {
         edges
             .iter()
             .filter(|l| !edges.iter().any(|ll| (self.label_order)(l, ll)))
@@ -190,9 +190,9 @@ where
 
     fn smaller(
         &self,
-        edge: EdgeOrData<'query, LABEL>,
-        edges: &[EdgeOrData<'query, LABEL>],
-    ) -> Vec<EdgeOrData<'query, LABEL>> {
+        edge: EdgeOrData<LABEL>,
+        edges: &[EdgeOrData<LABEL>],
+    ) -> Vec<EdgeOrData<LABEL>> {
         edges
             .iter()
             .filter(|l| (self.label_order)(l, &edge))
@@ -200,3 +200,24 @@ where
             .collect()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use scopegraphs_macros::Label;
+
+    use crate::scopegraph::{completeness::ImplicitClose, ScopeGraph};
+
+    #[test]
+    fn test_traverse_single() {
+        #[derive(Label, Hash, PartialEq, Eq)]
+        enum Lbl {
+            Lex,
+            Def,
+        }
+
+        let mut scope_graph: ScopeGraph<Lbl, usize, ImplicitClose<Lbl>> =
+            ScopeGraph::new(ImplicitClose::default());
+
+        let s1 = scope_graph.new_scope(42);
+    }
+}
diff --git a/scopegraphs-lib/src/scopegraph/completeness.rs b/scopegraphs-lib/src/scopegraph/completeness.rs
index 9322de9..b4e269a 100644
--- a/scopegraphs-lib/src/scopegraph/completeness.rs
+++ b/scopegraphs-lib/src/scopegraph/completeness.rs
@@ -13,10 +13,10 @@ use private::Sealed;
 /*** Completeness trait ***/
 
 pub trait Completeness<LABEL, DATA>: Sealed {
-    fn new_scope(&mut self, inner_scope_graph: &InnerScopeGraph<LABEL, DATA>, scope: Scope); // FIXME `scope` needed?
+    fn cmpl_new_scope(&mut self, inner_scope_graph: &InnerScopeGraph<LABEL, DATA>, scope: Scope); // FIXME `scope` needed?
 
     type NewEdgeResult;
-    fn new_edge(
+    fn cmpl_new_edge(
         &mut self,
         inner_scope_graph: &mut InnerScopeGraph<LABEL, DATA>,
         src: Scope,
@@ -32,7 +32,7 @@ pub trait Completeness<LABEL, DATA>: Sealed {
         Self: 'a,
         DATA: 'a,
         LABEL: 'a;
-    fn get_edges<'a, 'b: 'a>(
+    fn cmpl_get_edges<'a, 'b: 'a>(
         &mut self,
         inner_scope_graph: &'a InnerScopeGraph<LABEL, DATA>,
         src: Scope,
@@ -46,11 +46,11 @@ struct UncheckedCompleteness {}
 impl Sealed for UncheckedCompleteness {}
 
 impl<LABEL: Hash + Eq, DATA> Completeness<LABEL, DATA> for UncheckedCompleteness {
-    fn new_scope(&mut self, inner_scope_graph: &InnerScopeGraph<LABEL, DATA>, scope: Scope) {}
+    fn cmpl_new_scope(&mut self, inner_scope_graph: &InnerScopeGraph<LABEL, DATA>, scope: Scope) {}
 
     type NewEdgeResult = ();
 
-    fn new_edge<'a>(
+    fn cmpl_new_edge<'a>(
         &mut self,
         inner_scope_graph: &mut InnerScopeGraph<LABEL, DATA>,
         src: Scope,
@@ -62,7 +62,7 @@ impl<LABEL: Hash + Eq, DATA> Completeness<LABEL, DATA> for UncheckedCompleteness
 
     type GetEdgesResult<'a> = Box<dyn Iterator<Item = Scope> + 'a> where DATA: 'a, LABEL: 'a;
 
-    fn get_edges<'a, 'b: 'a>(
+    fn cmpl_get_edges<'a, 'b: 'a>(
         &mut self,
         inner_scope_graph: &'a InnerScopeGraph<LABEL, DATA>,
         src: Scope,
@@ -78,6 +78,14 @@ struct CriticalEdgeSet<LABEL> {
     open_edges: Vec<HashSet<LABEL>>,
 }
 
+impl<LABEL> Default for CriticalEdgeSet<LABEL> {
+    fn default() -> Self {
+        Self {
+            open_edges: Default::default(),
+        }
+    }
+}
+
 impl<LABEL> CriticalEdgeSet<LABEL> {
     fn init_scope(&mut self, edges: HashSet<LABEL>) {
         self.open_edges.push(edges)
@@ -105,23 +113,22 @@ pub enum EdgesOrDelay<'a, EDGES, LABEL> {
 
 /*** Weakly-Critical-Edge Based Completeness Checking with Explicit Closing ***/
 
-struct ExplicitClose<LABEL> {
+#[derive(Default)]
+pub struct ExplicitClose<LABEL> {
     critical_edges: CriticalEdgeSet<LABEL>,
 }
 
 impl<LABEL> Sealed for ExplicitClose<LABEL> {}
 
-impl<LABEL: Hash + Eq + for<'a> Label<'a>, DATA> Completeness<LABEL, DATA>
-    for ExplicitClose<LABEL>
-{
-    fn new_scope(&mut self, inner_scope_graph: &InnerScopeGraph<LABEL, DATA>, scope: Scope) {
+impl<LABEL: Hash + Eq + Label, DATA> Completeness<LABEL, DATA> for ExplicitClose<LABEL> {
+    fn cmpl_new_scope(&mut self, inner_scope_graph: &InnerScopeGraph<LABEL, DATA>, scope: Scope) {
         self.critical_edges
             .init_scope(HashSet::from_iter(LABEL::iter()))
     }
 
     type NewEdgeResult = Result<(), EdgeClosedError<LABEL>>;
 
-    fn new_edge(
+    fn cmpl_new_edge(
         &mut self,
         inner_scope_graph: &mut InnerScopeGraph<LABEL, DATA>,
         src: Scope,
@@ -141,7 +148,7 @@ impl<LABEL: Hash + Eq + for<'a> Label<'a>, DATA> Completeness<LABEL, DATA>
 
     type GetEdgesResult<'a> = EdgesOrDelay<'a, Box<dyn Iterator<Item = Scope> + 'a>, LABEL> where DATA: 'a, LABEL: 'a;
 
-    fn get_edges<'a, 'b: 'a>(
+    fn cmpl_get_edges<'a, 'b: 'a>(
         &mut self,
         inner_scope_graph: &'a InnerScopeGraph<LABEL, DATA>,
         src: Scope,
@@ -162,16 +169,22 @@ impl<LABEL: Hash + Eq + for<'a> Label<'a>, DATA> Completeness<LABEL, DATA>
 
 /*** Weakly-Critical-Edge Based Completeness Checking with Implicit Closing ***/
 
-struct ImplicitClose<LABEL> {
+pub struct ImplicitClose<LABEL> {
     critical_edges: CriticalEdgeSet<LABEL>,
 }
 
+impl<LABEL> Default for ImplicitClose<LABEL> {
+    fn default() -> Self {
+        Self {
+            critical_edges: Default::default(),
+        }
+    }
+}
+
 impl<LABEL> Sealed for ImplicitClose<LABEL> {}
 
-impl<LABEL: Hash + Eq + for<'a> Label<'a>, DATA> Completeness<LABEL, DATA>
-    for ImplicitClose<LABEL>
-{
-    fn new_scope(&mut self, inner_scope_graph: &InnerScopeGraph<LABEL, DATA>, scope: Scope) {
+impl<LABEL: Hash + Eq + Label, DATA> Completeness<LABEL, DATA> for ImplicitClose<LABEL> {
+    fn cmpl_new_scope(&mut self, inner_scope_graph: &InnerScopeGraph<LABEL, DATA>, scope: Scope) {
         self.critical_edges
             .init_scope(HashSet::from_iter(LABEL::iter()))
     }
@@ -179,7 +192,7 @@ impl<LABEL: Hash + Eq + for<'a> Label<'a>, DATA> Completeness<LABEL, DATA>
     type NewEdgeResult = Result<(), EdgeClosedError<LABEL>>;
 
     // FIXME: identical to `ExplicitClose` impl.
-    fn new_edge(
+    fn cmpl_new_edge(
         &mut self,
         inner_scope_graph: &mut InnerScopeGraph<LABEL, DATA>,
         src: Scope,
@@ -200,7 +213,7 @@ impl<LABEL: Hash + Eq + for<'a> Label<'a>, DATA> Completeness<LABEL, DATA>
 
     type GetEdgesResult<'a> = Box<dyn Iterator<Item = Scope> + 'a> where DATA: 'a, LABEL: 'a;
 
-    fn get_edges<'a, 'b: 'a>(
+    fn cmpl_get_edges<'a, 'b: 'a>(
         &mut self,
         inner_scope_graph: &'a InnerScopeGraph<LABEL, DATA>,
         src: Scope,
diff --git a/scopegraphs-lib/src/scopegraph/mod.rs b/scopegraphs-lib/src/scopegraph/mod.rs
index ad5fff7..6f0432e 100644
--- a/scopegraphs-lib/src/scopegraph/mod.rs
+++ b/scopegraphs-lib/src/scopegraph/mod.rs
@@ -1,6 +1,6 @@
 #![allow(unused)]
 
-mod completeness;
+pub mod completeness;
 
 use std::{
     cell::RefCell,
@@ -12,7 +12,7 @@ use std::{
 
 use bumpalo::Bump;
 
-pub use completeness::Completeness;
+use completeness::Completeness;
 
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
 pub struct Scope(usize);
@@ -123,7 +123,16 @@ pub struct ScopeGraph<LABEL, DATA, CMPL> {
     completeness: RefCell<CMPL>,
 }
 
-impl<'a, LABEL, DATA, CMPL> ScopeGraph<LABEL, DATA, CMPL>
+impl<LABEL, DATA, CMPL> ScopeGraph<LABEL, DATA, CMPL> {
+    pub fn new(completeness: CMPL) -> Self {
+        ScopeGraph {
+            inner_scope_graph: InnerScopeGraph::new(),
+            completeness: RefCell::new(completeness),
+        }
+    }
+}
+
+impl<LABEL, DATA, CMPL> ScopeGraph<LABEL, DATA, CMPL>
 where
     CMPL: Completeness<LABEL, DATA>,
 {
@@ -131,23 +140,23 @@ where
         let scope = self.inner_scope_graph.add_scope(data);
         self.completeness
             .borrow_mut()
-            .new_scope(&self.inner_scope_graph, scope);
+            .cmpl_new_scope(&self.inner_scope_graph, scope);
         scope
     }
 
     pub fn new_edge(&mut self, src: Scope, lbl: LABEL, dst: Scope) -> CMPL::NewEdgeResult {
         self.completeness
             .borrow_mut()
-            .new_edge(&mut self.inner_scope_graph, src, lbl, dst)
+            .cmpl_new_edge(&mut self.inner_scope_graph, src, lbl, dst)
     }
 
     pub fn get_data(&self, scope: Scope) -> &DATA {
         &self.inner_scope_graph.data[scope.0]
     }
 
-    pub fn get_edges<'b: 'a>(&'a self, src: Scope, lbl: &'b LABEL) -> CMPL::GetEdgesResult<'a> {
+    pub fn get_edges<'a>(&'a self, src: Scope, lbl: &'a LABEL) -> CMPL::GetEdgesResult<'a> {
         self.completeness
             .borrow_mut()
-            .get_edges(&self.inner_scope_graph, src, lbl)
+            .cmpl_get_edges(&self.inner_scope_graph, src, lbl)
     }
 }