From 98801455e4dc1f873b77fa0ddac6d26000ce6434 Mon Sep 17 00:00:00 2001
From: Aron Zwaan <aronzwaan@gmail.com>
Date: Tue, 29 Oct 2024 10:25:50 +0100
Subject: [PATCH 1/8] Introduce trait for shadowing environment containers

---
 scopegraphs/src/containers/env.rs   | 206 +++++++++++++++-------------
 scopegraphs/src/containers/path.rs  |  11 +-
 scopegraphs/src/containers/scope.rs |   8 +-
 scopegraphs/src/resolve/lookup.rs   |  57 ++------
 scopegraphs/src/resolve/mod.rs      |   4 +-
 scopegraphs/src/resolve/params.rs   |  21 ++-
 6 files changed, 149 insertions(+), 158 deletions(-)

diff --git a/scopegraphs/src/containers/env.rs b/scopegraphs/src/containers/env.rs
index 104c203..66b2ea6 100644
--- a/scopegraphs/src/containers/env.rs
+++ b/scopegraphs/src/containers/env.rs
@@ -1,18 +1,24 @@
 use crate::future_wrapper::FutureWrapper;
-use crate::resolve::{Env, ResolvedPath};
+use crate::resolve::{DataEquivalence, Env, ResolvedPath};
 use futures::future::Shared;
 use std::hash::Hash;
 use std::rc::Rc;
 
 /// Interface for environment containers that support the operations required for query resolution.
-pub trait EnvContainer<'sg, 'rslv, LABEL: 'sg, DATA: 'sg, DWFO>:
+pub trait EnvContainer<'sg, 'rslv, LABEL: 'sg, DATA: 'sg>:
     From<Env<'sg, LABEL, DATA>> + 'rslv
+where
+    ResolvedPath<'sg, LABEL, DATA>: Eq + Hash + Clone,
 {
-    /// Creates a new, container with an empty environment.
-    fn empty() -> Self;
+    /// Creates a new container with an empty environment.
+    fn empty() -> Self {
+        Self::from(Env::new())
+    }
 
-    /// Creates a new environment that contains path when `data_ok` is `true`, and is empty otherwise.
-    fn inject_if(data_ok: DWFO, path: ResolvedPath<'sg, LABEL, DATA>) -> Self;
+    /// Creates a new container with a single path.
+    fn single(path: ResolvedPath<'sg, LABEL, DATA>) -> Self {
+        Self::from(Env::single(path))
+    }
 
     /// Maps the current container to a new one, based a provided mapping of the underlying environment.
     fn flat_map(
@@ -21,23 +27,11 @@ pub trait EnvContainer<'sg, 'rslv, LABEL: 'sg, DATA: 'sg, DWFO>:
     ) -> Self;
 }
 
-impl<'sg: 'rslv, 'rslv, LABEL: Eq, DATA: Eq> EnvContainer<'sg, 'rslv, LABEL, DATA, bool>
+impl<'sg: 'rslv, 'rslv, LABEL: Eq, DATA: Eq> EnvContainer<'sg, 'rslv, LABEL, DATA>
     for Env<'sg, LABEL, DATA>
 where
     ResolvedPath<'sg, LABEL, DATA>: Hash + Clone,
 {
-    fn empty() -> Self {
-        Self::new()
-    }
-
-    fn inject_if(data_ok: bool, path: ResolvedPath<'sg, LABEL, DATA>) -> Self {
-        if data_ok {
-            Self::single(path)
-        } else {
-            Self::empty()
-        }
-    }
-
     fn flat_map(
         &self,
         map: impl 'rslv + for<'short> FnOnce(&'short Env<'sg, LABEL, DATA>) -> Self,
@@ -46,25 +40,13 @@ where
     }
 }
 
-impl<'sg: 'rslv, 'rslv, LABEL, DATA> EnvContainer<'sg, 'rslv, LABEL, DATA, bool>
+impl<'sg: 'rslv, 'rslv, LABEL, DATA> EnvContainer<'sg, 'rslv, LABEL, DATA>
     for Rc<Env<'sg, LABEL, DATA>>
 where
     ResolvedPath<'sg, LABEL, DATA>: Hash,
     LABEL: 'sg + Eq + Clone,
     DATA: 'sg + Eq,
 {
-    fn empty() -> Self {
-        Self::new(Env::empty())
-    }
-
-    fn inject_if(data_ok: bool, path: ResolvedPath<'sg, LABEL, DATA>) -> Self {
-        if data_ok {
-            Env::single(path).into()
-        } else {
-            Self::empty()
-        }
-    }
-
     fn flat_map(
         &self,
         map: impl for<'short> FnOnce(&'short Env<'sg, LABEL, DATA>) -> Self,
@@ -73,7 +55,6 @@ where
     }
 }
 
-// Implementations for Results
 impl<'sg, LABEL: 'sg, DATA: 'sg, E> From<Env<'sg, LABEL, DATA>>
     for Result<Env<'sg, LABEL, DATA>, E>
 {
@@ -83,23 +64,11 @@ impl<'sg, LABEL: 'sg, DATA: 'sg, E> From<Env<'sg, LABEL, DATA>>
 }
 
 impl<'sg: 'rslv, 'rslv, LABEL: 'sg + Eq, DATA: 'sg + Eq, E: 'rslv>
-    EnvContainer<'sg, 'rslv, LABEL, DATA, bool> for Result<Env<'sg, LABEL, DATA>, E>
+    EnvContainer<'sg, 'rslv, LABEL, DATA> for Result<Env<'sg, LABEL, DATA>, E>
 where
     ResolvedPath<'sg, LABEL, DATA>: Hash + Clone,
     E: Clone,
 {
-    fn empty() -> Self {
-        Ok(Env::empty())
-    }
-
-    fn inject_if(data_ok: bool, path: ResolvedPath<'sg, LABEL, DATA>) -> Self {
-        if data_ok {
-            Env::single(path).into()
-        } else {
-            Env::empty().into()
-        }
-    }
-
     fn flat_map(&self, map: impl for<'short> FnOnce(&Env<'sg, LABEL, DATA>) -> Self) -> Self {
         match self {
             Ok(env) => map(env),
@@ -108,45 +77,22 @@ where
     }
 }
 
-impl<'sg: 'rslv, 'rslv, LABEL: 'sg + Eq, DATA: 'sg + Eq, E: 'rslv>
-    EnvContainer<'sg, 'rslv, LABEL, DATA, Result<bool, E>> for Result<Env<'sg, LABEL, DATA>, E>
+impl<'sg: 'rslv, 'rslv, LABEL, DATA> From<Env<'sg, LABEL, DATA>>
+    for FutureWrapper<'rslv, Env<'sg, LABEL, DATA>>
 where
-    ResolvedPath<'sg, LABEL, DATA>: Hash + Clone,
-    E: Clone,
+    LABEL: Clone,
 {
-    fn empty() -> Self {
-        Ok(Env::empty())
-    }
-
-    fn inject_if(data_ok: Result<bool, E>, path: ResolvedPath<'sg, LABEL, DATA>) -> Self {
-        data_ok.map(|ok| if ok { Env::single(path) } else { Env::empty() })
-    }
-
-    fn flat_map(&self, map: impl for<'short> FnOnce(&Env<'sg, LABEL, DATA>) -> Self) -> Self {
-        match self {
-            Ok(env) => map(env),
-            Err(err) => Err(err.clone()),
-        }
+    fn from(value: Env<'sg, LABEL, DATA>) -> Self {
+        FutureWrapper::new(std::future::ready(value))
     }
 }
-impl<'sg: 'rslv, 'rslv, LABEL: 'sg + Eq, DATA: 'sg + Eq> EnvContainer<'sg, 'rslv, LABEL, DATA, bool>
+
+impl<'sg: 'rslv, 'rslv, LABEL: 'sg + Eq, DATA: 'sg + Eq> EnvContainer<'sg, 'rslv, LABEL, DATA>
     for FutureWrapper<'rslv, Env<'sg, LABEL, DATA>>
 where
     ResolvedPath<'sg, LABEL, DATA>: Hash + Clone,
     LABEL: Clone,
 {
-    fn empty() -> Self {
-        FutureWrapper::new(std::future::ready(Env::empty()))
-    }
-
-    fn inject_if(data_ok: bool, path: ResolvedPath<'sg, LABEL, DATA>) -> Self {
-        if data_ok {
-            Env::single(path).into()
-        } else {
-            Env::empty().into()
-        }
-    }
-
     fn flat_map(
         &self,
         map: impl 'rslv + for<'short> FnOnce(&'short Env<'sg, LABEL, DATA>) -> Self,
@@ -159,17 +105,51 @@ where
     }
 }
 
+// Injectable
+
+/// Environment Container in which a path can be injected based on a condition.
+pub trait Injectable<'sg, 'rslv, LABEL: 'sg, DATA: 'sg, DWFO>:
+    EnvContainer<'sg, 'rslv, LABEL, DATA>
+where
+    ResolvedPath<'sg, LABEL, DATA>: Eq + Hash + Clone,
+{
+    /// Creates a new environment that contains path when `data_ok` is `true`, and is empty otherwise.
+    fn inject_if(data_ok: DWFO, path: ResolvedPath<'sg, LABEL, DATA>) -> Self;
+}
+
+impl<'sg: 'rslv, 'rslv, LABEL: Eq + 'sg, DATA: Eq + 'sg, ENVC>
+    Injectable<'sg, 'rslv, LABEL, DATA, bool> for ENVC
+where
+    ENVC: EnvContainer<'sg, 'rslv, LABEL, DATA>,
+    ResolvedPath<'sg, LABEL, DATA>: Eq + Hash + Clone,
+{
+    fn inject_if(data_ok: bool, path: ResolvedPath<'sg, LABEL, DATA>) -> Self {
+        if data_ok {
+            Self::single(path)
+        } else {
+            Self::empty()
+        }
+    }
+}
+
+impl<'sg: 'rslv, 'rslv, LABEL: 'sg + Eq, DATA: 'sg + Eq, E: 'rslv>
+    Injectable<'sg, 'rslv, LABEL, DATA, Result<bool, E>> for Result<Env<'sg, LABEL, DATA>, E>
+where
+    ResolvedPath<'sg, LABEL, DATA>: Hash + Clone,
+    E: Clone,
+{
+    fn inject_if(data_ok: Result<bool, E>, path: ResolvedPath<'sg, LABEL, DATA>) -> Self {
+        data_ok.map(|ok| if ok { Env::single(path) } else { Env::empty() })
+    }
+}
+
 impl<'sg: 'rslv, 'rslv, LABEL: 'sg + Eq, DATA: 'sg + Eq>
-    EnvContainer<'sg, 'rslv, LABEL, DATA, FutureWrapper<'rslv, bool>>
+    Injectable<'sg, 'rslv, LABEL, DATA, FutureWrapper<'rslv, bool>>
     for FutureWrapper<'rslv, Env<'sg, LABEL, DATA>>
 where
     ResolvedPath<'sg, LABEL, DATA>: Hash + Clone,
     LABEL: Clone,
 {
-    fn empty() -> Self {
-        FutureWrapper::new(std::future::ready(Env::empty()))
-    }
-
     fn inject_if(
         data_ok: FutureWrapper<'rslv, bool>,
         path: ResolvedPath<'sg, LABEL, DATA>,
@@ -183,25 +163,61 @@ where
             }
         })
     }
