Prelude> :t (.)
(.) :: (b -> c) -> (a -> b) -> a -> c
Prelude> (.) ((+) 5) ((*) 2) 4
13

194 {- | The ‘Functor‘ class is used for types that can be mapped over.
195 Instances of ‘Functor‘ should satisfy the following laws:
196 
197 > fmap id  ==  id
198 > fmap (f . g)  ==  fmap f . fmap g
199 
200 The instances of ‘Functor‘ for lists, ‘Data.Maybe.Maybe‘ and ‘System.IO.IO‘
201 satisfy these laws.
202 -}
203 
204 class  Functor f  where
205     fmap        :: (a -> b) -> f a -> f b
206 
207     -- | Replace all locations in the input with the same value.
208     -- The default definition is @‘fmap‘ . ‘const‘@, but this may be
209     -- overridden with a more efficient version.
210     (<$)        :: a -> f b -> f a
211     (<$)        =  fmap . const

Prelude> :t id
id :: a -> a
Prelude> id "Daniel"
"Daniel"
Prelude> id 1
1
Prelude> id True
True
Prelude> id Just "Happy"
Just "Happy"
Prelude> id Nothing
Nothing

Prelude Data.Char> fmap isDigit ((++) [‘0‘..‘9‘] [‘a‘..‘f‘])
[True,True,True,True,True,True,True,True,True,True,False,False,False,False,False,False]

Prelude Data.Char> :t isDigit
isDigit :: Char -> Bool

Prelude Data.Char> fmap isDigit (Just ‘a‘)
Just False
Prelude Data.Char> fmap isDigit (Nothing)
Nothing
Prelude Data.Char> fmap isDigit (Just ‘1‘)
Just True

Prelude Data.Char> :i Monad
class Monad m where
  (>>=) :: m a -> (a -> m b) -> m b
  (>>) :: m a -> m b -> m b
  return :: a -> m a
  fail :: String -> m a
  	-- Defined in `GHC.Base‘
instance Monad Maybe -- Defined in `Data.Maybe‘
instance Monad (Either e) -- Defined in `Data.Either‘
instance Monad [] -- Defined in `GHC.Base‘
instance Monad IO -- Defined in `GHC.Base‘
instance Monad ((->) r) -- Defined in `GHC.Base‘

Prelude Data.Char> :t (>>)
(>>) :: Monad m => m a -> m b -> m b
Prelude Data.Char> (>>) "Daniel" "King"
"KingKingKingKingKingKing"

212 
213 {- | The ‘Monad‘ class defines the basic operations over a /monad/,
214 a concept from a branch of mathematics known as /category theory/.
215 From the perspective of a Haskell programmer, however, it is best to
216 think of a monad as an /abstract datatype/ of actions.
217 Haskell‘s @do@ expressions provide a convenient syntax for writing
218 monadic expressions.
219 
220 Minimal complete definition: ‘>>=‘ and ‘return‘.
221 
222 Instances of ‘Monad‘ should satisfy the following laws:
223 
224 > return a >>= k  ==  k a
225 > m >>= return  ==  m
226 > m >>= (\x -> k x >>= h)  ==  (m >>= k) >>= h
227 
228 Instances of both ‘Monad‘ and ‘Functor‘ should additionally satisfy the law:
229 
230 > fmap f xs  ==  xs >>= return . f
231 
232 The instances of ‘Monad‘ for lists, ‘Data.Maybe.Maybe‘ and ‘System.IO.IO‘
233 defined in the "Prelude" satisfy these laws.
234 -}
235 
236 class  Monad m  where
237     -- | Sequentially compose two actions, passing any value produced
238     -- by the first as an argument to the second.
239     (>>=)       :: forall a b. m a -> (a -> m b) -> m b
240     -- | Sequentially compose two actions, discarding any value produced
241     -- by the first, like sequencing operators (such as the semicolon)
242     -- in imperative languages.
243     (>>)        :: forall a b. m a -> m b -> m b
244         -- Explicit for-alls so that we know what order to
245         -- give type arguments when desugaring
246 
247     -- | Inject a value into the monadic type.
248     return      :: a -> m a
249     -- | Fail with a message.  This operation is not part of the
250     -- mathematical definition of a monad, but is invoked on pattern-match
251     -- failure in a @do@ expression.
252     fail        :: String -> m a
253 
254     {-# INLINE (>>) #-}
255     m >> k      = m >>= \_ -> k
256     fail s      = error s

Prelude Data.Char> :t return
return :: Monad m => a -> m a
Prelude Data.Char> :t (>>=)
(>>=) :: Monad m => m a -> (a -> m b) -> m b
Prelude Data.Char> (>>=) (return ((++) "Daniel" "King")) ((:) ‘X‘)
"XDanielKing"

Prelude Data.Char> (>>=) (return ((++) "Daniel" "King")) ((++) "Hello ")
"Hello DanielKing"