From c5b1f6fa7531d0d31411fa57b46a0c63c6343312 Mon Sep 17 00:00:00 2001
From: Aron Zwaan <aronzwaan@gmail.com>
Date: Wed, 23 Oct 2024 16:42:04 +0200
Subject: [PATCH 1/5] WIP container trait bounds

---
 scopegraphs/src/containers/path.rs  | 19 ++++---
 scopegraphs/src/containers/scope.rs | 31 +++++++----
 scopegraphs/src/lib.rs              |  1 +
 scopegraphs/src/resolve/lookup.rs   | 82 ++++++++++++++---------------
 4 files changed, 76 insertions(+), 57 deletions(-)

diff --git a/scopegraphs/src/containers/path.rs b/scopegraphs/src/containers/path.rs
index 043aa39..1129f7d 100644
--- a/scopegraphs/src/containers/path.rs
+++ b/scopegraphs/src/containers/path.rs
@@ -1,12 +1,16 @@
 use crate::future_wrapper::FutureWrapper;
-use crate::resolve::{Env, Path, ResolvedPath};
+use crate::resolve::{DataEquivalence, Env, Path, ResolvedPath};
 use futures::future::join_all;
 use std::hash::Hash;
+use std::fmt::Debug;
+
+use super::EnvContainer;
 
 /// Interface for path containers that support the operations required for query resolution.
-pub trait PathContainer<'sg, 'rslv, LABEL: 'sg, DATA: 'sg>: 'rslv {
+pub trait PathContainer<'sg, 'rslv, LABEL: 'sg, DATA: 'sg, DWFO>: Debug + 'rslv 
+{
     /// Type returned by resolving a path to its sub-environment.
-    type EnvContainer;
+    type EnvContainer: EnvContainer<'sg, 'rslv, LABEL, DATA, DWFO>;
 
     /// Computes sub-environments for each path in the container.
     fn map_into_env<F: 'rslv + FnMut(Path<LABEL>) -> Self::EnvContainer>(
@@ -15,11 +19,12 @@ pub trait PathContainer<'sg, 'rslv, LABEL: 'sg, DATA: 'sg>: 'rslv {
     ) -> Self::EnvContainer;
 }
 
-impl<'rslv, 'sg, LABEL: 'sg, DATA: 'sg> PathContainer<'sg, 'rslv, LABEL, DATA> for Vec<Path<LABEL>>
+impl<'rslv, 'sg, LABEL: Debug + 'sg, DATA: 'sg, DWFO> PathContainer<'sg, 'rslv, LABEL, DATA, DWFO> for Vec<Path<LABEL>>
 where
     Self: 'rslv,
     LABEL: Clone + Hash + Eq,
     DATA: Hash + Eq,
+    Env<'sg, LABEL, DATA>: EnvContainer<'sg, 'rslv, LABEL, DATA, DWFO>
 {
     type EnvContainer = Env<'sg, LABEL, DATA>;
 
@@ -30,13 +35,14 @@ where
 
 // TODO: can this be generalized to arbitrary results of PathContainers?
 // (challenge is converting between the different `::EnvContainer`s.)
-impl<'rslv, 'sg, LABEL: 'sg, DATA: 'sg, E: 'rslv> PathContainer<'sg, 'rslv, LABEL, DATA>
+impl<'rslv, 'sg, LABEL: Debug + 'sg, DATA: 'sg, E: Debug + 'rslv, DWFO> PathContainer<'sg, 'rslv, LABEL, DATA, DWFO>
     for Result<Vec<Path<LABEL>>, E>
 where
     Self: 'rslv,
     LABEL: Clone + Hash,
     DATA: Hash,
     for<'a> ResolvedPath<'a, LABEL, DATA>: Hash + Eq,
+    Result<Env<'sg, LABEL, DATA>, E>: EnvContainer<'sg, 'rslv, LABEL, DATA, DWFO>
 {
     type EnvContainer = Result<Env<'sg, LABEL, DATA>, E>;
 
@@ -49,12 +55,13 @@ where
         })
     }
 }
-impl<'sg, 'rslv, LABEL: 'sg, DATA: 'sg> PathContainer<'sg, 'rslv, LABEL, DATA>
+impl<'sg, 'rslv, LABEL: 'sg, DATA: 'sg, DWFO> PathContainer<'sg, 'rslv, LABEL, DATA, DWFO>
     for FutureWrapper<'rslv, Vec<Path<LABEL>>>
 where
     Self: 'rslv,
     LABEL: Clone + Hash,
     DATA: Hash,
