diff --git a/src/func.rs b/src/func.rs
index 98a6136..2db603e 100644
--- a/src/func.rs
+++ b/src/func.rs
@@ -15,7 +15,7 @@ pub trait CarriesType<T: WeakFunctor + ?Sized> {
 }
 
 /// Rust-specific implementation of [Functor], respecting `move` semantics.
-/// 
+///
 /// Cannot insantiate for e.g. multi-element collections:
 /// ```compile_fail
 /// use radn_rs::func::*;
@@ -32,8 +32,8 @@ pub trait CarriesType<T: WeakFunctor + ?Sized> {
 ///     }
 /// }
 /// ```
-/// Why does it fail to compile? `.map` expects `FnMut` (or we can think of it being `Fn`, doesn't matter here). But what we provide it (`f`) is 
-/// 
+/// Why does it fail to compile? `.map` expects `FnMut` (or we can think of it being `Fn`, doesn't matter here). But what we provide it (`f`) is
+///
 /// For Haskell-style Functors, use [clone_func::CloneFunctor] instead.
 /// ```
 /// use radn_rs::func::clone_func::*;
diff --git a/src/func/clone_func.rs b/src/func/clone_func.rs
index 6048e07..31bc5fb 100644
--- a/src/func/clone_func.rs
+++ b/src/func/clone_func.rs
@@ -1,11 +1,5 @@
-use crate::func::*;
-
 pub trait CloneWeakFunctor {
-    type ClF<'a, A: Clone>;
-}
-
-impl<T: WeakFunctor> CloneWeakFunctor for T {
-    type ClF<'a, A: Clone> = T::F<'a, A>;
+    type ClF<'a, A: Clone>: Clone;
 }
 
 pub trait CloneFunctor: CloneWeakFunctor {
@@ -26,26 +20,6 @@ pub trait CloneFunctor: CloneWeakFunctor {
     }
 }
 
-impl<T: Functor> CloneFunctor for T {
-    fn clone_fmap<'a, A: 'a + Clone, B: 'a + Clone, F: 'a + Fn(A) -> B>(
-        f: F,
-        fa: Self::ClF<'a, A>,
-    ) -> Self::ClF<'a, B> {
-        Self::fmap(f, fa)
-    }
-
-    fn clone_replace<'a, A: 'a + Clone, B: 'a + Clone>(
-        fa: Self::ClF<'a, A>,
-        b: B,
-    ) -> Self::ClF<'a, B> {
-        Self::replace(fa, b)
-    }
-
-    fn clone_void<'a, A: 'a + Clone>(fa: Self::ClF<'a, A>) -> Self::ClF<'a, ()> {
-        Self::void(fa)
-    }
-}
-
 pub trait CloneApplicativeSeq: CloneFunctor {
     fn clone_seq<'a, A: 'a + Clone, B: 'a + Clone, F: 'a + Clone + Fn(A) -> B>(
         ff: Self::ClF<'a, F>,
@@ -76,15 +50,6 @@ pub trait CloneApplicativeSeq: CloneFunctor {
     }
 }
 
-impl<T: ApplicativeSeq> CloneApplicativeSeq for T {
-    fn clone_seq<'a, A: 'a + Clone, B: 'a + Clone, F: 'a + Clone + Fn(A) -> B>(
-        ff: Self::ClF<'a, F>,
-        fa: Self::ClF<'a, A>,
-    ) -> Self::ClF<'a, B> {
-        Self::seq(ff, fa)
-    }
-}
-
 pub trait CloneApplicativeLA2: CloneFunctor {
     fn clone_la2<'a, A: 'a + Clone, B: 'a + Clone, C: 'a + Clone, F: 'a + Clone + Fn(A, B) -> C>(
         f: F,
@@ -100,16 +65,6 @@ pub trait CloneApplicativeLA2: CloneFunctor {
     }
 }
 
