Map the unwrapped computation using the given function.

runExceptT (mapExceptT f m) = f (runExceptT m)

This function maps one exception into another as proposed in the paper
"A semantics for imprecise exceptions".

The mapMaybe function is a version of map which can
throw out elements. In particular, the functional argument returns
something of type `Maybe b`. If this is Nothing,
no element is added on to the result list. If it is `Just
b`, then `b` is included in the result list.
**Examples**

Using `mapMaybe f x` is a shortcut for
`catMaybes $ map f x` in most cases:

>>> import Text.Read ( readMaybe ) >>> let readMaybeInt = readMaybe :: String -> Maybe Int >>> mapMaybe readMaybeInt ["1", "Foo", "3"] [1,3] >>> catMaybes $ map readMaybeInt ["1", "Foo", "3"] [1,3]If we map the Just constructor, the entire list should be returned:

>>> mapMaybe Just [1,2,3] [1,2,3]

The mapAndUnzipM function maps its first argument over a list,
returning the result as a pair of lists. This function is mainly used
with complicated data structures or a state monad.

Map a function over all the elements of a container and concatenate
the resulting lists.
**Examples**

Basic usage:

>>> concatMap (take 3) [[1..], [10..], [100..], [1000..]] [1,2,3,10,11,12,100,101,102,1000,1001,1002]

>>> concatMap (take 3) (Just [1..]) [1,2,3]

Map each element of the structure into a monoid, and combine the
results with `(<>)`. This fold is
right-associative and lazy in the accumulator. For strict
left-associative folds consider foldMap' instead.
**Examples**

Basic usage:
`(<>)` is lazy in its second
argument, foldMap can return a result even from an unbounded
structure. For example, lazy accumulation enables
Data.ByteString.Builder to efficiently serialise large data
structures and produce the output incrementally:

>>> foldMap Sum [1, 3, 5] Sum {getSum = 9}

>>> foldMap Product [1, 3, 5] Product {getProduct = 15}

>>> foldMap (replicate 3) [1, 2, 3] [1,1,1,2,2,2,3,3,3]When a Monoid's

>>> import qualified Data.ByteString.Lazy as L >>> import qualified Data.ByteString.Builder as B >>> let bld :: Int -> B.Builder; bld i = B.intDec i <> B.word8 0x20 >>> let lbs = B.toLazyByteString $ foldMap bld [0..] >>> L.take 64 lbs "0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24"

fmap is used to apply a function of type `(a -> b)`
to a value of type `f a`, where f is a functor, to produce a
value of type `f b`. Note that for any type constructor with
more than one parameter (e.g., `Either`), only the last type
parameter can be modified with fmap (e.g., `b` in
`Either a b`).
Some type constructors with two parameters or more have a
`Bifunctor` instance that allows both the last and the
penultimate parameters to be mapped over.
**Examples**

Convert from a `Maybe Int` to a `Maybe String`
using show:
`Either Int Int` to an `Either Int
String` using show:
`(a,b,c)` can also be written `(,,) a b c` and
its `Functor` instance is defined for `Functor ((,,) a
b)` (i.e., only the third parameter is free to be mapped over with
`fmap`).
It explains why `fmap` can be used with tuples containing
values of different types as in the following example:

>>> fmap show Nothing Nothing >>> fmap show (Just 3) Just "3"Convert from an

>>> fmap show (Left 17) Left 17 >>> fmap show (Right 17) Right "17"Double each element of a list:

>>> fmap (*2) [1,2,3] [2,4,6]Apply even to the second element of a pair:

>>> fmap even (2,2) (2,True)It may seem surprising that the function is only applied to the last element of the tuple compared to the list example above which applies it to every element in the list. To understand, remember that tuples are type constructors with multiple type parameters: a tuple of 3 elements

>>> fmap even ("hello", 1.0, 4) ("hello",1.0,True)

**Packages**- is:exact