+}
 
-    fn flat_map(
+// Mergeable
+
+/// Environment Container in which a path can be injected based on a condition.
+pub trait Mergable<'sg, 'rslv, LABEL: 'sg, DATA: 'sg, DEQO>:
+    EnvContainer<'sg, 'rslv, LABEL, DATA>
+where
+    ResolvedPath<'sg, LABEL, DATA>: Eq + Hash + Clone,
+{
+    /// Creates a new environment that contains path when `data_ok` is `true`, and is empty otherwise.
+    fn merge_if(
         &self,
-        map: impl 'rslv + for<'short> FnOnce(&'short Env<'sg, LABEL, DATA>) -> Self,
-    ) -> Self {
-        let fut = Shared::clone(&self.0);
-        FutureWrapper::new(async move {
-            let env = fut.await;
-            map(&env).0.await
-        })
-    }
+        data_equiv: &'rslv impl DataEquivalence<'sg, DATA, Output = DEQO>,
+        sub_env: Self,
+    ) -> Self;
 }
 
-impl<'sg: 'rslv, 'rslv, LABEL, DATA> From<Env<'sg, LABEL, DATA>>
-    for FutureWrapper<'rslv, Env<'sg, LABEL, DATA>>
+impl<'sg: 'rslv, 'rslv, LABEL: Eq + 'sg, DATA: Eq + 'sg, ENVC>
+    Mergable<'sg, 'rslv, LABEL, DATA, bool> for ENVC
 where
-    LABEL: Clone,
+    ENVC: EnvContainer<'sg, 'rslv, LABEL, DATA>,
+    Env<'sg, LABEL, DATA>: Clone,
+    ResolvedPath<'sg, LABEL, DATA>: Eq + Hash + Clone,
 {
-    fn from(value: Env<'sg, LABEL, DATA>) -> Self {
-        FutureWrapper::new(std::future::ready(value))
+    fn merge_if(
+        &self,
+        data_equiv: &'rslv impl DataEquivalence<'sg, DATA, Output = bool>,
+        sub_env: Self,
+    ) -> Self {
+        let base_env = self;
+        base_env.flat_map(move |base_env| {
+            if !base_env.is_empty() && data_equiv.always_equivalent() {
+                <ENVC as From<Env<'sg, LABEL, DATA>>>::from(base_env.clone())
+            } else {
+                let base_env = base_env.clone();
+
+                sub_env.flat_map(move |sub_env| {
+                    let filtered_env = sub_env
+                        .iter()
+                        .filter(|p1| {
+                            base_env
+                                .iter()
+                                .find(|p2| data_equiv.data_equiv(p1.data, p2.data))
+                                .is_none()
+                        })
+                        .collect::<Vec<_>>();
+
+                    let mut new_env = base_env;
+                    for path in filtered_env {
+                        new_env.insert(path.clone())
+                    }
+                    new_env.into()
+                })
+            }
+        })
     }
 }
diff --git a/scopegraphs/src/containers/path.rs b/scopegraphs/src/containers/path.rs
index e3e5c7e..d92aab8 100644
--- a/scopegraphs/src/containers/path.rs
+++ b/scopegraphs/src/containers/path.rs
@@ -4,7 +4,7 @@ use futures::future::join_all;
 use std::fmt::Debug;
 use std::hash::Hash;
 
-use super::EnvContainer;
+use super::{Injectable, Mergable};
 
 /// Interface for path containers that support the operations required for query resolution.
 pub trait PathContainer<'sg, 'rslv, LABEL: 'sg, DATA: 'sg>: Debug + 'rslv {
@@ -21,9 +21,12 @@ pub trait PathContainer<'sg, 'rslv, LABEL: 'sg, DATA: 'sg>: Debug + 'rslv {
 /// 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>
+where
+    ResolvedPath<'sg, LABEL, DATA>: Eq + Hash + Clone,
 {
     /// Witness that ```Self::EnvContainer``` is a valid environment container.
-    type EnvContainerWf: EnvContainer<'sg, 'rslv, LABEL, DATA, DWFO>;
+    type EnvContainerWf: Injectable<'sg, 'rslv, LABEL, DATA, DWFO>
+        + Mergable<'sg, 'rslv, LABEL, DATA, bool>;
 }
 
 impl<'sg, 'rslv, LABEL, DATA, DWFO, T> PathContainerWf<'sg, 'rslv, LABEL, DATA, DWFO> for T
@@ -31,7 +34,9 @@ where
     LABEL: Debug + 'sg,
     DATA: 'sg,
     T: PathContainer<'sg, 'rslv, LABEL, DATA>,
-    Self::EnvContainer: EnvContainer<'sg, 'rslv, LABEL, DATA, DWFO>,
+    Self::EnvContainer:
+        Injectable<'sg, 'rslv, LABEL, DATA, DWFO> + Mergable<'sg, 'rslv, LABEL, DATA, bool>,
+    ResolvedPath<'sg, LABEL, DATA>: Eq + Hash + Clone,
 {
     type EnvContainerWf = Self::EnvContainer;
 }
diff --git a/scopegraphs/src/containers/scope.rs b/scopegraphs/src/containers/scope.rs
index 3edca07..76c0c0c 100644
--- a/scopegraphs/src/containers/scope.rs
+++ b/scopegraphs/src/containers/scope.rs
@@ -1,9 +1,9 @@
 use std::fmt::Debug;
 use std::hash::Hash;
 
-use crate::future_wrapper::FutureWrapper;
 use crate::resolve::Path;
 use crate::Scope;
+use crate::{future_wrapper::FutureWrapper, resolve::ResolvedPath};
 
 use super::{PathContainer, PathContainerWf};
 
@@ -64,7 +64,7 @@ pub trait ScopeContainer<'sg, 'rslv, LABEL: Debug + 'sg, DATA: 'sg>: 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>) {
+/// fn test<'sg, 'rslv, LABEL: Clone + Hash + Eq + Debug + 'sg, DATA: Hash + Eq + 'sg, DWFO>(cont: impl ScopeContainerWf<'sg, 'rslv, LABEL, DATA, DWFO>) {
 ///
 /// }
 /// ```
@@ -78,7 +78,7 @@ pub trait ScopeContainer<'sg, 'rslv, LABEL: Debug + 'sg, DATA: 'sg>: Debug {
 /// 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>) {
+/// fn test<'sg, 'rslv, LABEL: Clone + Hash + Eq + Debug + 'sg, DATA: Hash + Eq + 'sg, DWFO>(cont: impl ScopeContainerWf<'sg, 'rslv, LABEL, DATA, DWFO>) {
 ///
 /// }
 /// ```
@@ -88,6 +88,7 @@ pub trait ScopeContainerWf<'sg, 'rslv, LABEL, DATA, DWFO>:
 where
     LABEL: Debug + 'sg,
     DATA: 'sg,
+    ResolvedPath<'sg, LABEL, DATA>: Eq + Hash + Clone,
 {
     /// Refinement of `Self::PathContainer`, carrying proof that this scope container resolves to valid path containers.
     type PathContainerWf: PathContainerWf<'sg, 'rslv, LABEL, DATA, DWFO>;
@@ -99,6 +100,7 @@ where
     DATA: 'sg,
     T: ScopeContainer<'sg, 'rslv, LABEL, DATA>,
     Self::PathContainer: PathContainerWf<'sg, 'rslv, LABEL, DATA, DWFO>,
+    ResolvedPath<'sg, LABEL, DATA>: Eq + Hash + Clone,
 {
     type PathContainerWf = Self::PathContainer;
 }
diff --git a/scopegraphs/src/resolve/lookup.rs b/scopegraphs/src/resolve/lookup.rs
index ee3a3f4..b1abc64 100644
--- a/scopegraphs/src/resolve/lookup.rs
+++ b/scopegraphs/src/resolve/lookup.rs
@@ -14,7 +14,8 @@ use std::sync::Arc;
 
 use crate::completeness::Completeness;
 use crate::containers::{
-    EnvContainer, PathContainer, PathContainerWf, ScopeContainer, ScopeContainerWf,
+    EnvContainer, Injectable, Mergable, PathContainer, PathContainerWf, ScopeContainer,
+    ScopeContainerWf,
 };
 use crate::resolve::{
     DataEquivalence, DataWellformedness, EdgeOrData, Env, LabelOrder, Path, Query, Resolve,
@@ -36,7 +37,7 @@ where
 
     // DWF : DataWellFormedNess<DATA, Completeness::DWF>
     LO: LabelOrder<LABEL> + 'rslv,
-    DEq: DataEquivalence<DATA> + 'rslv,
+    DEq: DataEquivalence<'sg, DATA, /* tmp */ Output = bool> + 'rslv,
     ResolvedPath<'sg, LABEL, DATA>: Hash + Eq,
     Path<LABEL>: Clone,
 {
@@ -116,7 +117,7 @@ where
     ResolvedPath<'sg, LABEL, DATA>: Hash + Eq,
     CMPL: Completeness<LABEL, DATA>,
     CMPL::GetEdgesResult<'rslv>: ScopeContainerWf<'sg, 'rslv, LABEL, DATA, DWF::Output>,
-    DEq: DataEquivalence<DATA>,
+    DEq: DataEquivalence<'sg, DATA, /* tmp */ Output = bool>,
     DWF: DataWellformedness<'sg, DATA>,
     LO: LabelOrder<LABEL>,
     Path<LABEL>: Clone,
@@ -215,49 +216,10 @@ where
         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);
+        let sub_env = local_self.resolve_edge(path_wellformedness.clone(), edge, path);
+
         // 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())
-            } else {
-                let sub_env = local_self.resolve_edge(path_wellformedness.clone(), edge, path);
-                let local_self = Arc::clone(&local_self);
-                let base_env = base_env.clone();
-
-                sub_env.flat_map(move |sub_env| {
-                    let filtered_env = sub_env
-                        .iter()
-                        .filter(|p1| {
-                            if let Some(p2) = base_env
-                                .iter()
-                                .find(|p2| local_self.data_equiv.data_equiv(p1.data, p2.data))
-                            {
-                                log::info!(
-                                    "Discarding {:?} in {:?}; shadowed by {:?} in {:?}",
-                                    p1.data,
-                                    p1.path.target(),
-                                    p2.data,
-                                    p2.path.target()
-                                );
-                                false
-                            } else {
-                                true
-                            }
-                        })
-                        .collect::<Vec<_>>();
-
-                    let mut new_env = base_env;
-                    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)
-                })
-            }
-        }))
+        Rc::new(base_env.merge_if(local_self.data_equiv, sub_env))
     }
 
     /// Compute environment for single edge
