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] 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>;