Remove outdated explanation regarding Monad/Applicative class hierarchy (#149)

Signed-off-by: Xingye-Dujing <63134338+Xingye-Dujing@users.noreply.github.com>
Co-authored-by: Matthijs <19817960+MatthijsBlom@users.noreply.github.com>

Author: Xingye-Dujing

source_md/a-fistful-of-monads.md

@@ -208,7 +208,7 @@ Wow, who would have thought?
 This is what the type class looks like:
 
 ```{.haskell:hs}
-class Monad m where
+class Applicative m => Monad m where
     return :: a -> m a
 
     (>>=) :: m a -> (a -> m b) -> m b
@@ -222,13 +222,6 @@ class Monad m where
 
 ![this is you on monads](assets/images/a-fistful-of-monads/kid.png){.right width=363 height=451}
 
-Let's start with the first line.
-It says `class Monad m where`.
-But wait, didn't we say that monads are just beefed up applicative functors?
-Shouldn't there be a class constraint in there along the lines of `class (Applicative m) => Monad m where` so that a type has to be an applicative functor first before it can be made a monad?
-Well, there should, but when Haskell was made, it hadn't occurred to people that applicative functors are a good fit for Haskell so they weren't in there.
-But rest assured, every monad is an applicative functor, even if the `Monad` class declaration doesn't say so.
-
 The first function that the `Monad` type class defines is `return`.
 It's the same as `pure`, only with a different name.
 Its type is `(Monad m) => a -> m a`.

source_md/for-a-few-monads-more.md

@@ -1175,7 +1175,7 @@ Finally, we introduced monads as improved applicative functors, which added the
 
 So every monad is an applicative functor and every applicative functor is a functor.
 The `Applicative` type class has a class constraint such that our type has to be an instance of `Functor` before we can make it an instance of `Applicative`.
-But even though `Monad` should have the same constraint for `Applicative`, as every monad is an applicative functor, it doesn't, because the `Monad` type class was introduced to Haskell way before `Applicative`.
+Likewise, the `Monad` class enforces an `Applicative` constraint, ensuring every monad instance is strictly built upon an applicative functor instance.
 
 But even though every monad is a functor, we don't have to rely on it having a `Functor` instance because of the `liftM` function.
 `liftM` takes a function and a monadic value and maps it over the monadic value.