content: \section[GHC.Base]{Module @GHC.Base@}
  
  simple lhs test
  
  -- to be found Monad
  
  Other Prelude modules are much easier with fewer complex dependencies.
  
  \begin{code}
  {- | The 'Functor' class is used for types that can be mapped over.
  Instances of 'Functor' should satisfy the following laws:
  
  > fmap id  ==  id
  > fmap (f . g)  ==  fmap f . fmap g
  
  The instances of 'Functor' for lists, 'Data.Maybe.Maybe' and 'System.IO.IO'
  satisfy these laws.
  -}
  
  class  Functor f  where
      fmap        :: (a -> b) -> f a -> f b
  
      -- | Replace all locations in the input with the same value.
      -- The default definition is @'fmap' . 'const'@, but this may be
      -- overridden with a more efficient version.
      (<$)        :: a -> f b -> f a
      (<$)        =  fmap . const
  
  {- | The 'Monad' class defines the basic operations over a /monad/,
  a concept from a branch of mathematics known as /category theory/.
  From the perspective of a Haskell programmer, however, it is best to
  think of a monad as an /abstract datatype/ of actions.
  Haskell's @do@ expressions provide a convenient syntax for writing
  monadic expressions.
  
  Minimal complete definition: '>>=' and 'return'.
  
  Instances of 'Monad' should satisfy the following laws:
  
  > return a >>= k  ==  k a
  > m >>= return  ==  m
  > m >>= (\x -> k x >>= h)  ==  (m >>= k) >>= h
  
  Instances of both 'Monad' and 'Functor' should additionally satisfy the law:
  
  > fmap f xs  ==  xs >>= return . f
  
  The instances of 'Monad' for lists, 'Data.Maybe.Maybe' and 'System.IO.IO'
  defined in the "Prelude" satisfy these laws.
  -}
  
  class  Monad m  where
      -- | Sequentially compose two actions, passing any value produced
      -- by the first as an argument to the second.
      (>>=)       :: forall a b. m a -> (a -> m b) -> m b
      -- | Sequentially compose two actions, discarding any value produced
      -- by the first, like sequencing operators (such as the semicolon)
      -- in imperative languages.
      (>>)        :: forall a b. m a -> m b -> m b
          -- Explicit for-alls so that we know what order to
          -- give type arguments when desugaring
  
      -- | Inject a value into the monadic type.
      return      :: a -> m a
      -- | Fail with a message.  This operation is not part of the
      -- mathematical definition of a monad, but is invoked on pattern-match
      -- failure in a @do@ expression.
      fail        :: String -> m a
  
      {-# INLINE (>>) #-}
      m >> k      = m >>= \_ -> k
      fail s      = error s
  
  instance Functor ((->) r) where
      fmap = (.)
  
  instance Monad ((->) r) where
      return = const
      f >>= k = \ r -> k (f r) r
  
  instance Functor ((,) a) where
      fmap f (x,y) = (x, f y)
  \end{code}
  
  