Remove redundant deriving of Typeable.

Author: kukimik

docs/01_introduction.md

@@ -73,7 +73,7 @@ data LispVal
   | Fun IFunc
   | Lambda IFunc EnvCtx
   | Nil
-  | Bool Bool deriving (Typeable)
+  | Bool Bool deriving (Eq)
 
 data IFunc = IFunc { fn :: [LispVal] -> Eval LispVal }
 ```
@@ -95,7 +95,6 @@ To handle lexical scoping, the lambda function must enclose the environment pres
 Conceptually, the easiest way is to just bring the environment along with the function.
 For an implementation, the data constructor `Lambda` accepts  `EnvCtx`, which is the lexical environment, as well as `IFunc`, which is a Haskell function.
 You'll notice it takes its arguments as a list of `LispVal`, then returns an object of type `Eval LispVal`.  For more on `Eval`, read the next section.
-There's also a `deriving (Typeable)`, which is needed for error handling.  More on that later!
 
 ## Evaluation Monad
 (from [LispVal.hs](https://github.com/write-you-a-scheme-v2/scheme/tree/master/src/LispVal.hs))
@@ -116,7 +115,6 @@ newtype Eval a = Eval { unEval :: ReaderT EnvCtx IO a }
            , Applicative
            , MonadReader EnvCtx
            , MonadIO)
-
 ```
 
 For evaluation, we need to handle the context of a couple of things: the environment of variable/value bindings, exception handling, and IO.

src/LispVal.hs

@@ -1,4 +1,3 @@
-{-# LANGUAGE DeriveDataTypeable #-}
 {-# LANGUAGE GeneralizedNewtypeDeriving #-}
 
 module LispVal (
@@ -10,7 +9,6 @@ module LispVal (
   showVal,
 ) where
 
-import Data.Typeable (Typeable)
 import qualified Data.Text as T
 import qualified Data.Map as Map
 
@@ -28,7 +26,7 @@ data EnvCtx = EnvCtx
   } deriving (Eq)
 
 newtype Eval a = Eval { unEval :: ReaderT EnvCtx IO a }
-  deriving (Monad, Functor, Applicative, MonadReader EnvCtx,  MonadIO)
+  deriving (Monad, Functor, Applicative, MonadReader EnvCtx, MonadIO)
 
 data LispVal
   = Atom T.Text
@@ -39,13 +37,12 @@ data LispVal
   | Lambda IFunc EnvCtx
   | Nil
   | Bool Bool
-  deriving (Typeable,Eq)
+  deriving (Eq)
 
 instance Show LispVal where
   show = T.unpack . showVal
 
 data IFunc = IFunc { fn :: [LispVal] -> Eval LispVal }
-  deriving (Typeable)
 
 instance Eq IFunc where
  (==) _ _ = False
@@ -79,7 +76,6 @@ data LispException
   | Default LispVal
   | PError String -- from show anyway
   | IOError T.Text
-  deriving (Typeable)
 
 instance Exception LispException