Point::resolve_map

src/rcore/point.rs

@@ -30,4 +30,11 @@ impl<'a, Ctx: Context<'a>, A: Mentionable<'a, Ctx>> Point<'a, Ctx, A> {
     pub fn resolve(&self) -> Resolution<'a, Ctx, A> {
         self.origin.clone().resolve()
     }
+
+    pub fn resolve_map<B: 'a>(
+        &self,
+        f: impl 'a + FnOnce(ResolutionResult<'a, Ctx, A>) -> B,
+    ) -> Wrapped<'a, Ctx, B> {
+        Ctx::fmap(self.resolve(), f)
+    }
 }

src/rstd/cast.rs

@@ -144,7 +144,7 @@ where
             Ok(point) => point,
             Err(cast_error) => return cast_error.pure::<Ctx>(),
         };
-        Ctx::fmap(point.resolve(), cast_resolved)
+        point.resolve_map(cast_resolved)
     }
 }
 

src/rstd/collections/stack.rs

@@ -164,7 +164,7 @@ impl<'a, Ctx: Context<'a>, A: Mentionable<'a, Ctx> + Clone> ExtStackClone<'a, Ct
     fn vec(self) -> StackVecWrapped<'a, Ctx, A> {
         Ctx::T::iterate_mut((vec![], self), |(mut vec, stack)| match stack {
             Nullable::Null(_) => Ctx::pure(ControlFlow::Break(Ok(vec))),
-            Nullable::NotNull(point) => Ctx::fmap(point.resolve(), |resolved| {
+            Nullable::NotNull(point) => point.resolve_map(|resolved| {
                 let node = match resolved {
                     Ok(node) => node,
                     Err(error) => {

src/rstd/collections/tree/context.rs

@@ -92,7 +92,7 @@ impl<'a, Ctx: Context<'a>, A: Mentionable<'a, Ctx> + Clone, C: 'a + Comparator<A
         &self,
         reference: &Self::Reference,
     ) -> crate::flow::binary::BTWrap<'a, Self, Self::Node> {
-        Ctx::stuff(Ctx::fmap(reference.resolve(), |resolved| {
+        Ctx::stuff(reference.resolve_map(|resolved| {
             resolved
                 .map(|rc| rc.as_ref().clone())
                 .map_err(TreeContextError::Resolution)