-impl<T: ApplicativeLA2> CloneApplicativeLA2 for T {
-    fn clone_la2<'a, A: 'a + Clone, B: 'a + Clone, C: 'a + Clone, F: 'a + Clone + Fn(A, B) -> C>(
-        f: F,
-        fa: Self::ClF<'a, A>,
-        fb: Self::ClF<'a, B>,
-    ) -> Self::ClF<'a, C> {
-        Self::la2(f, fa, fb)
-    }
-}
-
 pub trait CloneApplicative: CloneFunctor + CloneApplicativeSeq + CloneApplicativeLA2 {
     fn clone_pure<'a, A: 'a + Clone>(a: A) -> Self::ClF<'a, A>;
 
@@ -128,26 +83,6 @@ pub trait CloneApplicative: CloneFunctor + CloneApplicativeSeq + CloneApplicativ
     }
 }
 
-impl<T: Applicative> CloneApplicative for T {
-    fn clone_pure<'a, A: 'a + Clone>(a: A) -> Self::ClF<'a, A> {
-        Self::pure(a)
-    }
-
-    fn clone_discard_first<'a, A: 'a + Clone, B: 'a + Clone>(
-        fa: Self::ClF<'a, A>,
-        fb: Self::ClF<'a, B>,
-    ) -> Self::ClF<'a, B> {
-        Self::discard_first(fa, fb)
-    }
-
-    fn clone_discard_second<'a, A: 'a + Clone, B: 'a + Clone>(
-        fa: Self::ClF<'a, A>,
-        fb: Self::ClF<'a, B>,
-    ) -> Self::ClF<'a, A> {
-        Self::discard_second(fa, fb)
-    }
-}
-
 pub trait CloneMonad: CloneApplicative {
     fn clone_bind<'a, A: 'a + Clone, B: 'a + Clone, F: 'a + Clone + Fn(A) -> Self::ClF<'a, B>>(
         fa: Self::ClF<'a, A>,
@@ -156,25 +91,9 @@ pub trait CloneMonad: CloneApplicative {
 
     fn clone_join<'a, A: 'a + Clone>(ffa: Self::ClF<'a, Self::ClF<'a, A>>) -> Self::ClF<'a, A>
     where
-        Self::ClF<'a, A>: 'a + Clone,
+        Self::ClF<'a, A>: 'a,
     {
         // ugly
         Self::clone_bind(ffa, |fa| fa)
     }
 }
-
-impl<T: Monad> CloneMonad for T {
-    fn clone_bind<'a, A: 'a + Clone, B: 'a + Clone, F: 'a + Clone + Fn(A) -> Self::ClF<'a, B>>(
-        fa: Self::ClF<'a, A>,
-        f: F,
-    ) -> Self::ClF<'a, B> {
-        T::bind(fa, f)
-    }
-
-    fn clone_join<'a, A: 'a + Clone>(ffa: Self::ClF<'a, Self::ClF<'a, A>>) -> Self::ClF<'a, A>
-    where
-        Self::ClF<'a, A>: 'a + Clone,
-    {
-        T::join(ffa)
-    }
-}
diff --git a/src/func/copy_func.rs b/src/func/copy_func.rs
index d70aefa..a65c10f 100644
--- a/src/func/copy_func.rs
+++ b/src/func/copy_func.rs
@@ -1,11 +1,5 @@
-use crate::func::clone_func::*;
-
 pub trait CopyWeakFunctor {
-    type CF<'a, A: Copy>;
-}
-
-impl<T: CloneWeakFunctor> CopyWeakFunctor for T {
-    type CF<'a, A: Copy> = T::ClF<'a, A>;
+    type CF<'a, A: Copy>: Copy;
 }
 
 pub trait CopyFunctor: CopyWeakFunctor {
@@ -23,23 +17,6 @@ pub trait CopyFunctor: CopyWeakFunctor {
     }
 }
 
