SharedFunctorAny

radn-derive/src/lib.rs

@@ -1,26 +1,26 @@
 use quote::quote;
 use syn::{parse_macro_input, parse_quote, DeriveInput, GenericParam, Generics};
 
-#[proc_macro_derive(SharedFunctor)]
+#[proc_macro_derive(SharedFunctorAny)]
 pub fn derive_shared_functor(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
     let input = parse_macro_input!(input as DeriveInput);
     let name = input.ident;
     let generics = add_clone_bounds(input.generics);
     let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
     let expanded = quote! {
-        impl #impl_generics SharedFunctor for #name #ty_generics #where_clause {
-            type Shared<'a, A: 'a + Clone> = Self::F<'a, A>
+        impl #impl_generics SharedFunctorAny for #name #ty_generics #where_clause {
+            type SharedAny<'a, A: 'a + Clone> = Self::F<'a, A>
             where
                 Self: 'a;
 
-            fn share<'a, A: 'a + Clone>(fa: Self::F<'a, A>) -> Self::Shared<'a, A>
+            fn share<'a, A: 'a + Clone>(fa: Self::F<'a, A>) -> Self::SharedAny<'a, A>
             where
                 Self: 'a,
             {
                 fa
             }
 
-            fn unshare<'a, A: 'a + Clone>(sa: Self::Shared<'a, A>) -> Self::F<'a, A>
+            fn unshare<'a, A: 'a + Clone>(sa: Self::SharedAny<'a, A>) -> Self::F<'a, A>
             where
                 Self: 'a,
             {

src/func.rs

@@ -21,7 +21,7 @@ pub mod tests;
 
 pub use std::ops::ControlFlow;
 
-pub use radn_derive::SharedFunctor;
+pub use radn_derive::SharedFunctorAny;
 
 pub use self::applicative_select::{
     ApplicativeSelect, ApplicativeSelectExt, Selected, SelectedWrapped,
@@ -268,24 +268,36 @@ pub trait MonadFailAnyExt<'a>: MonadFailAny<'a> {
 
 impl<'a, Fallible: ?Sized + MonadFailAny<'a>> MonadFailAnyExt<'a> for Fallible {}
 
-pub trait SharedFunctor: WeakFunctor {
-    type Shared<'a, A: 'a + Clone>: 'a + Clone
+pub trait SharedFunctorAny: WeakFunctor {
+    type SharedAny<'a, A: 'a + Clone>: 'a + Clone
     where
         Self: 'a;
 
-    fn share<'a, A: 'a + Clone>(fa: Self::F<'a, A>) -> Self::Shared<'a, A>
+    fn share<'a, A: 'a + Clone>(fa: Self::F<'a, A>) -> Self::SharedAny<'a, A>
     where
         Self: 'a;
 
-    fn unshare<'a, A: 'a + Clone>(sa: Self::Shared<'a, A>) -> Self::F<'a, A>
+    fn unshare<'a, A: 'a + Clone>(sa: Self::SharedAny<'a, A>) -> Self::F<'a, A>
     where
         Self: 'a;
 }
 
-pub trait SharedFunctorA<'a>: WeakFunctorA<'a> {
-    type SharedA<A: 'a + Clone>: 'a + Clone;
+pub trait SharedFunctor<'a>: WeakFunctorA<'a> {
+    type Shared<A: 'a + Clone>: 'a + Clone;
 
-    fn share<A: 'a + Clone>(fa: Self::Fa<A>) -> Self::SharedA<A>;
+    fn share<A: 'a + Clone>(fa: Self::Fa<A>) -> Self::Shared<A>;
 
-    fn unshare<A: 'a + Clone>(sa: Self::SharedA<A>) -> Self::Fa<A>;
+    fn unshare<A: 'a + Clone>(sa: Self::Shared<A>) -> Self::Fa<A>;
+}
+
+impl<'a, T: 'a + SharedFunctorAny> SharedFunctor<'a> for T {
+    type Shared<A: 'a + Clone> = T::SharedAny<'a, A>;
+
+    fn share<A: 'a + Clone>(fa: Self::Fa<A>) -> Self::Shared<A> {
+        T::share(fa)
+    }
+
+    fn unshare<A: 'a + Clone>(sa: Self::Shared<A>) -> Self::Fa<A> {
+        T::unshare(sa)
+    }
 }

src/func/instances/composition.rs

@@ -136,16 +136,16 @@ impl<'a, U: LocalFunctor<'a> + Functor<'a>, V: LocalFunctor<'a>> LocalFunctor<'a
     }
 }
 
-impl<'a, U: SharedFunctorA<'a> + Functor<'a>, V: SharedFunctorA<'a>> SharedFunctorA<'a>
+impl<'a, U: SharedFunctor<'a> + Functor<'a>, V: SharedFunctor<'a>> SharedFunctor<'a>
     for CompositionInstance<U, V>
 {
-    type SharedA<A: 'a + Clone> = U::SharedA<V::SharedA<A>>;
+    type Shared<A: 'a + Clone> = U::Shared<V::Shared<A>>;
 
-    fn share<A: 'a + Clone>(fa: Self::Fa<A>) -> Self::SharedA<A> {
+    fn share<A: 'a + Clone>(fa: Self::Fa<A>) -> Self::Shared<A> {
         U::share(U::fmap(V::share, fa))
     }
 
-    fn unshare<A: 'a + Clone>(sa: Self::SharedA<A>) -> Self::Fa<A> {
+    fn unshare<A: 'a + Clone>(sa: Self::Shared<A>) -> Self::Fa<A> {
         U::fmap(V::unshare, U::unshare(sa))
     }
 }

src/func/instances/effect.rs

@@ -23,7 +23,7 @@ impl<A, E: Effect> WithEffect<A, E> {
     }
 }
 
-#[derive(SharedFunctor)]
+#[derive(SharedFunctorAny)]
 pub struct EffectInstance<E>(E);
 
 impl<E> WeakFunctor for EffectInstance<E> {

src/func/instances/future.rs

@@ -107,14 +107,14 @@ impl<'a> Monad<'a> for FutureInstance {
     }
 }
 
-impl<'a> SharedFunctorA<'a> for FutureInstance {
-    type SharedA<A: 'a + Clone> = Shared<Pin<Box<dyn 'a + Future<Output = A>>>>;
+impl<'a> SharedFunctor<'a> for FutureInstance {
+    type Shared<A: 'a + Clone> = Shared<Pin<Box<dyn 'a + Future<Output = A>>>>;
 
-    fn share<A: 'a + Clone>(fa: Self::Fa<A>) -> Self::SharedA<A> {
+    fn share<A: 'a + Clone>(fa: Self::Fa<A>) -> Self::Shared<A> {
         fa.shared()
     }
 
-    fn unshare<A: 'a + Clone>(sa: Self::SharedA<A>) -> Self::Fa<A> {
+    fn unshare<A: 'a + Clone>(sa: Self::Shared<A>) -> Self::Fa<A> {
         Box::pin(sa)
     }
 }

src/func/instances/lazy.rs

@@ -103,14 +103,14 @@ fn unshare<'a, A: 'a + Clone>(shared: &mut Option<Box<dyn 'a + FnOnce() -> A>>)
     a
 }
 
-impl<'a> SharedFunctorA<'a> for LazyInstance {
-    type SharedA<A: 'a + Clone> = Rc<RefCell<Option<Box<dyn 'a + FnOnce() -> A>>>>;
+impl<'a> SharedFunctor<'a> for LazyInstance {
+    type Shared<A: 'a + Clone> = Rc<RefCell<Option<Box<dyn 'a + FnOnce() -> A>>>>;
 
-    fn share<A: 'a + Clone>(fa: Self::Fa<A>) -> Self::SharedA<A> {
+    fn share<A: 'a + Clone>(fa: Self::Fa<A>) -> Self::Shared<A> {
         Rc::new(RefCell::new(Some(fa)))
     }
 
-    fn unshare<A: 'a + Clone>(sa: Self::SharedA<A>) -> Self::Fa<A> {
+    fn unshare<A: 'a + Clone>(sa: Self::Shared<A>) -> Self::Fa<A> {
         Box::new(move || unshare(&mut *sa.borrow_mut()))
     }
 }

src/func/instances/option.rs

@@ -9,7 +9,7 @@
 
 use crate::func::*;
 
-#[derive(SharedFunctor)]
+#[derive(SharedFunctorAny)]
 pub struct OptionInstance;
 
 impl WeakFunctor for OptionInstance {

src/func/instances/overload.rs

@@ -194,16 +194,16 @@ impl<'a, Ex: 'a, Fallible: MonadFailAny<'a>> MonadFailAny<'a> for DeriveFailAny<
     }
 }
 
-impl<'a, T: SharedFunctorA<'a>, O: 'a + DeriveWeakFunctor> SharedFunctorA<'a>
+impl<'a, T: SharedFunctor<'a>, O: 'a + DeriveWeakFunctor> SharedFunctor<'a>
     for OverloadInstance<T, O>
 {
-    type SharedA<A: 'a + Clone> = T::SharedA<A>;
+    type Shared<A: 'a + Clone> = T::Shared<A>;
 
-    fn share<A: 'a + Clone>(fa: Self::Fa<A>) -> Self::SharedA<A> {
+    fn share<A: 'a + Clone>(fa: Self::Fa<A>) -> Self::Shared<A> {
         T::share(fa)
     }
 
-    fn unshare<A: 'a + Clone>(sa: Self::SharedA<A>) -> Self::Fa<A> {
+    fn unshare<A: 'a + Clone>(sa: Self::Shared<A>) -> Self::Fa<A> {
         T::unshare(sa)
     }
 }

src/func/instances/result.rs

@@ -9,7 +9,7 @@
 
 use crate::func::*;
 
-#[derive(SharedFunctor)]
+#[derive(SharedFunctorAny)]
 pub struct ResultInstance<E>(E);
 
 impl<E> WeakFunctor for ResultInstance<E> {

src/func/instances/solo.rs

@@ -4,7 +4,7 @@
 
 use crate::func::*;
 
-#[derive(SharedFunctor)]
+#[derive(SharedFunctorAny)]
 pub struct SoloInstance;
 
 impl WeakFunctor for SoloInstance {

src/func/instances/tryfuture.rs

@@ -104,14 +104,14 @@ impl<'a, E: 'a> Monad<'a> for TryFutureInstance<E> {
     }
 }
 
-impl<'a, E: 'a + Clone> SharedFunctorA<'a> for TryFutureInstance<E> {
-    type SharedA<A: 'a + Clone> = Shared<Pin<Box<dyn 'a + Future<Output = Result<A, E>>>>>;
+impl<'a, E: 'a + Clone> SharedFunctor<'a> for TryFutureInstance<E> {
+    type Shared<A: 'a + Clone> = Shared<Pin<Box<dyn 'a + Future<Output = Result<A, E>>>>>;
 
-    fn share<A: 'a + Clone>(fa: Self::Fa<A>) -> Self::SharedA<A> {
+    fn share<A: 'a + Clone>(fa: Self::Fa<A>) -> Self::Shared<A> {
         fa.shared()
     }
 
-    fn unshare<A: 'a + Clone>(sa: Self::SharedA<A>) -> Self::Fa<A> {
+    fn unshare<A: 'a + Clone>(sa: Self::Shared<A>) -> Self::Fa<A> {
         Box::pin(sa)
     }
 }