diff --git a/src/ch04/s01-alternatives.md b/src/ch04/s01-alternatives.md
index 29a200d..1b7ca91 100644
--- a/src/ch04/s01-alternatives.md
+++ b/src/ch04/s01-alternatives.md
@@ -9,17 +9,15 @@ without extra (sub)traits like `WeakFunctor`, `Pure`, `ApplicativeLA2`, etc. .
 trait Functor<'a>: 'a {
     type F<A: 'a>: 'a;
 
-    fn fmap<'a, A: 'a, B: 'a>(
-        f: impl 'a + FnOnce(A) -> B, fa: Self::F<'a, A>,
-    ) -> Self::F<'a, B>
-    where
-        Self: 'a;
+    fn fmap<A: 'a, B: 'a>(
+        fa: Self::F<A>, f: impl 'a + FnOnce(A) -> B,
+    ) -> Self::F<B>;
 }
 
-fn fmap<'a, T: 'a + Functor, A: 'a, B: 'a>(
+fn fmap<'a, T: Functor<'a>, A: 'a, B: 'a>(
     f: impl 'a + FnOnce(A) -> B,
-) -> impl FnOnce(T::F<'a, A>) -> T::F<'a, B> {
-    |fa| T::fmap(f, fa)
+) -> impl FnOnce(<T as Functor<'a>>::F<A>) -> <T as Functor<'a>>::F<B> {
+    |fa| T::fmap(fa, f)
 }
 ```
 
@@ -28,22 +26,18 @@ fn fmap<'a, T: 'a + Functor, A: 'a, B: 'a>(
 This is probably the closest representation to what Haskell views as a category of its types.
 
 ```rust
-trait Functor: Clone {
-    type F<'a, A: 'a + Clone>: 'a + Clone
-    where
-        Self: 'a;
+trait Functor<'a>: 'a + Clone {
+    type F<A: 'a + Clone>: 'a + Clone;
 
-    fn fmap<'a, A: 'a + Clone, B: 'a + Clone>(
-        f: impl 'a + Clone + Fn(A) -> B, fa: Self::F<'a, A>,
-    ) -> Self::F<'a, B>
-    where
-        Self: 'a;
+    fn fmap<A: 'a + Clone, B: 'a + Clone>(
+        fa: Self::F<A>, f: impl 'a + Clone + Fn(A) -> B,
+    ) -> Self::F<B>;
 }
 
-fn fmap<'a, T: 'a + Functor, A: 'a + Clone, B: 'a + Clone>(
+fn fmap<'a, T: Functor<'a>, A: 'a + Clone, B: 'a + Clone>(
     f: impl 'a + Clone + Fn(A) -> B,
-) -> impl 'a + Clone + Fn(T::F<'a, A>) -> T::F<'a, B> {
-    move |fa| T::fmap(f.clone(), fa)
+) -> impl 'a + Clone + Fn(<T as Functor<'a>>::F<A>) -> <T as Functor<'a>>::F<B> {
+    move |fa| T::fmap(fa, f.clone())
 }
 ```
 
@@ -57,16 +51,12 @@ We view use of `FnMut` for category's morphisms as somewhat controversial[^e].
 sequential application (`<*>` in Haskell, `seq` in RADN) *difficult*.
 
 ```rust
-trait Functor: Clone {
-    type F<'a, A: 'a + Clone>: 'a + Clone
-    where
-        Self: 'a;
+trait Functor<'a>: 'a + Clone {
+    type F<A: 'a + Clone>: 'a + Clone;
 
-    fn fmap<'a, A: 'a + Clone, B: 'a + Clone>(
-        f: impl 'a + FnMut(A) -> B, fa: Self::F<'a, A>,
-    ) -> Self::F<'a, B>
-    where
-        Self: 'a;
+    fn fmap<A: 'a + Clone, B: 'a + Clone>(
+        fa: Self::F<A>, f: impl 'a + FnMut(A) -> B,
+    ) -> Self::F<B>;
 }
 ```
 
@@ -75,21 +65,17 @@ trait Functor: Clone {
 ## `Copy`-`Fn` category functors
 
 ```rust
-trait Functor: Copy {
-    type F<'a, A: 'a + Copy>: 'a + Copy
-    where
-        Self: 'a;
+trait Functor<'a>: 'a + Copy {
+    type F<A: 'a + Copy>: 'a + Copy;
 
-    fn fmap<'a, A: 'a + Copy, B: 'a + Copy>(
-        f: impl 'a + Copy + Fn(A) -> B, fa: Self::F<'a, A>,
-    ) -> Self::F<'a, B>
-    where
-        Self: 'a;
+    fn fmap<A: 'a + Copy, B: 'a + Copy>(
+        fa: Self::F<A>, f: impl 'a + Copy + Fn(A) -> B,
+    ) -> Self::F<B>;
 }
 
-fn fmap<'a, T: 'a + Functor, A: 'a + Copy, B: 'a + Copy>(
+fn fmap<'a, T: Functor<'a>, A: 'a + Copy, B: 'a + Copy>(
     f: impl 'a + Copy + Fn(A) -> B,
-) -> impl 'a + Copy + Fn(T::F<'a, A>) -> T::F<'a, B> {
-    move |fa| T::fmap(f, fa)
+) -> impl 'a + Copy + Fn(<T as Functor<'a>>::F<A>) -> <T as Functor<'a>>::F<B> {
+    move |fa| T::fmap(fa, f)
 }
 ```