-impl<T: CloneFunctor> CopyFunctor for T {
-    fn copy_fmap<'a, A: 'a + Copy, B: 'a + Copy, F: 'a + Fn(A) -> B>(
-        f: F,
-        fa: Self::CF<'a, A>,
-    ) -> Self::CF<'a, B> {
-        Self::clone_fmap(f, fa)
-    }
-
-    fn copy_replace<'a, A: 'a + Copy, B: 'a + Copy>(fa: Self::CF<'a, A>, b: B) -> Self::CF<'a, B> {
-        Self::clone_replace(fa, b)
-    }
-
-    fn copy_void<'a, A: 'a + Copy>(fa: Self::CF<'a, A>) -> Self::CF<'a, ()> {
-        Self::clone_void(fa)
-    }
-}
-
 pub trait CopyApplicativeSeq: CopyFunctor {
     fn copy_seq<'a, A: 'a + Copy, B: 'a + Copy, F: 'a + Copy + Fn(A) -> B>(
         ff: Self::CF<'a, F>,
@@ -55,15 +32,6 @@ pub trait CopyApplicativeSeq: CopyFunctor {
     }
 }
 
-impl<T: CloneApplicativeSeq> CopyApplicativeSeq for T {
-    fn copy_seq<'a, A: 'a + Copy, B: 'a + Copy, F: 'a + Copy + Fn(A) -> B>(
-        ff: Self::CF<'a, F>,
-        fa: Self::CF<'a, A>,
-    ) -> Self::CF<'a, B> {
-        Self::clone_seq(ff, fa)
-    }
-}
-
 pub trait CopyApplicativeLA2: CopyFunctor {
     fn copy_la2<'a, A: 'a + Copy, B: 'a + Copy, C: 'a + Copy, F: 'a + Copy + Fn(A, B) -> C>(
         f: F,
@@ -79,16 +47,6 @@ pub trait CopyApplicativeLA2: CopyFunctor {
     }
 }
 
-impl<T: CloneApplicativeLA2> CopyApplicativeLA2 for T {
-    fn copy_la2<'a, A: 'a + Copy, B: 'a + Copy, C: 'a + Copy, F: 'a + Copy + Fn(A, B) -> C>(
-        f: F,
-        fa: Self::CF<'a, A>,
-        fb: Self::CF<'a, B>,
-    ) -> Self::CF<'a, C> {
-        Self::clone_la2(f, fa, fb)
-    }
-}
-
 pub trait CopyApplicative: CopyFunctor + CopyApplicativeSeq + CopyApplicativeLA2 {
     fn copy_pure<'a, A: 'a + Copy>(a: A) -> Self::CF<'a, A>;
 
@@ -107,26 +65,6 @@ pub trait CopyApplicative: CopyFunctor + CopyApplicativeSeq + CopyApplicativeLA2
     }
 }
 
-impl<T: CloneApplicative> CopyApplicative for T {
-    fn copy_pure<'a, A: 'a + Copy>(a: A) -> Self::CF<'a, A> {
-        Self::clone_pure(a)
-    }
-
-    fn copy_discard_first<'a, A: 'a + Copy, B: 'a + Copy>(
-        fa: Self::CF<'a, A>,
-        fb: Self::CF<'a, B>,
-    ) -> Self::CF<'a, B> {
-        Self::clone_discard_first(fa, fb)
-    }
-
-    fn copy_discard_second<'a, A: 'a + Copy, B: 'a + Copy>(
-        fa: Self::CF<'a, A>,
-        fb: Self::CF<'a, B>,
-    ) -> Self::CF<'a, A> {
-        Self::clone_discard_second(fa, fb)
-    }
-}
-
 pub trait CopyMonad: CopyApplicative {
     fn copy_bind<'a, A: 'a + Copy, B: 'a + Copy, F: 'a + Copy + Fn(A) -> Self::CF<'a, B>>(
         fa: Self::CF<'a, A>,
@@ -135,25 +73,9 @@ pub trait CopyMonad: CopyApplicative {
 
     fn copy_join<'a, A: 'a + Copy>(ffa: Self::CF<'a, Self::CF<'a, A>>) -> Self::CF<'a, A>
     where
-        Self::CF<'a, A>: 'a + Copy,
+        Self::CF<'a, A>: 'a,
     {
         // ugly
         Self::copy_bind(ffa, |fa| fa)
     }
 }
-
-impl<T: CloneMonad> CopyMonad for T {
-    fn copy_bind<'a, A: 'a + Copy, B: 'a + Copy, F: 'a + Copy + Fn(A) -> Self::CF<'a, B>>(
-        fa: Self::CF<'a, A>,
-        f: F,
-    ) -> Self::CF<'a, B> {
-        T::clone_bind(fa, f)
-    }
-
-    fn copy_join<'a, A: 'a + Copy>(ffa: Self::CF<'a, Self::CF<'a, A>>) -> Self::CF<'a, A>
-    where
-        Self::CF<'a, A>: 'a + Copy,
-    {
-        T::clone_join(ffa)
-    }
-}