ResolverMap::resolve_map

src/rcore.rs

@@ -28,7 +28,7 @@ pub use self::point::Point;
 pub use self::points::TakesPoints;
 pub use self::resolution::{
     Address, HashResolution, HashResolutionResult, Resolution, ResolutionError, ResolutionFailure,
-    ResolutionResult, Resolver,
+    ResolutionResult, Resolver, ResolverMap,
 };
 pub use self::serialization::{Deserializer, DeserializerExt, Serializable, Serializer};
 pub use self::slice_deserializer::SliceDeserializer;

src/rcore/resolution.rs

@@ -50,3 +50,15 @@ pub trait Resolver<'a, Ctx: Context<'a>>: 'a {
     /// with topology header ([`Mentionable::topology()`]) omitted.
     fn resolve(self: Rc<Self>, address: Address) -> HashResolution<'a, Ctx>;
 }
+
+pub trait ResolverMap<'a, Ctx: Context<'a>>: Resolver<'a, Ctx> {
+    fn resolve_map<T>(
+        self: Rc<Self>,
+        address: Address,
+        f: impl 'a + FnOnce(HashResolutionResult<'a, Ctx>) -> T,
+    ) -> Wrapped<'a, Ctx, T> {
+        Ctx::fmap(self.resolve(address), f)
+    }
+}
+
+impl<'a, Ctx: Context<'a>, R: ?Sized + Resolver<'a, Ctx>> ResolverMap<'a, Ctx> for R {}

src/rcore/resolver_origin.rs

@@ -27,8 +27,10 @@ struct ResolverOrigin<'a, Ctx: Context<'a>, F: Factory<'a, Ctx>> {
 fn _resolve_origin<'a, Ctx: Context<'a>, A: Mentionable<'a, Ctx>>(
     origin: Rc<ResolverOrigin<'a, Ctx, A::Fctr>>,
 ) -> Resolution<'a, Ctx, A> {
-    let resolution = origin.r_resolver.clone().resolve(origin.r_address);
+    origin
-    Ctx::fmap(resolution, move |resolved| {
+        .r_resolver
+        .clone()
+        .resolve_map(origin.r_address, move |resolved| {
             let (src, resolver) = resolved.map_err(ResolutionError::Lookup)?;
             let mentionable = origin
                 .r_factory

src/rstd/tracing/traceable.rs

@@ -14,7 +14,9 @@ impl<'a, Ctx: Context<'a, _Tm = TracedInstance>> TracedResolver<'a, Ctx> {
 
 impl<'a, Ctx: Context<'a, _Tm = TracedInstance>> Resolver<'a, Ctx> for TracedResolver<'a, Ctx> {
     fn resolve(self: Rc<Self>, address: Address) -> HashResolution<'a, Ctx> {
-        TracedInstance::fmap(self.resolver.clone().resolve(address), |resolved| {
+        self.resolver
+            .clone()
+            .resolve_map(address, |resolved| {
                 let (src, resolver) = resolved?;
                 let delayed: Rc<dyn Resolver<'a, Ctx>> = Rc::new(TracedResolver { resolver });
                 Ok((src, delayed))

src/testing/counted.rs

@@ -71,7 +71,9 @@ impl<'a> CountedResolver<'a> {
 
 impl<'a> Resolver<'a, TestContextCounted> for CountedResolver<'a> {
     fn resolve(self: Rc<Self>, address: Address) -> HashResolution<'a, TestContextCounted> {
-        CountedInstance::fmap(self.resolver.clone().resolve(address), |resolved| {
+        self.resolver
+            .clone()
+            .resolve_map(address, |resolved| {
                 let (src, resolver) = resolved?;
                 let delayed: Rc<dyn Resolver<'a, TestContextCounted>> =
                     Rc::new(CountedResolver { resolver });

src/testing/inject.rs

@@ -1,6 +1,5 @@
 use std::rc::Rc;
 
-use crate::func::context::*;
 use crate::rcore::*;
 
 trait Inject<'a, Ctx: Context<'a>>: 'a {
@@ -15,15 +14,16 @@ struct InjectedResolver<'a, Ctx: Context<'a>, F: Inject<'a, Ctx>> {
 impl<'a, Ctx: Context<'a>, F: Inject<'a, Ctx>> Resolver<'a, Ctx> for InjectedResolver<'a, Ctx, F> {
     fn resolve(self: Rc<Self>, address: crate::rcore::Address) -> HashResolution<'a, Ctx> {
         let inject = self.inject.clone();
-        self.inject.inject(Ctx::fmap(
+        self.inject.inject(
-            self.resolver.clone().resolve(address),
+            self.resolver
-            |resolved| match resolved {
+                .clone()
+                .resolve_map(address, |resolved| match resolved {
                     Ok((source, resolver)) => Ok((
                         source,
                         Rc::new(InjectedResolver { resolver, inject }) as Rc<dyn Resolver<'a, Ctx>>,
                     )),
                     Err(e) => Err(e),
-            },
+                }),
-        ))
+        )
     }
 }