@@ -304,12 +266,12 @@ where
         let path = path.clone().resolve(data);
         let data_ok = self.data_wellformedness.data_wf(data);
 
-        <EnvC<'sg, 'rslv, CMPL, LABEL, DATA, DWF::Output> as EnvContainer<
+        <EnvC<'sg, 'rslv, CMPL, LABEL, DATA, DWF::Output> as Injectable<
             'sg,
             'rslv,
             LABEL,
             DATA,
-            <DWF as DataWellformedness<DATA>>::Output,
+            DWF::Output,
         >>::inject_if(data_ok, path)
     }
 
@@ -347,7 +309,6 @@ where
             'rslv,
             LABEL,
             DATA,
-            <DWF as DataWellformedness<DATA>>::Output,
         >>::empty()
     }
 }
diff --git a/scopegraphs/src/resolve/mod.rs b/scopegraphs/src/resolve/mod.rs
index 5cd5129..ae5d5cb 100644
--- a/scopegraphs/src/resolve/mod.rs
+++ b/scopegraphs/src/resolve/mod.rs
@@ -119,7 +119,7 @@ where
 #[derive(Hash, PartialEq, Eq, Debug)]
 pub struct ResolvedPath<'sg, LABEL, DATA> {
     path: Path<LABEL>,
-    data: &'sg DATA,
+    pub(crate) data: &'sg DATA,
 }
 
 impl<LABEL: Clone, DATA> Clone for ResolvedPath<'_, LABEL, DATA> {
@@ -585,7 +585,7 @@ impl<'sg, 'storage, 'rslv, LABEL: Label, DATA, CMPL, PWF, DWF, LO, DEq>
         new_data_equivalence: NDEq,
     ) -> Query<'sg, 'storage, 'rslv, LABEL, DATA, CMPL, PWF, DWF, LO, NDEq>
     where
