CountedInject

src/testing/counted.rs

@@ -3,6 +3,7 @@ use std::cmp::max;
 use crate::func::{context::*, *};
 use crate::rcore::*;
 
+use super::inject::*;
 use super::*;
 
 pub struct TestContextCounted;
@@ -56,36 +57,20 @@ impl<A> Counted<A> {
     }
 }
 
-struct CountedResolver<'a> {
-    resolver: Rc<dyn Resolver<'a, TestContextCounted>>,
-}
+struct CountedInject;
 
-impl<'a> CountedResolver<'a> {
-    fn new(
-        resolver: Rc<dyn Resolver<'a, TestContextCounted>>,
-    ) -> Rc<dyn Resolver<'a, TestContextCounted>> {
-        Rc::new(Self { resolver })
-    }
-}
-
-impl<'a> Resolver<'a, TestContextCounted> for CountedResolver<'a> {
-    fn resolve(self: Rc<Self>, address: Address) -> HashResolution<'a, TestContextCounted> {
-        self.resolver
-            .clone()
-            .resolve_map(address, |resolved| {
-                let (src, resolver) = resolved?;
-                let delayed: Rc<dyn Resolver<'a, TestContextCounted>> =
-                    Rc::new(CountedResolver { resolver });
-                Ok((src, delayed))
-            })
-            .add(1)
+impl<'a> Inject<'a, TestContextCounted> for CountedInject {
+    fn inject<A: 'a>(
+        &self,
+        fa: Wrapped<'a, TestContextCounted, A>,
+    ) -> Wrapped<'a, TestContextCounted, A> {
+        fa.add(1)
     }
 }
 
 pub trait Delayable<'a>: Mentionable<'a, TestContextCounted> + Sized {
-    fn delay(self: Rc<Self>) -> ParseResultA<'a, TestContextCounted, Self> {
-        let factory = self.factory();
-        TypelessMentionable::from_typed(self).cast_full(factory, CountedResolver::new)
+    fn delay(&self) -> ParseResultA<'a, TestContextCounted, Self> {
+        Rc::new(CountedInject).inject_mentionable(self)
     }
 }