+    FutureWrapper<'rslv, Env<'sg, LABEL, DATA>>: EnvContainer<'sg, 'rslv, LABEL, DATA, DWFO>,
     for<'a> ResolvedPath<'a, LABEL, DATA>: Hash + Eq,
 {
     type EnvContainer = FutureWrapper<'rslv, Env<'sg, LABEL, DATA>>;
diff --git a/scopegraphs/src/containers/scope.rs b/scopegraphs/src/containers/scope.rs
index 2986c4a..67a4884 100644
--- a/scopegraphs/src/containers/scope.rs
+++ b/scopegraphs/src/containers/scope.rs
@@ -1,20 +1,28 @@
+use std::hash::Hash;
+use std::fmt::Debug;
+
 use crate::future_wrapper::FutureWrapper;
 use crate::resolve::Path;
 use crate::Scope;
 
+use super::PathContainer;
+
 /// Interface for scope containers that support the operations required for query resolution.
-pub trait ScopeContainer<LABEL> {
+pub trait ScopeContainer<'sg, 'rslv, LABEL: Debug + 'sg, DATA: 'sg, DWFO>: Debug {
     /// The type containing paths obtained after stepping to this scope.
-    type PathContainer;
+    type PathContainer<DWFO_INNER> : PathContainer<'sg, 'rslv, LABEL, DATA, DWFO>;
 
     /// Lift the [`Path::step`] operation into this container.
     ///
     /// Should retain the contract that for all scopes `s` in `self`, `prefix.step(lbl, s)` is
     /// included in the resulting path container (except cyclic paths).
-    fn lift_step(self, lbl: LABEL, prefix: Path<LABEL>) -> Self::PathContainer;
+    fn lift_step<DWFO_INNER>(self, lbl: LABEL, prefix: Path<LABEL>) -> Self::PathContainer<DWFO_INNER>;
 }
 
-impl<LABEL: Copy> ScopeContainer<LABEL> for Vec<Scope> {
+impl<'sg: 'rslv, 'rslv, LABEL: Debug + Copy + Eq + Hash + 'sg, DATA: Eq + Hash + 'sg, DWFO> ScopeContainer<'sg, 'rslv, LABEL, DATA, DWFO> for Vec<Scope> 
+    where
+        Vec<Path<LABEL>>: PathContainer<'sg, 'rslv, LABEL, DATA, DWFO>
+{
     type PathContainer = Vec<Path<LABEL>>;
 
     fn lift_step(self, lbl: LABEL, prefix: Path<LABEL>) -> Self::PathContainer {
@@ -24,7 +32,10 @@ impl<LABEL: Copy> ScopeContainer<LABEL> for Vec<Scope> {
     }
 }
 
-impl<LABEL, SC: ScopeContainer<LABEL>, E> ScopeContainer<LABEL> for Result<SC, E> {
+impl<'sg: 'rslv, 'rslv, LABEL: Debug + Copy + Eq + Hash + 'sg, DATA: Eq + Hash + 'sg, DWFO, SC: ScopeContainer<'sg, 'rslv, LABEL, DATA, DWFO>, E: Debug> ScopeContainer<'sg, 'rslv, LABEL, DATA, DWFO> for Result<SC, E>
+    where
+        Result<SC::PathContainer, E>: PathContainer<'sg, 'rslv, LABEL, DATA, DWFO>
+{
     type PathContainer = Result<SC::PathContainer, E>;
 
     fn lift_step(self, lbl: LABEL, prefix: Path<LABEL>) -> Self::PathContainer {
@@ -32,17 +43,19 @@ impl<LABEL, SC: ScopeContainer<LABEL>, E> ScopeContainer<LABEL> for Result<SC, E
     }
 }
 
-impl<'rslv, LABEL, SC: ScopeContainer<LABEL> + Clone> ScopeContainer<LABEL>
+impl<'sg: 'rslv, 'rslv, LABEL: Debug + Copy + Eq + Hash + 'sg, DATA: Eq + Hash + 'sg, DWFO, SC: ScopeContainer<'sg, 'rslv, LABEL, DATA, DWFO> + Clone> ScopeContainer<'sg, 'rslv, LABEL, DATA, DWFO>
     for FutureWrapper<'rslv, SC>
 where
     LABEL: Copy,
-    SC::PathContainer: Clone,
     Self: 'rslv,
     LABEL: 'rslv,
 {
-    type PathContainer = FutureWrapper<'rslv, SC::PathContainer>;
+    type PathContainer<DWFO_INNER> = FutureWrapper<'rslv, SC::PathContainer<DWFO_INNER>>
+        where
+        SC::PathContainer<DWFO_INNER>: PathContainer<'sg, 'rslv, LABEL, DATA, DWFO_INNER> + Clone
+        ;
 
-    fn lift_step(self, lbl: LABEL, prefix: Path<LABEL>) -> Self::PathContainer {
+    fn lift_step<DWFO_INNER>(self, lbl: LABEL, prefix: Path<LABEL>) -> Self::PathContainer<DWFO_INNER> {
         FutureWrapper::new(async move { self.0.await.lift_step(lbl, prefix.clone()) })
     }
 }
diff --git a/scopegraphs/src/lib.rs b/scopegraphs/src/lib.rs
index 2d753a2..06da5c7 100644
--- a/scopegraphs/src/lib.rs
+++ b/scopegraphs/src/lib.rs
@@ -11,6 +11,7 @@
 #![allow(unknown_lints)]
 #![allow(unexpected_cfgs)]
 #![allow(clippy::empty_docs)]
+#![feature(type_alias_impl_trait)]
 
 #[cfg(feature = "documentation")]
 pub mod concepts;
diff --git a/scopegraphs/src/resolve/lookup.rs b/scopegraphs/src/resolve/lookup.rs
index fd8dfc6..e14cb25 100644
--- a/scopegraphs/src/resolve/lookup.rs
+++ b/scopegraphs/src/resolve/lookup.rs
@@ -28,16 +28,7 @@ where
     LABEL: Label + Copy + Debug + Hash,
     DATA: Debug,
     CMPL: Completeness<LABEL, DATA>,
-    CMPL::GetEdgesResult<'rslv>: ScopeContainer<LABEL>,
-    <CMPL::GetEdgesResult<'rslv> as ScopeContainer<LABEL>>::PathContainer:
-        PathContainer<'sg, 'rslv, LABEL, DATA>,
-    <<CMPL::GetEdgesResult<'rslv> as ScopeContainer<LABEL>>::PathContainer as PathContainer<
-        'sg,
-        'rslv,
-        LABEL,
-        DATA,
-    >>::EnvContainer: EnvContainer<'sg, 'rslv, LABEL, DATA, <DWF as DataWellformedness<'sg, DATA>>::Output>
-        + Debug,
+    CMPL::GetEdgesResult<'rslv> : ScopeContainer<'sg, 'rslv, LABEL, DATA, DWF::Output>,
     PWF: for<'a> RegexMatcher<&'a LABEL> + 'rslv,
     DWF: DataWellformedness<'sg, DATA> + 'rslv,
 
@@ -48,7 +39,7 @@ where
     Path<LABEL>: Clone,
 {
     type EnvContainer
-        = EnvC<'sg, 'rslv, CMPL, LABEL, DATA>
+        = EnvC<'sg, 'rslv, CMPL, LABEL, DATA, DWF::Output>
     where
         'sg: 'rslv,
         Self: 'rslv;
@@ -104,9 +95,9 @@ struct ResolutionContext<'storage, 'sg: 'rslv, 'rslv, LABEL: Label, DATA, CMPL,
     data_equiv: &'rslv DEq,
 }
 
-type EnvC<'sg, 'rslv, CMPL, LABEL, DATA> = <<<CMPL as Completeness<LABEL, DATA>>::GetEdgesResult<
+type EnvC<'sg, 'rslv, CMPL, LABEL, DATA, DWFO> = <<<CMPL as Completeness<LABEL, DATA>>::GetEdgesResult<
     'rslv,
-> as ScopeContainer<LABEL>>::PathContainer as PathContainer<'sg, 'rslv, LABEL, DATA>>::EnvContainer;
+> as ScopeContainer<'sg, 'rslv, LABEL, DATA, DWFO>>::PathContainer as PathContainer<'sg, 'rslv, LABEL, DATA, DWFO>>::EnvContainer;
 
 type EnvCache<LABEL, ENVC> = RefCell<HashMap<EdgeOrData<LABEL>, Rc<ENVC>>>;
 
@@ -117,16 +108,7 @@ where
     DATA: Debug,
     ResolvedPath<'sg, LABEL, DATA>: Hash + Eq,
     CMPL: Completeness<LABEL, DATA>,
-    CMPL::GetEdgesResult<'rslv>: ScopeContainer<LABEL>,
-    <CMPL::GetEdgesResult<'rslv> as ScopeContainer<LABEL>>::PathContainer:
-        PathContainer<'sg, 'rslv, LABEL, DATA>,
-    <<CMPL::GetEdgesResult<'rslv> as ScopeContainer<LABEL>>::PathContainer as PathContainer<
-        'sg,
-        'rslv,
-        LABEL,
-        DATA,
-    >>::EnvContainer: EnvContainer<'sg, 'rslv, LABEL, DATA, <DWF as DataWellformedness<'sg, DATA>>::Output>
-        + Debug,
+    CMPL::GetEdgesResult<'rslv> : ScopeContainer<'sg, 'rslv, LABEL, DATA, DWF::Output>,
     DEq: DataEquivalence<DATA>,
     DWF: DataWellformedness<'sg, DATA>,
     LO: LabelOrder<LABEL>,
@@ -140,7 +122,7 @@ where
         self: &Arc<Self>,
         path_wellformedness: impl for<'a> RegexMatcher<&'a LABEL> + 'rslv,
         path: Path<LABEL>,
-    ) -> EnvC<'sg, 'rslv, CMPL, LABEL, DATA> {
+    ) -> EnvC<'sg, 'rslv, CMPL, LABEL, DATA, DWF::Output> {
         let edges: Vec<_> = self
             .all_edges
             .iter()
@@ -164,15 +146,15 @@ where
         path_wellformedness: impl for<'a> RegexMatcher<&'a LABEL> + 'rslv,
         edges: &[EdgeOrData<LABEL>],
         path: Path<LABEL>,
-        cache: &EnvCache<LABEL, EnvC<'sg, 'rslv, CMPL, LABEL, DATA>>,
-    ) -> EnvC<'sg, 'rslv, CMPL, LABEL, DATA> {
+        cache: &EnvCache<LABEL, EnvC<'sg, 'rslv, CMPL, LABEL, DATA, DWF::Output>>,
+    ) -> EnvC<'sg, 'rslv, CMPL, LABEL, DATA, DWF::Output> {
         // set of labels that are to be resolved last
         let max = self.max(edges);
         let tgt = path.target();
         log::info!("Resolving max-edges {:?} in {:?}", max, tgt);
 
         max.into_iter()
-            .map::<Rc<EnvC<'sg, 'rslv, CMPL, LABEL, DATA>>, _>(|edge| {
+            .map::<Rc<EnvC<'sg, 'rslv, CMPL, LABEL, DATA, DWF::Output>>, _>(|edge| {
                 if let Some(env) = cache.borrow().get(&edge) {
                     log::info!("Reuse {:?}-environment from cache", edge);
                     return env.clone();
@@ -201,7 +183,7 @@ where
                     let mut merged_env = agg_env.clone();
                     env2.flat_map(move |new_env| {
                         merged_env.merge(new_env);
-                        <EnvC<'sg, 'rslv, CMPL, LABEL, DATA> as From<Env<'sg, LABEL, DATA>>>::from(
+                        <EnvC<'sg, 'rslv, CMPL, LABEL, DATA, DWF::Output> as From<Env<'sg, LABEL, DATA>>>::from(
                             merged_env,
                         )
                     })
@@ -220,16 +202,16 @@ where
         edge: EdgeOrData<LABEL>,     // current max label
         edges: &[EdgeOrData<LABEL>], // smaller set of `edge`
         path: Path<LABEL>,
-        cache: &EnvCache<LABEL, EnvC<'sg, 'rslv, CMPL, LABEL, DATA>>,
-    ) -> Rc<EnvC<'sg, 'rslv, CMPL, LABEL, DATA>> {
+        cache: &EnvCache<LABEL, EnvC<'sg, 'rslv, CMPL, LABEL, DATA, DWF::Output>>,
+    ) -> Rc<EnvC<'sg, 'rslv, CMPL, LABEL, DATA, DWF::Output>> {
         // base environment
-        let base_env: EnvC<'sg, 'rslv, CMPL, LABEL, DATA> =
+        let base_env: EnvC<'sg, 'rslv, CMPL, LABEL, DATA, DWF::Output> =
             self.resolve_edges(path_wellformedness.clone(), edges, path.clone(), cache);
         let local_self = Arc::clone(self);
         // environment of current (max) label, which might be shadowed by the base environment
         Rc::new(base_env.flat_map(move |base_env| {
             if !base_env.is_empty() && local_self.data_equiv.always_equivalent() {
-                <EnvC<'sg, 'rslv, CMPL, LABEL, DATA> as From<Env<'sg, LABEL, DATA>>>::from(
+                <EnvC<'sg, 'rslv, CMPL, LABEL, DATA, DWF::Output> as From<Env<'sg, LABEL, DATA>>>::from(
                     base_env.clone(),
                 )
             } else {
@@ -263,7 +245,7 @@ where
                     for path in filtered_env {
                         new_env.insert(path.clone())
                     }
-                    <EnvC<'sg, 'rslv, CMPL, LABEL, DATA> as From<Env<'sg, LABEL, DATA>>>::from(
+                    <EnvC<'sg, 'rslv, CMPL, LABEL, DATA, DWF::Output> as From<Env<'sg, LABEL, DATA>>>::from(
                         new_env,
                     )
                 })
@@ -277,7 +259,7 @@ where
         path_wellformedness: impl for<'a> RegexMatcher<&'a LABEL> + 'rslv,
         edge: EdgeOrData<LABEL>,
         path: Path<LABEL>,
-    ) -> EnvC<'sg, 'rslv, CMPL, LABEL, DATA> {
+    ) -> EnvC<'sg, 'rslv, CMPL, LABEL, DATA, DWF::Output> {
         match edge {
             EdgeOrData::Edge(label) => {
                 let mut new_path_wellformedness = path_wellformedness.clone();
@@ -297,24 +279,24 @@ where
         path_wellformedness: impl for<'a> RegexMatcher<&'a LABEL> + 'rslv,
         label: LABEL,
         path: Path<LABEL>,
-    ) -> EnvC<'sg, 'rslv, CMPL, LABEL, DATA> {
+    ) -> EnvC<'sg, 'rslv, CMPL, LABEL, DATA, DWF::Output> {
         let source = path.target();
         let targets = self.sg.get_edges(source, label);
         let path_set = targets.lift_step(label, path.clone());
         let local_ctx = Arc::clone(self);
-        let env: EnvC<'sg, 'rslv, CMPL, LABEL, DATA> = path_set.map_into_env::<_>(move |p| {
+        let env: EnvC<'sg, 'rslv, CMPL, LABEL, DATA, DWF::Output> = path_set.map_into_env::<_>(move |p| {
             local_ctx.resolve_all(path_wellformedness.clone(), p.clone())
         });
         env
     }
 
     /// Creates single-path environment if the data `path.target()` is matching, or an empty environment otherwise.
-    fn resolve_data(&self, path: Path<LABEL>) -> EnvC<'sg, 'rslv, CMPL, LABEL, DATA> {
+    fn resolve_data(&self, path: Path<LABEL>) -> EnvC<'sg, 'rslv, CMPL, LABEL, DATA, DWF::Output> {
         let data = self.sg.get_data(path.target());
         let path = path.clone().resolve(data);
         let data_ok = self.data_wellformedness.data_wf(data);
 
-        <EnvC<'sg, 'rslv, CMPL, LABEL, DATA> as EnvContainer<
+        <EnvC<'sg, 'rslv, CMPL, LABEL, DATA, DWF::Output> as EnvContainer<
             'sg,
             'rslv,
             LABEL,
@@ -351,8 +333,8 @@ where
         smaller
     }
 
-    fn empty_env_container() -> EnvC<'sg, 'rslv, CMPL, LABEL, DATA> {
-        <EnvC<'sg, 'rslv, CMPL, LABEL, DATA> as EnvContainer<
+    fn empty_env_container() -> EnvC<'sg, 'rslv, CMPL, LABEL, DATA, DWF::Output> {
+        <EnvC<'sg, 'rslv, CMPL, LABEL, DATA, DWF::Output> as EnvContainer<
             'sg,
             'rslv,
             LABEL,
@@ -374,7 +356,7 @@ mod tests {
         },
         future_wrapper::FutureWrapper,
         query_regex,
-        resolve::{Resolve, ResolvedPath},
+        resolve::{DataWellformedness, Resolve, ResolvedPath},
         storage::Storage,
         Label, ScopeGraph,
     };
@@ -478,7 +460,19 @@ mod tests {
                 .with_path_wellformedness(query_regex!(Lbl: Lex* Imp? Def))
                 .with_data_wellformedness(TData::matcher_fut("x"))
                 .with_label_order(label_order!(Lbl: Def < Imp < Lex));
-            let env = query.resolve(s_let).await;
+            type DWF = impl for<'sg> DataWellformedness<'sg, TData<'sg>, Output = FutureWrapper<'sg, bool>>;
+            let env = crate::resolve::Query::<
+                '_,
+                '_,
+                '_,
+                _,
+                _,
+                _,
+                _,
+                DWF,
+                _,
+                _
+            >::resolve(&query, s_let).await;
 
             let env_vec = env.into_iter().collect::<Vec<_>>();
             assert_eq!(1, env_vec.len());
@@ -490,6 +484,10 @@ mod tests {
         });
     }
 
+    fn explicate_dwf_impl<'sg, DATA: 'sg>(dwf: impl for<'b> Fn(&'b DATA) -> FutureWrapper<'b, bool> ) -> impl DataWellformedness<'sg, DATA> {
+        dwf
+    }
+
     #[test]
     fn test_match_data() {
         let storage = Storage::new();

From 2caae92f883334c8893d999f1079b194727b4013 Mon Sep 17 00:00:00 2001
From: Aron Zwaan <aronzwaan@gmail.com>
Date: Fri, 25 Oct 2024 16:23:54 +0200
Subject: [PATCH 2/5] Towards an implementation of proper early error messages

---
 scopegraphs/src/containers/path.rs  |  32 ++++++--
 scopegraphs/src/containers/scope.rs | 109 ++++++++++++++++++++++++----
 scopegraphs/src/lib.rs              |   5 +-
 scopegraphs/src/resolve/lookup.rs   |  12 +--
 4 files changed, 127 insertions(+), 31 deletions(-)

diff --git a/scopegraphs/src/containers/path.rs b/scopegraphs/src/containers/path.rs
index 1129f7d..d52a418 100644
--- a/scopegraphs/src/containers/path.rs
+++ b/scopegraphs/src/containers/path.rs
@@ -7,10 +7,10 @@ use std::fmt::Debug;
 use super::EnvContainer;
 
 /// Interface for path containers that support the operations required for query resolution.
-pub trait PathContainer<'sg, 'rslv, LABEL: 'sg, DATA: 'sg, DWFO>: Debug + 'rslv 
+pub trait PathContainer<'sg, 'rslv, LABEL: 'sg, DATA: 'sg>: Debug + 'rslv 
 {
     /// Type returned by resolving a path to its sub-environment.
-    type EnvContainer: EnvContainer<'sg, 'rslv, LABEL, DATA, DWFO>;
+    type EnvContainer;
 
     /// Computes sub-environments for each path in the container.
     fn map_into_env<F: 'rslv + FnMut(Path<LABEL>) -> Self::EnvContainer>(
@@ -19,12 +19,30 @@ pub trait PathContainer<'sg, 'rslv, LABEL: 'sg, DATA: 'sg, DWFO>: Debug + 'rslv
     ) -> Self::EnvContainer;
 }
 
-impl<'rslv, 'sg, LABEL: Debug + 'sg, DATA: 'sg, DWFO> PathContainer<'sg, 'rslv, LABEL, DATA, DWFO> for Vec<Path<LABEL>>
+pub trait PathContainerWf<'sg, 'rslv, LABEL: 'sg, DATA: 'sg, DWFO>: PathContainer<'sg, 'rslv, LABEL, DATA, EnvContainer = Self::EnvContainerWf> {
+    
+    type EnvContainerWf: EnvContainer<'sg, 'rslv, LABEL, DATA, DWFO>;
+
+}
+
+
+impl<'sg, 'rslv, LABEL, DATA, DWFO, T> PathContainerWf<'sg, 'rslv, LABEL, DATA, DWFO> for T 
+    where
+        LABEL: Debug + 'sg,
+        DATA: 'sg,
+        T: PathContainer<'sg, 'rslv, LABEL, DATA>,
+        Self::EnvContainer: EnvContainer<'sg, 'rslv, LABEL, DATA, DWFO>
+{
+    type EnvContainerWf = Self::EnvContainer;
+}
+
+
+
+impl<'rslv, 'sg, LABEL: Debug + 'sg, DATA: 'sg> PathContainer<'sg, 'rslv, LABEL, DATA> for Vec<Path<LABEL>>
 where
     Self: 'rslv,
     LABEL: Clone + Hash + Eq,
     DATA: Hash + Eq,
-    Env<'sg, LABEL, DATA>: EnvContainer<'sg, 'rslv, LABEL, DATA, DWFO>
 {
     type EnvContainer = Env<'sg, LABEL, DATA>;
 
@@ -35,14 +53,13 @@ where
 
 // TODO: can this be generalized to arbitrary results of PathContainers?
 // (challenge is converting between the different `::EnvContainer`s.)
-impl<'rslv, 'sg, LABEL: Debug + 'sg, DATA: 'sg, E: Debug + 'rslv, DWFO> PathContainer<'sg, 'rslv, LABEL, DATA, DWFO>
+impl<'rslv, 'sg, LABEL: Debug + 'sg, DATA: 'sg, E: Debug + 'rslv> PathContainer<'sg, 'rslv, LABEL, DATA>
     for Result<Vec<Path<LABEL>>, E>
 where
     Self: 'rslv,
     LABEL: Clone + Hash,
     DATA: Hash,
     for<'a> ResolvedPath<'a, LABEL, DATA>: Hash + Eq,
-    Result<Env<'sg, LABEL, DATA>, E>: EnvContainer<'sg, 'rslv, LABEL, DATA, DWFO>
 {
     type EnvContainer = Result<Env<'sg, LABEL, DATA>, E>;
 
@@ -55,13 +72,12 @@ where
         })
     }
 }
-impl<'sg, 'rslv, LABEL: 'sg, DATA: 'sg, DWFO> PathContainer<'sg, 'rslv, LABEL, DATA, DWFO>
+impl<'sg, 'rslv, LABEL: 'sg, DATA: 'sg> PathContainer<'sg, 'rslv, LABEL, DATA>
     for FutureWrapper<'rslv, Vec<Path<LABEL>>>
 where
     Self: 'rslv,
     LABEL: Clone + Hash,
     DATA: Hash,
-    FutureWrapper<'rslv, Env<'sg, LABEL, DATA>>: EnvContainer<'sg, 'rslv, LABEL, DATA, DWFO>,
     for<'a> ResolvedPath<'a, LABEL, DATA>: Hash + Eq,
 {
     type EnvContainer = FutureWrapper<'rslv, Env<'sg, LABEL, DATA>>;
diff --git a/scopegraphs/src/containers/scope.rs b/scopegraphs/src/containers/scope.rs
index 67a4884..4a0382a 100644
--- a/scopegraphs/src/containers/scope.rs
+++ b/scopegraphs/src/containers/scope.rs
@@ -5,23 +5,106 @@ use crate::future_wrapper::FutureWrapper;
 use crate::resolve::Path;
 use crate::Scope;
 
-use super::PathContainer;
+use super::{PathContainer, PathContainerWf};
 
 /// Interface for scope containers that support the operations required for query resolution.
-pub trait ScopeContainer<'sg, 'rslv, LABEL: Debug + 'sg, DATA: 'sg, DWFO>: Debug {
+pub trait ScopeContainer<'sg, 'rslv, LABEL: Debug + 'sg, DATA: 'sg>: Debug {
     /// The type containing paths obtained after stepping to this scope.
-    type PathContainer<DWFO_INNER> : PathContainer<'sg, 'rslv, LABEL, DATA, DWFO>;
+    type PathContainer;
 
     /// Lift the [`Path::step`] operation into this container.
     ///
     /// Should retain the contract that for all scopes `s` in `self`, `prefix.step(lbl, s)` is
     /// included in the resulting path container (except cyclic paths).
-    fn lift_step<DWFO_INNER>(self, lbl: LABEL, prefix: Path<LABEL>) -> Self::PathContainer<DWFO_INNER>;
+    fn lift_step(self, lbl: LABEL, prefix: Path<LABEL>) -> Self::PathContainer;
 }
 
-impl<'sg: 'rslv, 'rslv, LABEL: Debug + Copy + Eq + Hash + 'sg, DATA: Eq + Hash + 'sg, DWFO> ScopeContainer<'sg, 'rslv, LABEL, DATA, DWFO> for Vec<Scope> 
+/// Trait that is auto-implemented for any [ScopeContainer] implementation that yields a valid [PathContainer].
+/// 
+/// This trait is implemented for:
+/// - `Vec<Scope>`,
+/// - [Result] of scope containers, and
+/// - [FutureWrapper] of scope containers.
+/// ```
+/// # use scopegraphs::containers::ScopeContainerWf;
+/// # use scopegraphs::future_wrapper::FutureWrapper;
+/// # use scopegraphs::Scope;
+/// # use std::fmt::Debug;
+/// # use std::hash::Hash;
+/// 
+/// # trait LBound<'sg>: Copy + Hash + Eq + Debug + 'sg {}
+/// # trait DBound<'sg>: Hash + Eq + 'sg {}
+/// 
+/// fn test<'sg, 'rslv, LABEL: LBound<'sg>, DATA: DBound<'sg>, DWFO>(
+///     cont: impl ScopeContainerWf<'sg, 'rslv, LABEL, DATA, DWFO>
+/// ) { }
+/// 
+/// # fn scope_vec<'sg, 'rslv, LABEL: LBound<'sg>, DATA: DBound<'sg>>() {
+///     let vec: Vec<Scope> = todo!();
+///     test::<'_, '_, LABEL, DATA, bool>(vec);
+/// # }
+/// 
+/// # fn result<'sg, 'rslv, LABEL: LBound<'sg>, DATA: DBound<'sg>, E: Debug + Clone>() {
+///     let result: Result<Vec<Scope>, E> = todo!();
+///     test::<'_, '_, LABEL, DATA, bool>(result);
+///     test::<'_, '_, LABEL, DATA, Result<bool, E>>(result);
+/// # }
+/// 
+/// # fn future<'sg, 'rslv, LABEL: LBound<'sg>, DATA: DBound<'sg>>() {
+///     let future: FutureWrapper<Vec<Scope>> = todo!();
+///     test::<'_, '_, LABEL, DATA, bool>(future);
+///     test::<'_, '_, LABEL, DATA, FutureWrapper<'_, bool>>(result);
+/// # }
+/// ```
+/// 
+/// ```no_run
+/// # use scopegraphs::containers::ScopeContainerWf;
+/// # use scopegraphs::Scope;
+/// # use std::fmt::Debug;
+/// # use std::hash::Hash;
+/// 
+/// 
+/// fn test<'sg, 'rslv, LABEL: Hash + Eq + Debug + 'sg, DATA: Hash + Eq + 'sg, DWFO>(cont: impl ScopeContainerWf<'sg, 'rslv, LABEL, DATA, DWFO>) {
+/// 
+/// }
+/// ```
+/// 
+/// ```no_run
+/// # use scopegraphs::containers::ScopeContainerWf;
+/// # use scopegraphs::Scope;
+/// # use std::fmt::Debug;
+/// # use std::hash::Hash;
+/// 
+/// test::<'_, '_, (), (), bool>(Result::<_, ()>::Ok(Vec::<Scope>::new()));
+/// test::<'_, '_, (), (), Result<bool, ()>>(Result::<_, ()>::Ok(Vec::<Scope>::new()));
+/// 
+/// fn test<'sg, 'rslv, LABEL: Hash + Eq + Debug + 'sg, DATA: Hash + Eq + 'sg, DWFO>(cont: impl ScopeContainerWf<'sg, 'rslv, LABEL, DATA, DWFO>) {
+/// 
+/// }
+/// ```
+/// 
+pub trait ScopeContainerWf<'sg, 'rslv, LABEL, DATA, DWFO>: ScopeContainer<'sg, 'rslv, LABEL, DATA, PathContainer = Self::PathContainerWf> 
     where
-        Vec<Path<LABEL>>: PathContainer<'sg, 'rslv, LABEL, DATA, DWFO>
+        LABEL: Debug + 'sg,
+        DATA: 'sg
+{
+    type PathContainerWf: PathContainerWf<'sg, 'rslv, LABEL, DATA, DWFO>;
+}
+
+impl<'sg, 'rslv, LABEL, DATA, DWFO, T> ScopeContainerWf<'sg, 'rslv, LABEL, DATA, DWFO> for T 
+    where
+        LABEL: Debug + 'sg,
+        DATA: 'sg,
+        T: ScopeContainer<'sg, 'rslv, LABEL, DATA>,
+        Self::PathContainer: PathContainerWf<'sg, 'rslv, LABEL, DATA, DWFO>
+{
+    type PathContainerWf = Self::PathContainer;
+}
+
+
+impl<'sg: 'rslv, 'rslv, LABEL: Debug + Copy + Eq + Hash + 'sg, DATA: Eq + Hash + 'sg> ScopeContainer<'sg, 'rslv, LABEL, DATA> for Vec<Scope> 
+    where
+        Vec<Path<LABEL>>: PathContainer<'sg, 'rslv, LABEL, DATA>
 {
     type PathContainer = Vec<Path<LABEL>>;
 
@@ -32,9 +115,9 @@ impl<'sg: 'rslv, 'rslv, LABEL: Debug + Copy + Eq + Hash + 'sg, DATA: Eq + Hash +
     }
 }
 
-impl<'sg: 'rslv, 'rslv, LABEL: Debug + Copy + Eq + Hash + 'sg, DATA: Eq + Hash + 'sg, DWFO, SC: ScopeContainer<'sg, 'rslv, LABEL, DATA, DWFO>, E: Debug> ScopeContainer<'sg, 'rslv, LABEL, DATA, DWFO> for Result<SC, E>
+impl<'sg: 'rslv, 'rslv, LABEL: Debug + Copy + Eq + Hash + 'sg, DATA: Eq + Hash + 'sg, SC: ScopeContainer<'sg, 'rslv, LABEL, DATA>, E: Debug> ScopeContainer<'sg, 'rslv, LABEL, DATA> for Result<SC, E>
     where
-        Result<SC::PathContainer, E>: PathContainer<'sg, 'rslv, LABEL, DATA, DWFO>
+        Result<SC::PathContainer, E>: PathContainer<'sg, 'rslv, LABEL, DATA>
 {
     type PathContainer = Result<SC::PathContainer, E>;
 
@@ -43,19 +126,17 @@ impl<'sg: 'rslv, 'rslv, LABEL: Debug + Copy + Eq + Hash + 'sg, DATA: Eq + Hash +
     }
 }
 
-impl<'sg: 'rslv, 'rslv, LABEL: Debug + Copy + Eq + Hash + 'sg, DATA: Eq + Hash + 'sg, DWFO, SC: ScopeContainer<'sg, 'rslv, LABEL, DATA, DWFO> + Clone> ScopeContainer<'sg, 'rslv, LABEL, DATA, DWFO>
+impl<'sg: 'rslv, 'rslv, LABEL: Debug + Copy + Eq + Hash + 'sg, DATA: Eq + Hash + 'sg, SC: ScopeContainer<'sg, 'rslv, LABEL, DATA> + Clone> ScopeContainer<'sg, 'rslv, LABEL, DATA>
     for FutureWrapper<'rslv, SC>
 where
     LABEL: Copy,
     Self: 'rslv,
     LABEL: 'rslv,
+    SC::PathContainer: Clone
 {
-    type PathContainer<DWFO_INNER> = FutureWrapper<'rslv, SC::PathContainer<DWFO_INNER>>
-        where
-        SC::PathContainer<DWFO_INNER>: PathContainer<'sg, 'rslv, LABEL, DATA, DWFO_INNER> + Clone
-        ;
+    type PathContainer = FutureWrapper<'rslv, SC::PathContainer>;
 
-    fn lift_step<DWFO_INNER>(self, lbl: LABEL, prefix: Path<LABEL>) -> Self::PathContainer<DWFO_INNER> {
+    fn lift_step(self, lbl: LABEL, prefix: Path<LABEL>) -> Self::PathContainer {
         FutureWrapper::new(async move { self.0.await.lift_step(lbl, prefix.clone()) })
     }
 }
diff --git a/scopegraphs/src/lib.rs b/scopegraphs/src/lib.rs
index 06da5c7..63dd120 100644
--- a/scopegraphs/src/lib.rs
+++ b/scopegraphs/src/lib.rs
@@ -30,7 +30,10 @@ pub use scopegraphs_regular_expressions::*;
 
 pub mod completeness;
 pub mod containers;
-mod future_wrapper;
+// #[cfg(test)]
+pub mod future_wrapper;
+// #[cfg(not(test))]
+// mod future_wrapper;
 
 pub mod resolve;
 
diff --git a/scopegraphs/src/resolve/lookup.rs b/scopegraphs/src/resolve/lookup.rs
index e14cb25..2b7aea0 100644
--- a/scopegraphs/src/resolve/lookup.rs
+++ b/scopegraphs/src/resolve/lookup.rs
@@ -13,7 +13,7 @@ use std::rc::Rc;
 use std::sync::Arc;
 
 use crate::completeness::Completeness;
-use crate::containers::{EnvContainer, PathContainer, ScopeContainer};
+use crate::containers::{EnvContainer, PathContainer, PathContainerWf, ScopeContainer, ScopeContainerWf};
 use crate::resolve::{
     DataEquivalence, DataWellformedness, EdgeOrData, Env, LabelOrder, Path, Query, Resolve,
     ResolvedPath,
@@ -28,7 +28,7 @@ where
     LABEL: Label + Copy + Debug + Hash,
     DATA: Debug,
     CMPL: Completeness<LABEL, DATA>,
-    CMPL::GetEdgesResult<'rslv> : ScopeContainer<'sg, 'rslv, LABEL, DATA, DWF::Output>,
+    CMPL::GetEdgesResult<'rslv> : ScopeContainerWf<'sg, 'rslv, LABEL, DATA, DWF::Output>,
     PWF: for<'a> RegexMatcher<&'a LABEL> + 'rslv,
     DWF: DataWellformedness<'sg, DATA> + 'rslv,
 
@@ -97,7 +97,7 @@ struct ResolutionContext<'storage, 'sg: 'rslv, 'rslv, LABEL: Label, DATA, CMPL,
 
 type EnvC<'sg, 'rslv, CMPL, LABEL, DATA, DWFO> = <<<CMPL as Completeness<LABEL, DATA>>::GetEdgesResult<
     'rslv,
-> as ScopeContainer<'sg, 'rslv, LABEL, DATA, DWFO>>::PathContainer as PathContainer<'sg, 'rslv, LABEL, DATA, DWFO>>::EnvContainer;
+> as ScopeContainerWf<'sg, 'rslv, LABEL, DATA, DWFO>>::PathContainerWf as PathContainerWf<'sg, 'rslv, LABEL, DATA, DWFO>>::EnvContainerWf;
 
 type EnvCache<LABEL, ENVC> = RefCell<HashMap<EdgeOrData<LABEL>, Rc<ENVC>>>;
 
@@ -108,7 +108,7 @@ where
     DATA: Debug,
     ResolvedPath<'sg, LABEL, DATA>: Hash + Eq,
     CMPL: Completeness<LABEL, DATA>,
-    CMPL::GetEdgesResult<'rslv> : ScopeContainer<'sg, 'rslv, LABEL, DATA, DWF::Output>,
+    CMPL::GetEdgesResult<'rslv> : ScopeContainerWf<'sg, 'rslv, LABEL, DATA, DWF::Output>,
     DEq: DataEquivalence<DATA>,
     DWF: DataWellformedness<'sg, DATA>,
     LO: LabelOrder<LABEL>,
@@ -484,10 +484,6 @@ mod tests {
         });
     }
 
-    fn explicate_dwf_impl<'sg, DATA: 'sg>(dwf: impl for<'b> Fn(&'b DATA) -> FutureWrapper<'b, bool> ) -> impl DataWellformedness<'sg, DATA> {
-        dwf
-    }
-
     #[test]
     fn test_match_data() {
         let storage = Storage::new();

From 4f0a919da57b8914fa06ddbc52d29c343fafdad7 Mon Sep 17 00:00:00 2001
From: Aron Zwaan <aronzwaan@gmail.com>
Date: Mon, 28 Oct 2024 15:29:09 +0100
Subject: [PATCH 3/5] Missing docs

---
 scopegraphs/src/containers/path.rs  | 37 ++++++------
 scopegraphs/src/containers/scope.rs | 88 +++++++++++++++++------------
 scopegraphs/src/future_wrapper.rs   |  7 ++-
 scopegraphs/src/resolve/lookup.rs   | 65 +++++++++++----------
 4 files changed, 108 insertions(+), 89 deletions(-)

diff --git a/scopegraphs/src/containers/path.rs b/scopegraphs/src/containers/path.rs
index d52a418..e3e5c7e 100644
--- a/scopegraphs/src/containers/path.rs
+++ b/scopegraphs/src/containers/path.rs
@@ -1,14 +1,13 @@
 use crate::future_wrapper::FutureWrapper;
-use crate::resolve::{DataEquivalence, Env, Path, ResolvedPath};
+use crate::resolve::{Env, Path, ResolvedPath};
 use futures::future::join_all;
-use std::hash::Hash;
 use std::fmt::Debug;
+use std::hash::Hash;
 
 use super::EnvContainer;
 
 /// Interface for path containers that support the operations required for query resolution.
-pub trait PathContainer<'sg, 'rslv, LABEL: 'sg, DATA: 'sg>: Debug + 'rslv 
-{
+pub trait PathContainer<'sg, 'rslv, LABEL: 'sg, DATA: 'sg>: Debug + 'rslv {
     /// Type returned by resolving a path to its sub-environment.
     type EnvContainer;
 
@@ -19,26 +18,26 @@ pub trait PathContainer<'sg, 'rslv, LABEL: 'sg, DATA: 'sg>: Debug + 'rslv
     ) -> Self::EnvContainer;
 }
 
-pub trait PathContainerWf<'sg, 'rslv, LABEL: 'sg, DATA: 'sg, DWFO>: PathContainer<'sg, 'rslv, LABEL, DATA, EnvContainer = Self::EnvContainerWf> {
-    
+/// Trait that is auto-implemented for any [PathContainer] implementation that yields a valid [EnvContainer].
+pub trait PathContainerWf<'sg, 'rslv, LABEL: 'sg, DATA: 'sg, DWFO>:
+    PathContainer<'sg, 'rslv, LABEL, DATA, EnvContainer = Self::EnvContainerWf>
+{
+    /// Witness that ```Self::EnvContainer``` is a valid environment container.
     type EnvContainerWf: EnvContainer<'sg, 'rslv, LABEL, DATA, DWFO>;
-
 }
 
-
-impl<'sg, 'rslv, LABEL, DATA, DWFO, T> PathContainerWf<'sg, 'rslv, LABEL, DATA, DWFO> for T 
-    where
-        LABEL: Debug + 'sg,
-        DATA: 'sg,
-        T: PathContainer<'sg, 'rslv, LABEL, DATA>,
-        Self::EnvContainer: EnvContainer<'sg, 'rslv, LABEL, DATA, DWFO>
+impl<'sg, 'rslv, LABEL, DATA, DWFO, T> PathContainerWf<'sg, 'rslv, LABEL, DATA, DWFO> for T
+where
+    LABEL: Debug + 'sg,
+    DATA: 'sg,
+    T: PathContainer<'sg, 'rslv, LABEL, DATA>,
+    Self::EnvContainer: EnvContainer<'sg, 'rslv, LABEL, DATA, DWFO>,
 {
     type EnvContainerWf = Self::EnvContainer;
 }
 
-
-
-impl<'rslv, 'sg, LABEL: Debug + 'sg, DATA: 'sg> PathContainer<'sg, 'rslv, LABEL, DATA> for Vec<Path<LABEL>>
+impl<'rslv, 'sg, LABEL: Debug + 'sg, DATA: 'sg> PathContainer<'sg, 'rslv, LABEL, DATA>
+    for Vec<Path<LABEL>>
 where
     Self: 'rslv,
     LABEL: Clone + Hash + Eq,
@@ -53,8 +52,8 @@ where
 
 // TODO: can this be generalized to arbitrary results of PathContainers?
 // (challenge is converting between the different `::EnvContainer`s.)
-impl<'rslv, 'sg, LABEL: Debug + 'sg, DATA: 'sg, E: Debug + 'rslv> PathContainer<'sg, 'rslv, LABEL, DATA>
-    for Result<Vec<Path<LABEL>>, E>
+impl<'rslv, 'sg, LABEL: Debug + 'sg, DATA: 'sg, E: Debug + 'rslv>
+    PathContainer<'sg, 'rslv, LABEL, DATA> for Result<Vec<Path<LABEL>>, E>
 where
     Self: 'rslv,
     LABEL: Clone + Hash,
diff --git a/scopegraphs/src/containers/scope.rs b/scopegraphs/src/containers/scope.rs
index 4a0382a..3edca07 100644
--- a/scopegraphs/src/containers/scope.rs
+++ b/scopegraphs/src/containers/scope.rs
@@ -1,5 +1,5 @@
-use std::hash::Hash;
 use std::fmt::Debug;
+use std::hash::Hash;
 
 use crate::future_wrapper::FutureWrapper;
 use crate::resolve::Path;
@@ -20,7 +20,7 @@ pub trait ScopeContainer<'sg, 'rslv, LABEL: Debug + 'sg, DATA: 'sg>: Debug {
 }
 
 /// Trait that is auto-implemented for any [ScopeContainer] implementation that yields a valid [PathContainer].
-/// 
+///
 /// This trait is implemented for:
 /// - `Vec<Scope>`,
 /// - [Result] of scope containers, and
@@ -31,80 +31,82 @@ pub trait ScopeContainer<'sg, 'rslv, LABEL: Debug + 'sg, DATA: 'sg>: Debug {
 /// # use scopegraphs::Scope;
 /// # use std::fmt::Debug;
 /// # use std::hash::Hash;
-/// 
+///
 /// # trait LBound<'sg>: Copy + Hash + Eq + Debug + 'sg {}
 /// # trait DBound<'sg>: Hash + Eq + 'sg {}
-/// 
+///
 /// fn test<'sg, 'rslv, LABEL: LBound<'sg>, DATA: DBound<'sg>, DWFO>(
 ///     cont: impl ScopeContainerWf<'sg, 'rslv, LABEL, DATA, DWFO>
 /// ) { }
-/// 
+///
 /// # fn scope_vec<'sg, 'rslv, LABEL: LBound<'sg>, DATA: DBound<'sg>>() {
 ///     let vec: Vec<Scope> = todo!();
 ///     test::<'_, '_, LABEL, DATA, bool>(vec);
 /// # }
-/// 
+///
 /// # fn result<'sg, 'rslv, LABEL: LBound<'sg>, DATA: DBound<'sg>, E: Debug + Clone>() {
 ///     let result: Result<Vec<Scope>, E> = todo!();
 ///     test::<'_, '_, LABEL, DATA, bool>(result);
 ///     test::<'_, '_, LABEL, DATA, Result<bool, E>>(result);
 /// # }
-/// 
+///
 /// # fn future<'sg, 'rslv, LABEL: LBound<'sg>, DATA: DBound<'sg>>() {
 ///     let future: FutureWrapper<Vec<Scope>> = todo!();
 ///     test::<'_, '_, LABEL, DATA, bool>(future);
-///     test::<'_, '_, LABEL, DATA, FutureWrapper<'_, bool>>(result);
+///     test::<'_, '_, LABEL, DATA, FutureWrapper<'_, bool>>(future);
 /// # }
 /// ```
-/// 
+///
 /// ```no_run
 /// # use scopegraphs::containers::ScopeContainerWf;
 /// # use scopegraphs::Scope;
 /// # use std::fmt::Debug;
 /// # use std::hash::Hash;
-/// 
-/// 
+///
+///
 /// fn test<'sg, 'rslv, LABEL: Hash + Eq + Debug + 'sg, DATA: Hash + Eq + 'sg, DWFO>(cont: impl ScopeContainerWf<'sg, 'rslv, LABEL, DATA, DWFO>) {
-/// 
+///
 /// }
 /// ```
-/// 
+///
 /// ```no_run
 /// # use scopegraphs::containers::ScopeContainerWf;
 /// # use scopegraphs::Scope;
 /// # use std::fmt::Debug;
 /// # use std::hash::Hash;
-/// 
+///
 /// test::<'_, '_, (), (), bool>(Result::<_, ()>::Ok(Vec::<Scope>::new()));
 /// test::<'_, '_, (), (), Result<bool, ()>>(Result::<_, ()>::Ok(Vec::<Scope>::new()));
-/// 
+///
 /// fn test<'sg, 'rslv, LABEL: Hash + Eq + Debug + 'sg, DATA: Hash + Eq + 'sg, DWFO>(cont: impl ScopeContainerWf<'sg, 'rslv, LABEL, DATA, DWFO>) {
-/// 
+///
 /// }
 /// ```
-/// 
-pub trait ScopeContainerWf<'sg, 'rslv, LABEL, DATA, DWFO>: ScopeContainer<'sg, 'rslv, LABEL, DATA, PathContainer = Self::PathContainerWf> 
-    where
-        LABEL: Debug + 'sg,
-        DATA: 'sg
+///
+pub trait ScopeContainerWf<'sg, 'rslv, LABEL, DATA, DWFO>:
+    ScopeContainer<'sg, 'rslv, LABEL, DATA, PathContainer = Self::PathContainerWf>
+where
+    LABEL: Debug + 'sg,
+    DATA: 'sg,
 {
+    /// Refinement of `Self::PathContainer`, carrying proof that this scope container resolves to valid path containers.
     type PathContainerWf: PathContainerWf<'sg, 'rslv, LABEL, DATA, DWFO>;
 }
 
-impl<'sg, 'rslv, LABEL, DATA, DWFO, T> ScopeContainerWf<'sg, 'rslv, LABEL, DATA, DWFO> for T 
-    where
-        LABEL: Debug + 'sg,
-        DATA: 'sg,
-        T: ScopeContainer<'sg, 'rslv, LABEL, DATA>,
-        Self::PathContainer: PathContainerWf<'sg, 'rslv, LABEL, DATA, DWFO>
+impl<'sg, 'rslv, LABEL, DATA, DWFO, T> ScopeContainerWf<'sg, 'rslv, LABEL, DATA, DWFO> for T
+where
+    LABEL: Debug + 'sg,
+    DATA: 'sg,
+    T: ScopeContainer<'sg, 'rslv, LABEL, DATA>,
+    Self::PathContainer: PathContainerWf<'sg, 'rslv, LABEL, DATA, DWFO>,
 {
     type PathContainerWf = Self::PathContainer;
 }
 
-
-impl<'sg: 'rslv, 'rslv, LABEL: Debug + Copy + Eq + Hash + 'sg, DATA: Eq + Hash + 'sg> ScopeContainer<'sg, 'rslv, LABEL, DATA> for Vec<Scope> 
-    where
-        Vec<Path<LABEL>>: PathContainer<'sg, 'rslv, LABEL, DATA>
+impl<'sg: 'rslv, 'rslv, LABEL: Debug + Copy + Eq + Hash + 'sg, DATA: Eq + Hash + 'sg>
+    ScopeContainer<'sg, 'rslv, LABEL, DATA> for Vec<Scope>
+where
+    Vec<Path<LABEL>>: PathContainer<'sg, 'rslv, LABEL, DATA>,
 {
     type PathContainer = Vec<Path<LABEL>>;
 
@@ -115,9 +117,16 @@ impl<'sg: 'rslv, 'rslv, LABEL: Debug + Copy + Eq + Hash + 'sg, DATA: Eq + Hash +
     }
 }
 
-impl<'sg: 'rslv, 'rslv, LABEL: Debug + Copy + Eq + Hash + 'sg, DATA: Eq + Hash + 'sg, SC: ScopeContainer<'sg, 'rslv, LABEL, DATA>, E: Debug> ScopeContainer<'sg, 'rslv, LABEL, DATA> for Result<SC, E>
-    where
-        Result<SC::PathContainer, E>: PathContainer<'sg, 'rslv, LABEL, DATA>
+impl<
+        'sg: 'rslv,
+        'rslv,
+        LABEL: Debug + Copy + Eq + Hash + 'sg,
+        DATA: Eq + Hash + 'sg,
+        SC: ScopeContainer<'sg, 'rslv, LABEL, DATA>,
+        E: Debug,
+    > ScopeContainer<'sg, 'rslv, LABEL, DATA> for Result<SC, E>
+where
+    Result<SC::PathContainer, E>: PathContainer<'sg, 'rslv, LABEL, DATA>,
 {
     type PathContainer = Result<SC::PathContainer, E>;
 
@@ -126,13 +135,18 @@ impl<'sg: 'rslv, 'rslv, LABEL: Debug + Copy + Eq + Hash + 'sg, DATA: Eq + Hash +
     }
 }
 
-impl<'sg: 'rslv, 'rslv, LABEL: Debug + Copy + Eq + Hash + 'sg, DATA: Eq + Hash + 'sg, SC: ScopeContainer<'sg, 'rslv, LABEL, DATA> + Clone> ScopeContainer<'sg, 'rslv, LABEL, DATA>
-    for FutureWrapper<'rslv, SC>
+impl<
+        'sg: 'rslv,
+        'rslv,
+        LABEL: Debug + Copy + Eq + Hash + 'sg,
+        DATA: Eq + Hash + 'sg,
+        SC: ScopeContainer<'sg, 'rslv, LABEL, DATA> + Clone,
+    > ScopeContainer<'sg, 'rslv, LABEL, DATA> for FutureWrapper<'rslv, SC>
 where
     LABEL: Copy,
     Self: 'rslv,
     LABEL: 'rslv,
-    SC::PathContainer: Clone
+    SC::PathContainer: Clone,
 {
     type PathContainer = FutureWrapper<'rslv, SC::PathContainer>;
 
diff --git a/scopegraphs/src/future_wrapper.rs b/scopegraphs/src/future_wrapper.rs
index ae0bc49..56ee8a9 100644
--- a/scopegraphs/src/future_wrapper.rs
+++ b/scopegraphs/src/future_wrapper.rs
@@ -1,3 +1,5 @@
+//! Defines a cloneable pointer to a future.
+
 use futures::future::Shared;
 use futures::FutureExt;
 use std::fmt::{Debug, Formatter};
@@ -7,8 +9,8 @@ use std::{
     task::{Context, Poll},
 };
 
-// TODO: fork futures and create our own shared future that can have a
-//       ?Sized inner type (this should be possible)
+// FIXME: only expose futures on tests
+/// Shared pointer to a future, useful to make functions parametric over the type of future they are invoked with.
 pub struct FutureWrapper<'fut, T>(pub Shared<Pin<Box<dyn Future<Output = T> + 'fut>>>);
 
 impl<T> Clone for FutureWrapper<'_, T> {
@@ -18,6 +20,7 @@ impl<T> Clone for FutureWrapper<'_, T> {
 }
 
 impl<'fut, T: Clone> FutureWrapper<'fut, T> {
+    /// Creates shared pointer to `f`.
     pub fn new(f: impl Future<Output = T> + 'fut) -> Self {
         let f: Pin<Box<dyn Future<Output = T> + 'fut>> = Box::pin(f);
         Self(f.shared())
diff --git a/scopegraphs/src/resolve/lookup.rs b/scopegraphs/src/resolve/lookup.rs
index 2b7aea0..9bb5d35 100644
--- a/scopegraphs/src/resolve/lookup.rs
+++ b/scopegraphs/src/resolve/lookup.rs
@@ -13,7 +13,9 @@ use std::rc::Rc;
 use std::sync::Arc;
 
 use crate::completeness::Completeness;
-use crate::containers::{EnvContainer, PathContainer, PathContainerWf, ScopeContainer, ScopeContainerWf};
+use crate::containers::{
+    EnvContainer, PathContainer, PathContainerWf, ScopeContainer, ScopeContainerWf,
+};
 use crate::resolve::{
     DataEquivalence, DataWellformedness, EdgeOrData, Env, LabelOrder, Path, Query, Resolve,
     ResolvedPath,
@@ -28,7 +30,7 @@ where
     LABEL: Label + Copy + Debug + Hash,
     DATA: Debug,
     CMPL: Completeness<LABEL, DATA>,
-    CMPL::GetEdgesResult<'rslv> : ScopeContainerWf<'sg, 'rslv, LABEL, DATA, DWF::Output>,
+    CMPL::GetEdgesResult<'rslv>: ScopeContainerWf<'sg, 'rslv, LABEL, DATA, DWF::Output>,
     PWF: for<'a> RegexMatcher<&'a LABEL> + 'rslv,
     DWF: DataWellformedness<'sg, DATA> + 'rslv,
 
@@ -95,9 +97,14 @@ struct ResolutionContext<'storage, 'sg: 'rslv, 'rslv, LABEL: Label, DATA, CMPL,
     data_equiv: &'rslv DEq,
 }
 
-type EnvC<'sg, 'rslv, CMPL, LABEL, DATA, DWFO> = <<<CMPL as Completeness<LABEL, DATA>>::GetEdgesResult<
-    'rslv,
-> as ScopeContainerWf<'sg, 'rslv, LABEL, DATA, DWFO>>::PathContainerWf as PathContainerWf<'sg, 'rslv, LABEL, DATA, DWFO>>::EnvContainerWf;
+type EnvC<'sg, 'rslv, CMPL, LABEL, DATA, DWFO> =
+    <<<CMPL as Completeness<LABEL, DATA>>::GetEdgesResult<'rslv> as ScopeContainerWf<
+        'sg,
+        'rslv,
+        LABEL,
+        DATA,
+        DWFO,
+    >>::PathContainerWf as PathContainerWf<'sg, 'rslv, LABEL, DATA, DWFO>>::EnvContainerWf;
 
 type EnvCache<LABEL, ENVC> = RefCell<HashMap<EdgeOrData<LABEL>, Rc<ENVC>>>;
 
@@ -108,7 +115,7 @@ where
     DATA: Debug,
     ResolvedPath<'sg, LABEL, DATA>: Hash + Eq,
     CMPL: Completeness<LABEL, DATA>,
-    CMPL::GetEdgesResult<'rslv> : ScopeContainerWf<'sg, 'rslv, LABEL, DATA, DWF::Output>,
+    CMPL::GetEdgesResult<'rslv>: ScopeContainerWf<'sg, 'rslv, LABEL, DATA, DWF::Output>,
     DEq: DataEquivalence<DATA>,
     DWF: DataWellformedness<'sg, DATA>,
     LO: LabelOrder<LABEL>,
@@ -183,9 +190,9 @@ where
                     let mut merged_env = agg_env.clone();
                     env2.flat_map(move |new_env| {
                         merged_env.merge(new_env);
-                        <EnvC<'sg, 'rslv, CMPL, LABEL, DATA, DWF::Output> as From<Env<'sg, LABEL, DATA>>>::from(
-                            merged_env,
-                        )
+                        <EnvC<'sg, 'rslv, CMPL, LABEL, DATA, DWF::Output> as From<
+                            Env<'sg, LABEL, DATA>,
+                        >>::from(merged_env)
                     })
                 })
             })
@@ -211,9 +218,9 @@ where
         // environment of current (max) label, which might be shadowed by the base environment
         Rc::new(base_env.flat_map(move |base_env| {
             if !base_env.is_empty() && local_self.data_equiv.always_equivalent() {
-                <EnvC<'sg, 'rslv, CMPL, LABEL, DATA, DWF::Output> as From<Env<'sg, LABEL, DATA>>>::from(
-                    base_env.clone(),
-                )
+                <EnvC<'sg, 'rslv, CMPL, LABEL, DATA, DWF::Output> as From<
+                        Env<'sg, LABEL, DATA>,
+                    >>::from(base_env.clone())
             } else {
                 let sub_env = local_self.resolve_edge(path_wellformedness.clone(), edge, path);
                 let local_self = Arc::clone(&local_self);
@@ -245,9 +252,9 @@ where
                     for path in filtered_env {
                         new_env.insert(path.clone())
                     }
-                    <EnvC<'sg, 'rslv, CMPL, LABEL, DATA, DWF::Output> as From<Env<'sg, LABEL, DATA>>>::from(
-                        new_env,
-                    )
+                    <EnvC<'sg, 'rslv, CMPL, LABEL, DATA, DWF::Output> as From<
+                        Env<'sg, LABEL, DATA>,
+                    >>::from(new_env)
                 })
             }
         }))
@@ -284,9 +291,10 @@ where
         let targets = self.sg.get_edges(source, label);
         let path_set = targets.lift_step(label, path.clone());
         let local_ctx = Arc::clone(self);
-        let env: EnvC<'sg, 'rslv, CMPL, LABEL, DATA, DWF::Output> = path_set.map_into_env::<_>(move |p| {
-            local_ctx.resolve_all(path_wellformedness.clone(), p.clone())
-        });
+        let env: EnvC<'sg, 'rslv, CMPL, LABEL, DATA, DWF::Output> =
+            path_set.map_into_env::<_>(move |p| {
+                local_ctx.resolve_all(path_wellformedness.clone(), p.clone())
+            });
         env
     }
 
@@ -460,19 +468,14 @@ mod tests {
                 .with_path_wellformedness(query_regex!(Lbl: Lex* Imp? Def))
                 .with_data_wellformedness(TData::matcher_fut("x"))
                 .with_label_order(label_order!(Lbl: Def < Imp < Lex));
-            type DWF = impl for<'sg> DataWellformedness<'sg, TData<'sg>, Output = FutureWrapper<'sg, bool>>;
-            let env = crate::resolve::Query::<
-                '_,
-                '_,
-                '_,
-                _,
-                _,
-                _,
-                _,
-                DWF,
-                _,
-                _
-            >::resolve(&query, s_let).await;
+            type DWF = impl for<'sg> DataWellformedness<
+                'sg,
+                TData<'sg>,
+                Output = FutureWrapper<'sg, bool>,
+            >;
+            let env =
+                crate::resolve::Query::<'_, '_, '_, _, _, _, _, DWF, _, _>::resolve(&query, s_let)
+                    .await;
 
             let env_vec = env.into_iter().collect::<Vec<_>>();
             assert_eq!(1, env_vec.len());

From bfa1df326ef407f0da18657da30253a7bd93ba0e Mon Sep 17 00:00:00 2001
From: Aron Zwaan <aronzwaan@gmail.com>
Date: Mon, 28 Oct 2024 15:37:24 +0100
Subject: [PATCH 4/5] Remove incorrect type argument

---
 scopegraphs/src/completeness/implicit.rs |  2 +-
 scopegraphs/src/resolve/lookup.rs        | 11 ++---------
 2 files changed, 3 insertions(+), 10 deletions(-)

diff --git a/scopegraphs/src/completeness/implicit.rs b/scopegraphs/src/completeness/implicit.rs
index c6c62c8..2b8b8f3 100644
--- a/scopegraphs/src/completeness/implicit.rs
+++ b/scopegraphs/src/completeness/implicit.rs
@@ -14,7 +14,7 @@ use super::Implicit;
 /// Unlike [`ExplicitClose`](crate::completeness::ExplicitClose), this implementation will implicitly close edges once traversed.
 /// This does not require special attention from the type checker writer.
 ///
-/// Returns [`EdgeClosedError`](EdgeClosedError) when an edge is added to a scope in which the label is already
+/// Returns [EdgeClosedError] when an edge is added to a scope in which the label is already
 /// closed (because `get_edges(s, l, ...)` was called earlier.
 ///
 /// When edges are retrieved (e.g. during query resolution) the `(src, label)` edge is closed.
diff --git a/scopegraphs/src/resolve/lookup.rs b/scopegraphs/src/resolve/lookup.rs
index 9bb5d35..ee3a3f4 100644
--- a/scopegraphs/src/resolve/lookup.rs
+++ b/scopegraphs/src/resolve/lookup.rs
@@ -364,7 +364,7 @@ mod tests {
         },
         future_wrapper::FutureWrapper,
         query_regex,
-        resolve::{DataWellformedness, Resolve, ResolvedPath},
+        resolve::{Resolve, ResolvedPath},
         storage::Storage,
         Label, ScopeGraph,
     };
@@ -468,14 +468,7 @@ mod tests {
                 .with_path_wellformedness(query_regex!(Lbl: Lex* Imp? Def))
                 .with_data_wellformedness(TData::matcher_fut("x"))
                 .with_label_order(label_order!(Lbl: Def < Imp < Lex));
-            type DWF = impl for<'sg> DataWellformedness<
-                'sg,
-                TData<'sg>,
-                Output = FutureWrapper<'sg, bool>,
-            >;
-            let env =
-                crate::resolve::Query::<'_, '_, '_, _, _, _, _, DWF, _, _>::resolve(&query, s_let)
-                    .await;
+            let env = query.resolve(s_let).await;
 
             let env_vec = env.into_iter().collect::<Vec<_>>();
             assert_eq!(1, env_vec.len());

From 65f2689485143b7b20170225a3e9b1422e745a55 Mon Sep 17 00:00:00 2001
From: Aron Zwaan <aronzwaan@gmail.com>
Date: Mon, 28 Oct 2024 15:43:03 +0100
Subject: [PATCH 5/5] Remove unstable feature

---
 scopegraphs/src/lib.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/scopegraphs/src/lib.rs b/scopegraphs/src/lib.rs
index 63dd120..2d8b87e 100644
--- a/scopegraphs/src/lib.rs
+++ b/scopegraphs/src/lib.rs
@@ -11,7 +11,6 @@
 #![allow(unknown_lints)]
 #![allow(unexpected_cfgs)]
 #![allow(clippy::empty_docs)]
-#![feature(type_alias_impl_trait)]
 
 #[cfg(feature = "documentation")]
 pub mod concepts;