-        NDEq: DataEquivalence<DATA> + 'rslv,
+        NDEq: DataEquivalence<'sg, DATA> + 'rslv,
     {
         Query {
             _phantom: PhantomData,
diff --git a/scopegraphs/src/resolve/params.rs b/scopegraphs/src/resolve/params.rs
index e3414e4..c909892 100644
--- a/scopegraphs/src/resolve/params.rs
+++ b/scopegraphs/src/resolve/params.rs
@@ -86,9 +86,12 @@ impl<LABEL> LabelOrder<LABEL> for DefaultLabelOrder {
 /// Defines equivalence classes of declarations. Shadowing will only be applied with respect to
 /// declarations in the same equivalence class. That is, the shadowing explained in [`LabelOrder`]
 /// will only be applied if the declarations are equivalent.
-pub trait DataEquivalence<DATA> {
+pub trait DataEquivalence<'sg, DATA> {
+    /// Output of the data equivalence function; should something that contains a [bool].
+    type Output;
+
     /// Returns true if d1 is equivalent to d2
-    fn data_equiv(&self, d1: &DATA, d2: &DATA) -> bool;
+    fn data_equiv(&self, d1: &'sg DATA, d2: &'sg DATA) -> Self::Output;
 
     /// Returns if for this data equivalence, any data is always equivalent to any other data.
     fn always_equivalent(&self) -> bool {
@@ -96,11 +99,13 @@ pub trait DataEquivalence<DATA> {
     }
 }
 
-impl<DATA, T> DataEquivalence<DATA> for T
+impl<'sg, DATA: 'sg, T, O: 'sg> DataEquivalence<'sg, DATA> for T
 where
-    for<'sg> T: Fn(&'sg DATA, &'sg DATA) -> bool,
+    T: Fn(&'sg DATA, &'sg DATA) -> O,
 {
-    fn data_equiv(&self, d1: &DATA, d2: &DATA) -> bool {
+    type Output = O;
+
+    fn data_equiv(&self, d1: &'sg DATA, d2: &'sg DATA) -> Self::Output {
         self(d1, d2)
     }
 }
@@ -109,8 +114,10 @@ where
 #[derive(Default)]
 pub struct DefaultDataEquivalence {}
 
-impl<DATA> DataEquivalence<DATA> for DefaultDataEquivalence {
-    fn data_equiv(&self, _d1: &DATA, _d2: &DATA) -> bool {
+impl<'sg, DATA> DataEquivalence<'sg, DATA> for DefaultDataEquivalence {
+    type Output = bool;
+
+    fn data_equiv(&self, _d1: &'sg DATA, _d2: &'sg DATA) -> bool {
         true // all data in same equivalence class by default
     }
 

From 94e4f42442b629549f49f3b0c1f316e4b0d9ffbd Mon Sep 17 00:00:00 2001
From: Aron Zwaan <aronzwaan@gmail.com>
Date: Tue, 29 Oct 2024 10:26:17 +0100
Subject: [PATCH 2/8] Start working on example

---
 scopegraphs/examples/overload/main.rs | 3 +++
 1 file changed, 3 insertions(+)
 create mode 100644 scopegraphs/examples/overload/main.rs

diff --git a/scopegraphs/examples/overload/main.rs b/scopegraphs/examples/overload/main.rs
new file mode 100644
index 0000000..df1bb01
--- /dev/null
+++ b/scopegraphs/examples/overload/main.rs
@@ -0,0 +1,3 @@
+pub fn main() {
+    println!("Hello from overload example!")
+}

From 05b9ca9e6a7663801050887d15e46f1456ba9b11 Mon Sep 17 00:00:00 2001
From: Aron Zwaan <aronzwaan@gmail.com>
Date: Tue, 29 Oct 2024 10:30:36 +0100
Subject: [PATCH 3/8] Make clippy happy again

---
 scopegraphs/src/containers/env.rs | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/scopegraphs/src/containers/env.rs b/scopegraphs/src/containers/env.rs
index 66b2ea6..b5bafda 100644
--- a/scopegraphs/src/containers/env.rs
+++ b/scopegraphs/src/containers/env.rs
@@ -204,10 +204,9 @@ where
                     let filtered_env = sub_env
                         .iter()
                         .filter(|p1| {
-                            base_env
+                            !base_env
                                 .iter()
-                                .find(|p2| data_equiv.data_equiv(p1.data, p2.data))
-                                .is_none()
+                                .any(|p2| data_equiv.data_equiv(p1.data, p2.data))
                         })
                         .collect::<Vec<_>>();
 

From 677b3c4d4b8ec0e0d301609b8b5638aa496fe2a5 Mon Sep 17 00:00:00 2001
From: Aron Zwaan <aronzwaan@gmail.com>
Date: Tue, 29 Oct 2024 15:27:00 +0100
Subject: [PATCH 4/8] Trait for shadow operation

---
 scopegraphs/src/containers/env.rs   | 133 ++++++++++++++++++++--------
 scopegraphs/src/containers/path.rs  |  11 +--
 scopegraphs/src/containers/scope.rs |   9 +-
 scopegraphs/src/resolve/lookup.rs   |  76 +++++++++-------
 scopegraphs/src/resolve/mod.rs      |  10 +++
 5 files changed, 163 insertions(+), 76 deletions(-)

diff --git a/scopegraphs/src/containers/env.rs b/scopegraphs/src/containers/env.rs
index b5bafda..0937f45 100644
--- a/scopegraphs/src/containers/env.rs
+++ b/scopegraphs/src/containers/env.rs
@@ -165,58 +165,119 @@ where
     }
 }
 
-// Mergeable
+// Shadowable
 
-/// Environment Container in which a path can be injected based on a condition.
-pub trait Mergable<'sg, 'rslv, LABEL: 'sg, DATA: 'sg, DEQO>:
+/// Sub trait of [EnvContainer] that validates that shadowin operations can be applied on it.
+pub trait Shadowable<'sg, 'rslv, LABEL: 'sg, DATA: 'sg, DEQO>:
     EnvContainer<'sg, 'rslv, LABEL, DATA>
 where
     ResolvedPath<'sg, LABEL, DATA>: Eq + Hash + Clone,
 {
-    /// Creates a new environment that contains path when `data_ok` is `true`, and is empty otherwise.
-    fn merge_if(
-        &self,
-        data_equiv: &'rslv impl DataEquivalence<'sg, DATA, Output = DEQO>,
-        sub_env: Self,
+    /// Implementation of the shadow operation on this container.
+    fn shadow(
+        base_env: Env<'sg, LABEL, DATA>,
+        sub_env: &Env<'sg, LABEL, DATA>,
+        equiv: &'rslv impl DataEquivalence<'sg, DATA, Output = DEQO>,
     ) -> Self;
 }
 
-impl<'sg: 'rslv, 'rslv, LABEL: Eq + 'sg, DATA: Eq + 'sg, ENVC>
-    Mergable<'sg, 'rslv, LABEL, DATA, bool> for ENVC
+impl<'sg: 'rslv, 'rslv, LABEL: 'sg, DATA: 'sg, ENVC> Shadowable<'sg, 'rslv, LABEL, DATA, bool>
+    for ENVC
 where
     ENVC: EnvContainer<'sg, 'rslv, LABEL, DATA>,
     Env<'sg, LABEL, DATA>: Clone,
     ResolvedPath<'sg, LABEL, DATA>: Eq + Hash + Clone,
 {
-    fn merge_if(
-        &self,
-        data_equiv: &'rslv impl DataEquivalence<'sg, DATA, Output = bool>,
-        sub_env: Self,
+    fn shadow(
+        base_env: Env<'sg, LABEL, DATA>,
+        sub_env: &Env<'sg, LABEL, DATA>,
+        equiv: &'rslv impl DataEquivalence<'sg, DATA, Output = bool>,
     ) -> Self {
-        let base_env = self;
-        base_env.flat_map(move |base_env| {
-            if !base_env.is_empty() && data_equiv.always_equivalent() {
-                <ENVC as From<Env<'sg, LABEL, DATA>>>::from(base_env.clone())
-            } else {
-                let base_env = base_env.clone();
-
-                sub_env.flat_map(move |sub_env| {
-                    let filtered_env = sub_env
-                        .iter()
-                        .filter(|p1| {
-                            !base_env
-                                .iter()
-                                .any(|p2| data_equiv.data_equiv(p1.data, p2.data))
-                        })
-                        .collect::<Vec<_>>();
-
-                    let mut new_env = base_env;
-                    for path in filtered_env {
-                        new_env.insert(path.clone())
+        let filtered_env = sub_env
+            .iter()
+            .filter(|p1| !base_env.iter().any(|p2| equiv.data_equiv(p1.data, p2.data)))
+            .collect::<Vec<_>>();
+
+        // FIXME: factor out this part?
+        let mut new_env = base_env;
+        for path in filtered_env {
+            new_env.insert(path.clone())
+        }
+        new_env.into()
+    }
+}
+
+impl<'sg: 'rslv, 'rslv, LABEL: Clone + Eq + 'sg, DATA: Eq + 'sg, E: Clone + 'rslv>
+    Shadowable<'sg, 'rslv, LABEL, DATA, Result<bool, E>> for Result<Env<'sg, LABEL, DATA>, E>
+where
+    Env<'sg, LABEL, DATA>: Clone,
+    ResolvedPath<'sg, LABEL, DATA>: Eq + Hash + Clone,
+{
+    fn shadow(
+        base_env: Env<'sg, LABEL, DATA>,
+        sub_env: &Env<'sg, LABEL, DATA>,
+        equiv: &'rslv impl DataEquivalence<'sg, DATA, Output = Result<bool, E>>,
+    ) -> Self {
+        let sub_env = sub_env.clone();
+        let filtered_env = sub_env.into_iter().try_fold(
+            Vec::<ResolvedPath<'sg, LABEL, DATA>>::new(),
+            |mut filtered_env: Vec<ResolvedPath<'sg, LABEL, DATA>>,
+             p1: ResolvedPath<'sg, LABEL, DATA>| {
+                let shadowed = base_env.iter().try_fold(
+                    /* initially, not shadowed */ false,
+                    |previously_shadowed: bool, p2: &ResolvedPath<'sg, LABEL, DATA>| {
+                        if previously_shadowed {
+                            Ok(true) // if it was shadowed, it will be
+                        } else {
+                            // not yet shadowed, try if current path shadows
+                            equiv.data_equiv(p1.data, p2.data)
+                        }
+                    },
+                )?;
+                // p1 is not shadowed, so add it to accumulator
+                if !shadowed {
+                    filtered_env.push(p1);
+                }
+
+                Ok(filtered_env)
+            },
+        )?;
+        let mut new_env = base_env;
+        filtered_env
+            .into_iter()
+            .for_each(|path| new_env.insert(path));
+        new_env.into()
+    }
+}
+
+impl<'sg: 'rslv, 'rslv, LABEL: Clone + Eq + 'sg, DATA: Eq + 'sg>
+    Shadowable<'sg, 'rslv, LABEL, DATA, FutureWrapper<'rslv, bool>>
+    for FutureWrapper<'rslv, Env<'sg, LABEL, DATA>>
+where
+    Env<'sg, LABEL, DATA>: Clone,
+    ResolvedPath<'sg, LABEL, DATA>: Eq + Hash + Clone,
+{
+    fn shadow(
+        base_env: Env<'sg, LABEL, DATA>,
+        sub_env: &Env<'sg, LABEL, DATA>,
+        equiv: &'rslv impl DataEquivalence<'sg, DATA, Output = FutureWrapper<'rslv, bool>>,
+    ) -> Self {
+        let sub_env = sub_env.clone();
+        FutureWrapper::new(async move {
+            let mut filtered_env: Vec<ResolvedPath<'sg, LABEL, DATA>> = Vec::new();
+            'outer: for sub_path in sub_env {
+                for base_path in &base_env {
+                    if equiv.data_equiv(sub_path.data, base_path.data).await {
+                        continue 'outer;
                     }
-                    new_env.into()
-                })
+                }
+                filtered_env.push(sub_path.clone());
+            }
+            let mut new_env = base_env;
+            for path in filtered_env {
+                new_env.insert(path);
             }
+            new_env
         })
     }
 }
diff --git a/scopegraphs/src/containers/path.rs b/scopegraphs/src/containers/path.rs
index d92aab8..9257725 100644
--- a/scopegraphs/src/containers/path.rs
+++ b/scopegraphs/src/containers/path.rs
@@ -4,7 +4,7 @@ use futures::future::join_all;
 use std::fmt::Debug;
 use std::hash::Hash;
 
-use super::{Injectable, Mergable};
+use super::{Injectable, Shadowable};
 
 /// Interface for path containers that support the operations required for query resolution.
 pub trait PathContainer<'sg, 'rslv, LABEL: 'sg, DATA: 'sg>: Debug + 'rslv {
@@ -19,23 +19,24 @@ pub trait PathContainer<'sg, 'rslv, LABEL: 'sg, DATA: 'sg>: Debug + 'rslv {
 }
 
 /// Trait that is auto-implemented for any [PathContainer] implementation that yields a valid [EnvContainer].
-pub trait PathContainerWf<'sg, 'rslv, LABEL: 'sg, DATA: 'sg, DWFO>:
+pub trait PathContainerWf<'sg, 'rslv, LABEL: 'sg, DATA: 'sg, DWFO, DEQO>:
     PathContainer<'sg, 'rslv, LABEL, DATA, EnvContainer = Self::EnvContainerWf>
 where
     ResolvedPath<'sg, LABEL, DATA>: Eq + Hash + Clone,
 {
     /// Witness that ```Self::EnvContainer``` is a valid environment container.
     type EnvContainerWf: Injectable<'sg, 'rslv, LABEL, DATA, DWFO>
-        + Mergable<'sg, 'rslv, LABEL, DATA, bool>;
+        + Shadowable<'sg, 'rslv, LABEL, DATA, DEQO>;
 }
 
-impl<'sg, 'rslv, LABEL, DATA, DWFO, T> PathContainerWf<'sg, 'rslv, LABEL, DATA, DWFO> for T
+impl<'sg, 'rslv, LABEL, DATA, DWFO, DEQO, T> PathContainerWf<'sg, 'rslv, LABEL, DATA, DWFO, DEQO>
+    for T
 where
     LABEL: Debug + 'sg,
     DATA: 'sg,
     T: PathContainer<'sg, 'rslv, LABEL, DATA>,
     Self::EnvContainer:
-        Injectable<'sg, 'rslv, LABEL, DATA, DWFO> + Mergable<'sg, 'rslv, LABEL, DATA, bool>,
+        Injectable<'sg, 'rslv, LABEL, DATA, DWFO> + Shadowable<'sg, 'rslv, LABEL, DATA, DEQO>,
     ResolvedPath<'sg, LABEL, DATA>: Eq + Hash + Clone,
 {
     type EnvContainerWf = Self::EnvContainer;
diff --git a/scopegraphs/src/containers/scope.rs b/scopegraphs/src/containers/scope.rs
index 76c0c0c..36cc94f 100644
--- a/scopegraphs/src/containers/scope.rs
+++ b/scopegraphs/src/containers/scope.rs
@@ -83,7 +83,7 @@ pub trait ScopeContainer<'sg, 'rslv, LABEL: Debug + 'sg, DATA: 'sg>: Debug {
 /// }
 /// ```
 ///
-pub trait ScopeContainerWf<'sg, 'rslv, LABEL, DATA, DWFO>:
+pub trait ScopeContainerWf<'sg, 'rslv, LABEL, DATA, DWFO, DEQO>:
     ScopeContainer<'sg, 'rslv, LABEL, DATA, PathContainer = Self::PathContainerWf>
 where
     LABEL: Debug + 'sg,
@@ -91,15 +91,16 @@ where
     ResolvedPath<'sg, LABEL, DATA>: Eq + Hash + Clone,
 {
     /// Refinement of `Self::PathContainer`, carrying proof that this scope container resolves to valid path containers.
-    type PathContainerWf: PathContainerWf<'sg, 'rslv, LABEL, DATA, DWFO>;
+    type PathContainerWf: PathContainerWf<'sg, 'rslv, LABEL, DATA, DWFO, DEQO>;
 }
 
-impl<'sg, 'rslv, LABEL, DATA, DWFO, T> ScopeContainerWf<'sg, 'rslv, LABEL, DATA, DWFO> for T
+impl<'sg, 'rslv, LABEL, DATA, DWFO, DEQO, T> ScopeContainerWf<'sg, 'rslv, LABEL, DATA, DWFO, DEQO>
+    for T
 where
     LABEL: Debug + 'sg,
     DATA: 'sg,
     T: ScopeContainer<'sg, 'rslv, LABEL, DATA>,
-    Self::PathContainer: PathContainerWf<'sg, 'rslv, LABEL, DATA, DWFO>,
+    Self::PathContainer: PathContainerWf<'sg, 'rslv, LABEL, DATA, DWFO, DEQO>,
     ResolvedPath<'sg, LABEL, DATA>: Eq + Hash + Clone,
 {
     type PathContainerWf = Self::PathContainer;
diff --git a/scopegraphs/src/resolve/lookup.rs b/scopegraphs/src/resolve/lookup.rs
index b1abc64..0d70359 100644
--- a/scopegraphs/src/resolve/lookup.rs
+++ b/scopegraphs/src/resolve/lookup.rs
@@ -4,6 +4,8 @@
 //! The versatile set of parameters guides the search to ensure the resulting environment matches
 //! the intended semantics of the reference.
 
+#![allow(clippy::type_complexity)]
+
 use std::cell::RefCell;
 use std::collections::HashMap;
 use std::fmt::Debug;
@@ -14,12 +16,11 @@ use std::sync::Arc;
 
 use crate::completeness::Completeness;
 use crate::containers::{
-    EnvContainer, Injectable, Mergable, PathContainer, PathContainerWf, ScopeContainer,
-    ScopeContainerWf,
+    EnvContainer, Injectable, PathContainer, PathContainerWf, ScopeContainer, ScopeContainerWf,
+    Shadowable,
 };
 use crate::resolve::{
-    DataEquivalence, DataWellformedness, EdgeOrData, Env, LabelOrder, Path, Query, Resolve,
-    ResolvedPath,
+    DataEquivalence, DataWellformedness, EdgeOrData, LabelOrder, Path, Query, Resolve, ResolvedPath,
 };
 use crate::{Label, Scope, ScopeGraph};
 use scopegraphs_regular_expressions::RegexMatcher;
@@ -31,18 +32,19 @@ 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, DEq::Output>,
     PWF: for<'a> RegexMatcher<&'a LABEL> + 'rslv,
     DWF: DataWellformedness<'sg, DATA> + 'rslv,
 
     // DWF : DataWellFormedNess<DATA, Completeness::DWF>
     LO: LabelOrder<LABEL> + 'rslv,
-    DEq: DataEquivalence<'sg, DATA, /* tmp */ Output = bool> + 'rslv,
+    DEq: DataEquivalence<'sg, DATA> + 'rslv,
     ResolvedPath<'sg, LABEL, DATA>: Hash + Eq,
     Path<LABEL>: Clone,
 {
     type EnvContainer
-        = EnvC<'sg, 'rslv, CMPL, LABEL, DATA, DWF::Output>
+        = EnvC<'sg, 'rslv, CMPL, LABEL, DATA, DWF::Output, DEq::Output>
     where
         'sg: 'rslv,
         Self: 'rslv;
@@ -98,14 +100,15 @@ struct ResolutionContext<'storage, 'sg: 'rslv, 'rslv, LABEL: Label, DATA, CMPL,
     data_equiv: &'rslv DEq,
 }
 
-type EnvC<'sg, 'rslv, CMPL, LABEL, DATA, DWFO> =
+type EnvC<'sg, 'rslv, CMPL, LABEL, DATA, DWFO, DEQO> =
     <<<CMPL as Completeness<LABEL, DATA>>::GetEdgesResult<'rslv> as ScopeContainerWf<
         'sg,
         'rslv,
         LABEL,
         DATA,
         DWFO,
-    >>::PathContainerWf as PathContainerWf<'sg, 'rslv, LABEL, DATA, DWFO>>::EnvContainerWf;
+        DEQO,
+    >>::PathContainerWf as PathContainerWf<'sg, 'rslv, LABEL, DATA, DWFO, DEQO>>::EnvContainerWf;
 
 type EnvCache<LABEL, ENVC> = RefCell<HashMap<EdgeOrData<LABEL>, Rc<ENVC>>>;
 
@@ -116,8 +119,9 @@ where
     DATA: Debug,
     ResolvedPath<'sg, LABEL, DATA>: Hash + Eq,
     CMPL: Completeness<LABEL, DATA>,
-    CMPL::GetEdgesResult<'rslv>: ScopeContainerWf<'sg, 'rslv, LABEL, DATA, DWF::Output>,
-    DEq: DataEquivalence<'sg, DATA, /* tmp */ Output = bool>,
+    CMPL::GetEdgesResult<'rslv>:
+        ScopeContainerWf<'sg, 'rslv, LABEL, DATA, DWF::Output, DEq::Output>,
+    DEq: DataEquivalence<'sg, DATA>,
     DWF: DataWellformedness<'sg, DATA>,
     LO: LabelOrder<LABEL>,
     Path<LABEL>: Clone,
@@ -130,7 +134,7 @@ where
         self: &Arc<Self>,
         path_wellformedness: impl for<'a> RegexMatcher<&'a LABEL> + 'rslv,
         path: Path<LABEL>,
-    ) -> EnvC<'sg, 'rslv, CMPL, LABEL, DATA, DWF::Output> {
+    ) -> EnvC<'sg, 'rslv, CMPL, LABEL, DATA, DWF::Output, DEq::Output> {
         let edges: Vec<_> = self
             .all_edges
             .iter()
@@ -154,15 +158,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, DWF::Output>>,
-    ) -> EnvC<'sg, 'rslv, CMPL, LABEL, DATA, DWF::Output> {
+        cache: &EnvCache<LABEL, EnvC<'sg, 'rslv, CMPL, LABEL, DATA, DWF::Output, DEq::Output>>,
+    ) -> EnvC<'sg, 'rslv, CMPL, LABEL, DATA, DWF::Output, DEq::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, DWF::Output>>, _>(|edge| {
+            .map::<Rc<EnvC<'sg, 'rslv, CMPL, LABEL, DATA, DWF::Output, DEq::Output>>, _>(|edge| {
                 if let Some(env) = cache.borrow().get(&edge) {
                     log::info!("Reuse {:?}-environment from cache", edge);
                     return env.clone();
@@ -191,9 +195,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, DWF::Output> as From<
-                            Env<'sg, LABEL, DATA>,
-                        >>::from(merged_env)
+                        merged_env.into()
                     })
                 })
             })
@@ -210,16 +212,25 @@ 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, DWF::Output>>,
-    ) -> Rc<EnvC<'sg, 'rslv, CMPL, LABEL, DATA, DWF::Output>> {
+        cache: &EnvCache<LABEL, EnvC<'sg, 'rslv, CMPL, LABEL, DATA, DWF::Output, DEq::Output>>,
+    ) -> Rc<EnvC<'sg, 'rslv, CMPL, LABEL, DATA, DWF::Output, DEq::Output>> {
         // base environment
-        let base_env: EnvC<'sg, 'rslv, CMPL, LABEL, DATA, DWF::Output> =
+        let base_env: EnvC<'sg, 'rslv, CMPL, LABEL, DATA, DWF::Output, DEq::Output> =
             self.resolve_edges(path_wellformedness.clone(), edges, path.clone(), cache);
         let local_self = Arc::clone(self);
-        let sub_env = local_self.resolve_edge(path_wellformedness.clone(), edge, path);
 
         // environment of current (max) label, which might be shadowed by the base environment
-        Rc::new(base_env.merge_if(local_self.data_equiv, sub_env))
+        Rc::new(base_env.flat_map(move |base_env| {
+            if !base_env.is_empty() && local_self.data_equiv.always_equivalent() {
+                base_env.clone().into()
+            } else {
+                let base_env = base_env.clone();
+                let sub_env = local_self.resolve_edge(path_wellformedness.clone(), edge, path);
+                sub_env.flat_map(move |sub_env| {
+                    Shadowable::shadow(base_env, sub_env, local_self.data_equiv)
+                })
+            }
+        }))
     }
 
     /// Compute environment for single edge
@@ -228,7 +239,7 @@ where
         path_wellformedness: impl for<'a> RegexMatcher<&'a LABEL> + 'rslv,
         edge: EdgeOrData<LABEL>,
         path: Path<LABEL>,
-    ) -> EnvC<'sg, 'rslv, CMPL, LABEL, DATA, DWF::Output> {
+    ) -> EnvC<'sg, 'rslv, CMPL, LABEL, DATA, DWF::Output, DEq::Output> {
         match edge {
             EdgeOrData::Edge(label) => {
                 let mut new_path_wellformedness = path_wellformedness.clone();
@@ -248,25 +259,28 @@ where
         path_wellformedness: impl for<'a> RegexMatcher<&'a LABEL> + 'rslv,
         label: LABEL,
         path: Path<LABEL>,
-    ) -> EnvC<'sg, 'rslv, CMPL, LABEL, DATA, DWF::Output> {
+    ) -> EnvC<'sg, 'rslv, CMPL, LABEL, DATA, DWF::Output, DEq::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, DWF::Output> =
-            path_set.map_into_env::<_>(move |p| {
+        let env: EnvC<'sg, 'rslv, CMPL, LABEL, DATA, DWF::Output, DEq::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, DWF::Output> {
+    fn resolve_data(
+        &self,
+        path: Path<LABEL>,
+    ) -> EnvC<'sg, 'rslv, CMPL, LABEL, DATA, DWF::Output, DEq::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, DWF::Output> as Injectable<
+        <EnvC<'sg, 'rslv, CMPL, LABEL, DATA, DWF::Output, DEq::Output> as Injectable<
             'sg,
             'rslv,
             LABEL,
@@ -303,8 +317,8 @@ where
         smaller
     }
 
-    fn empty_env_container() -> EnvC<'sg, 'rslv, CMPL, LABEL, DATA, DWF::Output> {
-        <EnvC<'sg, 'rslv, CMPL, LABEL, DATA, DWF::Output> as EnvContainer<
+    fn empty_env_container() -> EnvC<'sg, 'rslv, CMPL, LABEL, DATA, DWF::Output, DEq::Output> {
+        <EnvC<'sg, 'rslv, CMPL, LABEL, DATA, DWF::Output, DEq::Output> as EnvContainer<
             'sg,
             'rslv,
             LABEL,
diff --git a/scopegraphs/src/resolve/mod.rs b/scopegraphs/src/resolve/mod.rs
index ae5d5cb..d231551 100644
--- a/scopegraphs/src/resolve/mod.rs
+++ b/scopegraphs/src/resolve/mod.rs
@@ -197,6 +197,16 @@ impl<LABEL> Path<LABEL> {
 #[derive(Debug)]
 pub struct Env<'sg, LABEL: 'sg, DATA>(HashSet<ResolvedPath<'sg, LABEL, DATA>>);
 
+impl<'a, 'sg, LABEL, DATA> IntoIterator for &'a Env<'sg, LABEL, DATA> {
+    type Item = &'a ResolvedPath<'sg, LABEL, DATA>;
+
+    type IntoIter = <&'a HashSet<ResolvedPath<'sg, LABEL, DATA>> as IntoIterator>::IntoIter;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.0.iter()
+    }
+}
+
 impl<'sg, LABEL, DATA> IntoIterator for Env<'sg, LABEL, DATA> {
     type Item = ResolvedPath<'sg, LABEL, DATA>;
 

From 957e1f77a26e0192feb4af20f4a2c7ed74fc196c Mon Sep 17 00:00:00 2001
From: Aron Zwaan <aronzwaan@gmail.com>
Date: Wed, 30 Oct 2024 11:07:26 +0100
Subject: [PATCH 5/8] Factor out shared part about merging the environments

---
 scopegraphs/src/containers/env.rs  | 67 ++++++++++++------------------
 scopegraphs/src/containers/path.rs |  6 +--
 scopegraphs/src/resolve/lookup.rs  | 10 +++--
 scopegraphs/src/resolve/mod.rs     |  2 +-
 4 files changed, 38 insertions(+), 47 deletions(-)

diff --git a/scopegraphs/src/containers/env.rs b/scopegraphs/src/containers/env.rs
index 0937f45..261fed2 100644
--- a/scopegraphs/src/containers/env.rs
+++ b/scopegraphs/src/containers/env.rs
@@ -165,63 +165,58 @@ where
     }
 }
 
-// Shadowable
+// Filtering
 
-/// Sub trait of [EnvContainer] that validates that shadowin operations can be applied on it.
-pub trait Shadowable<'sg, 'rslv, LABEL: 'sg, DATA: 'sg, DEQO>:
+/// Sub trait of [EnvContainer] that validates that filtering operations (for shadowing) can be applied on it.
+pub trait Filterable<'sg, 'rslv, LABEL: 'sg, DATA: 'sg, DEQO>:
     EnvContainer<'sg, 'rslv, LABEL, DATA>
 where
     ResolvedPath<'sg, LABEL, DATA>: Eq + Hash + Clone,
 {
     /// Implementation of the shadow operation on this container.
-    fn shadow(
-        base_env: Env<'sg, LABEL, DATA>,
+    fn filter(
+        base_env: &Env<'sg, LABEL, DATA>,
         sub_env: &Env<'sg, LABEL, DATA>,
         equiv: &'rslv impl DataEquivalence<'sg, DATA, Output = DEQO>,
     ) -> Self;
 }
 
-impl<'sg: 'rslv, 'rslv, LABEL: 'sg, DATA: 'sg, ENVC> Shadowable<'sg, 'rslv, LABEL, DATA, bool>
+impl<'sg: 'rslv, 'rslv, LABEL: 'sg, DATA: 'sg, ENVC> Filterable<'sg, 'rslv, LABEL, DATA, bool>
     for ENVC
 where
     ENVC: EnvContainer<'sg, 'rslv, LABEL, DATA>,
     Env<'sg, LABEL, DATA>: Clone,
     ResolvedPath<'sg, LABEL, DATA>: Eq + Hash + Clone,
 {
-    fn shadow(
-        base_env: Env<'sg, LABEL, DATA>,
+    fn filter(
+        base_env: &Env<'sg, LABEL, DATA>,
         sub_env: &Env<'sg, LABEL, DATA>,
         equiv: &'rslv impl DataEquivalence<'sg, DATA, Output = bool>,
     ) -> Self {
-        let filtered_env = sub_env
+        sub_env
             .iter()
             .filter(|p1| !base_env.iter().any(|p2| equiv.data_equiv(p1.data, p2.data)))
-            .collect::<Vec<_>>();
-
-        // FIXME: factor out this part?
-        let mut new_env = base_env;
-        for path in filtered_env {
-            new_env.insert(path.clone())
-        }
-        new_env.into()
+            .cloned()
+            .collect::<Env<_, _>>()
+            .into()
     }
 }
 
 impl<'sg: 'rslv, 'rslv, LABEL: Clone + Eq + 'sg, DATA: Eq + 'sg, E: Clone + 'rslv>
-    Shadowable<'sg, 'rslv, LABEL, DATA, Result<bool, E>> for Result<Env<'sg, LABEL, DATA>, E>
+    Filterable<'sg, 'rslv, LABEL, DATA, Result<bool, E>> for Result<Env<'sg, LABEL, DATA>, E>
 where
     Env<'sg, LABEL, DATA>: Clone,
     ResolvedPath<'sg, LABEL, DATA>: Eq + Hash + Clone,
 {
-    fn shadow(
-        base_env: Env<'sg, LABEL, DATA>,
+    fn filter(
+        base_env: &Env<'sg, LABEL, DATA>,
         sub_env: &Env<'sg, LABEL, DATA>,
         equiv: &'rslv impl DataEquivalence<'sg, DATA, Output = Result<bool, E>>,
     ) -> Self {
         let sub_env = sub_env.clone();
-        let filtered_env = sub_env.into_iter().try_fold(
-            Vec::<ResolvedPath<'sg, LABEL, DATA>>::new(),
-            |mut filtered_env: Vec<ResolvedPath<'sg, LABEL, DATA>>,
+        sub_env.into_iter().try_fold(
+            Env::new(),
+            |mut filtered_env: Env<'sg, LABEL, DATA>,
              p1: ResolvedPath<'sg, LABEL, DATA>| {
                 let shadowed = base_env.iter().try_fold(
                     /* initially, not shadowed */ false,
@@ -236,48 +231,40 @@ where
                 )?;
                 // p1 is not shadowed, so add it to accumulator
                 if !shadowed {
-                    filtered_env.push(p1);
+                    filtered_env.insert(p1);
                 }
 
                 Ok(filtered_env)
             },
-        )?;
-        let mut new_env = base_env;
-        filtered_env
-            .into_iter()
-            .for_each(|path| new_env.insert(path));
-        new_env.into()
+        )
     }
 }
 
 impl<'sg: 'rslv, 'rslv, LABEL: Clone + Eq + 'sg, DATA: Eq + 'sg>
-    Shadowable<'sg, 'rslv, LABEL, DATA, FutureWrapper<'rslv, bool>>
+    Filterable<'sg, 'rslv, LABEL, DATA, FutureWrapper<'rslv, bool>>
     for FutureWrapper<'rslv, Env<'sg, LABEL, DATA>>
 where
     Env<'sg, LABEL, DATA>: Clone,
     ResolvedPath<'sg, LABEL, DATA>: Eq + Hash + Clone,
 {
-    fn shadow(
-        base_env: Env<'sg, LABEL, DATA>,
+    fn filter(
+        base_env: &Env<'sg, LABEL, DATA>,
         sub_env: &Env<'sg, LABEL, DATA>,
         equiv: &'rslv impl DataEquivalence<'sg, DATA, Output = FutureWrapper<'rslv, bool>>,
     ) -> Self {
+        let base_env = base_env.clone();
         let sub_env = sub_env.clone();
         FutureWrapper::new(async move {
-            let mut filtered_env: Vec<ResolvedPath<'sg, LABEL, DATA>> = Vec::new();
+            let mut filtered_env = Env::new();
             'outer: for sub_path in sub_env {
                 for base_path in &base_env {
                     if equiv.data_equiv(sub_path.data, base_path.data).await {
                         continue 'outer;
                     }
                 }
-                filtered_env.push(sub_path.clone());
-            }
-            let mut new_env = base_env;
-            for path in filtered_env {
-                new_env.insert(path);
+                filtered_env.insert(sub_path.clone());
             }
-            new_env
+            filtered_env
         })
     }
 }
diff --git a/scopegraphs/src/containers/path.rs b/scopegraphs/src/containers/path.rs
index 9257725..9ec306b 100644
--- a/scopegraphs/src/containers/path.rs
+++ b/scopegraphs/src/containers/path.rs
@@ -4,7 +4,7 @@ use futures::future::join_all;
 use std::fmt::Debug;
 use std::hash::Hash;
 
-use super::{Injectable, Shadowable};
+use super::{Injectable, Filterable};
 
 /// Interface for path containers that support the operations required for query resolution.
 pub trait PathContainer<'sg, 'rslv, LABEL: 'sg, DATA: 'sg>: Debug + 'rslv {
@@ -26,7 +26,7 @@ where
 {
     /// Witness that ```Self::EnvContainer``` is a valid environment container.
     type EnvContainerWf: Injectable<'sg, 'rslv, LABEL, DATA, DWFO>
-        + Shadowable<'sg, 'rslv, LABEL, DATA, DEQO>;
+        + Filterable<'sg, 'rslv, LABEL, DATA, DEQO>;
 }
 
 impl<'sg, 'rslv, LABEL, DATA, DWFO, DEQO, T> PathContainerWf<'sg, 'rslv, LABEL, DATA, DWFO, DEQO>
@@ -36,7 +36,7 @@ where
     DATA: 'sg,
     T: PathContainer<'sg, 'rslv, LABEL, DATA>,
     Self::EnvContainer:
-        Injectable<'sg, 'rslv, LABEL, DATA, DWFO> + Shadowable<'sg, 'rslv, LABEL, DATA, DEQO>,
+        Injectable<'sg, 'rslv, LABEL, DATA, DWFO> + Filterable<'sg, 'rslv, LABEL, DATA, DEQO>,
     ResolvedPath<'sg, LABEL, DATA>: Eq + Hash + Clone,
 {
     type EnvContainerWf = Self::EnvContainer;
diff --git a/scopegraphs/src/resolve/lookup.rs b/scopegraphs/src/resolve/lookup.rs
index 0d70359..62cb350 100644
--- a/scopegraphs/src/resolve/lookup.rs
+++ b/scopegraphs/src/resolve/lookup.rs
@@ -17,7 +17,7 @@ use std::sync::Arc;
 use crate::completeness::Completeness;
 use crate::containers::{
     EnvContainer, Injectable, PathContainer, PathContainerWf, ScopeContainer, ScopeContainerWf,
-    Shadowable,
+    Filterable,
 };
 use crate::resolve::{
     DataEquivalence, DataWellformedness, EdgeOrData, LabelOrder, Path, Query, Resolve, ResolvedPath,
@@ -224,10 +224,14 @@ where
             if !base_env.is_empty() && local_self.data_equiv.always_equivalent() {
                 base_env.clone().into()
             } else {
-                let base_env = base_env.clone();
+                let mut base_env = base_env.clone();
                 let sub_env = local_self.resolve_edge(path_wellformedness.clone(), edge, path);
                 sub_env.flat_map(move |sub_env| {
-                    Shadowable::shadow(base_env, sub_env, local_self.data_equiv)
+                    let merged_env: EnvC<'sg, 'rslv, CMPL, LABEL, DATA, DWF::Output, DEq::Output> = Filterable::filter(&base_env, sub_env, local_self.data_equiv);
+                    merged_env.flat_map(move |merged_env| {
+                        base_env.merge(merged_env);
+                        base_env.into()
+                    })
                 })
             }
         }))
diff --git a/scopegraphs/src/resolve/mod.rs b/scopegraphs/src/resolve/mod.rs
index d231551..002a1ba 100644
--- a/scopegraphs/src/resolve/mod.rs
+++ b/scopegraphs/src/resolve/mod.rs
@@ -372,7 +372,7 @@ where
     }
 }
 
-impl<'sg, LABEL: 'sg, DATA: Hash> FromIterator<ResolvedPath<'sg, LABEL, DATA>>
+impl<'sg, LABEL: 'sg, DATA> FromIterator<ResolvedPath<'sg, LABEL, DATA>>
     for Env<'sg, LABEL, DATA>
 where
     ResolvedPath<'sg, LABEL, DATA>: Eq + Hash,

From ca5254de5f297af20c09fcfbecc38e2ac69a0fcc Mon Sep 17 00:00:00 2001
From: Aron Zwaan <aronzwaan@gmail.com>
Date: Wed, 30 Oct 2024 11:09:55 +0100
Subject: [PATCH 6/8] fix comment

---
 scopegraphs/src/containers/env.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/scopegraphs/src/containers/env.rs b/scopegraphs/src/containers/env.rs
index 261fed2..96c6ed3 100644
--- a/scopegraphs/src/containers/env.rs
+++ b/scopegraphs/src/containers/env.rs
@@ -173,7 +173,7 @@ pub trait Filterable<'sg, 'rslv, LABEL: 'sg, DATA: 'sg, DEQO>:
 where
     ResolvedPath<'sg, LABEL, DATA>: Eq + Hash + Clone,
 {
-    /// Implementation of the shadow operation on this container.
+    /// Implementation of the filter operation on this container.
     fn filter(
         base_env: &Env<'sg, LABEL, DATA>,
         sub_env: &Env<'sg, LABEL, DATA>,

From 675da40d3c2253381d99ecd6450477bdd7962c3d Mon Sep 17 00:00:00 2001
From: Aron Zwaan <aronzwaan@gmail.com>
Date: Wed, 30 Oct 2024 11:15:39 +0100
Subject: [PATCH 7/8] format

---
 scopegraphs/src/containers/env.rs  |  3 +--
 scopegraphs/src/containers/path.rs |  2 +-
 scopegraphs/src/resolve/lookup.rs  | 15 ++++++++-------
 scopegraphs/src/resolve/mod.rs     |  3 +--
 4 files changed, 11 insertions(+), 12 deletions(-)

diff --git a/scopegraphs/src/containers/env.rs b/scopegraphs/src/containers/env.rs
index 96c6ed3..928f59e 100644
--- a/scopegraphs/src/containers/env.rs
+++ b/scopegraphs/src/containers/env.rs
@@ -216,8 +216,7 @@ where
         let sub_env = sub_env.clone();
         sub_env.into_iter().try_fold(
             Env::new(),
-            |mut filtered_env: Env<'sg, LABEL, DATA>,
-             p1: ResolvedPath<'sg, LABEL, DATA>| {
+            |mut filtered_env: Env<'sg, LABEL, DATA>, p1: ResolvedPath<'sg, LABEL, DATA>| {
                 let shadowed = base_env.iter().try_fold(
                     /* initially, not shadowed */ false,
                     |previously_shadowed: bool, p2: &ResolvedPath<'sg, LABEL, DATA>| {
diff --git a/scopegraphs/src/containers/path.rs b/scopegraphs/src/containers/path.rs
index 9ec306b..9201dcd 100644
--- a/scopegraphs/src/containers/path.rs
+++ b/scopegraphs/src/containers/path.rs
@@ -4,7 +4,7 @@ use futures::future::join_all;
 use std::fmt::Debug;
 use std::hash::Hash;
 
-use super::{Injectable, Filterable};
+use super::{Filterable, Injectable};
 
 /// Interface for path containers that support the operations required for query resolution.
 pub trait PathContainer<'sg, 'rslv, LABEL: 'sg, DATA: 'sg>: Debug + 'rslv {
diff --git a/scopegraphs/src/resolve/lookup.rs b/scopegraphs/src/resolve/lookup.rs
index 62cb350..6bbac3e 100644
--- a/scopegraphs/src/resolve/lookup.rs
+++ b/scopegraphs/src/resolve/lookup.rs
@@ -16,8 +16,8 @@ use std::sync::Arc;
 
 use crate::completeness::Completeness;
 use crate::containers::{
-    EnvContainer, Injectable, PathContainer, PathContainerWf, ScopeContainer, ScopeContainerWf,
-    Filterable,
+    EnvContainer, Filterable, Injectable, PathContainer, PathContainerWf, ScopeContainer,
+    ScopeContainerWf,
 };
 use crate::resolve::{
     DataEquivalence, DataWellformedness, EdgeOrData, LabelOrder, Path, Query, Resolve, ResolvedPath,
@@ -227,11 +227,12 @@ where
                 let mut base_env = base_env.clone();
                 let sub_env = local_self.resolve_edge(path_wellformedness.clone(), edge, path);
                 sub_env.flat_map(move |sub_env| {
-                    let merged_env: EnvC<'sg, 'rslv, CMPL, LABEL, DATA, DWF::Output, DEq::Output> = Filterable::filter(&base_env, sub_env, local_self.data_equiv);
-                    merged_env.flat_map(move |merged_env| {
-                        base_env.merge(merged_env);
-                        base_env.into()
-                    })
+                    let filtered_env: EnvC<'sg, 'rslv, CMPL, LABEL, DATA, DWF::Output, DEq::Output> =
+                        Filterable::filter(&base_env, sub_env, local_self.data_equiv);
+                        filtered_env.flat_map(move |filtered_env| {
+                            base_env.merge(filtered_env);
+                            base_env.into()
+                        })
                 })
             }
         }))
diff --git a/scopegraphs/src/resolve/mod.rs b/scopegraphs/src/resolve/mod.rs
index 002a1ba..af41529 100644
--- a/scopegraphs/src/resolve/mod.rs
+++ b/scopegraphs/src/resolve/mod.rs
@@ -372,8 +372,7 @@ where
     }
 }
 
-impl<'sg, LABEL: 'sg, DATA> FromIterator<ResolvedPath<'sg, LABEL, DATA>>
-    for Env<'sg, LABEL, DATA>
+impl<'sg, LABEL: 'sg, DATA> FromIterator<ResolvedPath<'sg, LABEL, DATA>> for Env<'sg, LABEL, DATA>
 where
     ResolvedPath<'sg, LABEL, DATA>: Eq + Hash,
 {

From 0f1b2eaf728beb43aae97599acf6c171cb998366 Mon Sep 17 00:00:00 2001
From: Aron Zwaan <aronzwaan@gmail.com>
Date: Wed, 30 Oct 2024 11:22:26 +0100
Subject: [PATCH 8/8] Fix tests

---
 scopegraphs/src/containers/scope.rs | 14 +++++++-------
 scopegraphs/src/resolve/lookup.rs   | 19 +++++++++++++------
 2 files changed, 20 insertions(+), 13 deletions(-)

diff --git a/scopegraphs/src/containers/scope.rs b/scopegraphs/src/containers/scope.rs
index 36cc94f..b53a4e8 100644
--- a/scopegraphs/src/containers/scope.rs
+++ b/scopegraphs/src/containers/scope.rs
@@ -36,7 +36,7 @@ pub trait ScopeContainer<'sg, 'rslv, LABEL: Debug + 'sg, DATA: 'sg>: Debug {
 /// # 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>
+///     cont: impl ScopeContainerWf<'sg, 'rslv, LABEL, DATA, DWFO, DWFO>
 /// ) { }
 ///
 /// # fn scope_vec<'sg, 'rslv, LABEL: LBound<'sg>, DATA: DBound<'sg>>() {
@@ -64,9 +64,9 @@ pub trait ScopeContainer<'sg, 'rslv, LABEL: Debug + 'sg, DATA: 'sg>: Debug {
 /// # use std::hash::Hash;
 ///
 ///
-/// fn test<'sg, 'rslv, LABEL: Clone + Hash + Eq + Debug + 'sg, DATA: Hash + Eq + 'sg, DWFO>(cont: impl ScopeContainerWf<'sg, 'rslv, LABEL, DATA, DWFO>) {
-///
-/// }
+/// fn test<'sg, 'rslv, LABEL: Clone + Hash + Eq + Debug + 'sg, DATA: Hash + Eq + 'sg, DWFO>(
+///     cont: impl ScopeContainerWf<'sg, 'rslv, LABEL, DATA, DWFO, DWFO>
+/// ) { }
 /// ```
 ///
 /// ```no_run
@@ -78,9 +78,9 @@ pub trait ScopeContainer<'sg, 'rslv, LABEL: Debug + 'sg, DATA: 'sg>: Debug {
 /// test::<'_, '_, (), (), bool>(Result::<_, ()>::Ok(Vec::<Scope>::new()));
 /// test::<'_, '_, (), (), Result<bool, ()>>(Result::<_, ()>::Ok(Vec::<Scope>::new()));
 ///
-/// fn test<'sg, 'rslv, LABEL: Clone + Hash + Eq + Debug + 'sg, DATA: Hash + Eq + 'sg, DWFO>(cont: impl ScopeContainerWf<'sg, 'rslv, LABEL, DATA, DWFO>) {
-///
-/// }
+/// fn test<'sg, 'rslv, LABEL: Clone + Hash + Eq + Debug + 'sg, DATA: Hash + Eq + 'sg, DWFO>(
+///     cont: impl ScopeContainerWf<'sg, 'rslv, LABEL, DATA, DWFO, DWFO>
+/// ) { }
 /// ```
 ///
 pub trait ScopeContainerWf<'sg, 'rslv, LABEL, DATA, DWFO, DEQO>:
diff --git a/scopegraphs/src/resolve/lookup.rs b/scopegraphs/src/resolve/lookup.rs
index 6bbac3e..559972a 100644
--- a/scopegraphs/src/resolve/lookup.rs
+++ b/scopegraphs/src/resolve/lookup.rs
@@ -227,12 +227,19 @@ where
                 let mut base_env = base_env.clone();
                 let sub_env = local_self.resolve_edge(path_wellformedness.clone(), edge, path);
                 sub_env.flat_map(move |sub_env| {
-                    let filtered_env: EnvC<'sg, 'rslv, CMPL, LABEL, DATA, DWF::Output, DEq::Output> =
-                        Filterable::filter(&base_env, sub_env, local_self.data_equiv);
-                        filtered_env.flat_map(move |filtered_env| {
-                            base_env.merge(filtered_env);
-                            base_env.into()
-                        })
+                    let filtered_env: EnvC<
+                        'sg,
+                        'rslv,
+                        CMPL,
+                        LABEL,
+                        DATA,
+                        DWF::Output,
+                        DEq::Output,
+                    > = Filterable::filter(&base_env, sub_env, local_self.data_equiv);
+                    filtered_env.flat_map(move |filtered_env| {
+                        base_env.merge(filtered_env);
+                        base_env.into()
+                    })
                 })
             }
         }))