**Packages**- is:exact

map `f xs` is the list obtained by
applying `f` to each element of `xs`, i.e.,

map f [x1, x2, ..., xn] == [f x1, f x2, ..., f xn] map f [x1, x2, ...] == [f x1, f x2, ...]

>>> map (+1) [1, 2, 3] [2,3,4]

Promote a function to a monad.

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)

An infix synonym for fmap.
The name of this operator is an allusion to $. Note the
similarities between their types:
**Examples**

Convert from a `Maybe Int` to a `Maybe
String` using show:
`Either Int Int` to an
`Either Int` String using show:

($) :: (a -> b) -> a -> b (<$>) :: Functor f => (a -> b) -> f a -> f bWhereas $ is function application, <$> is function application lifted over a Functor.

>>> show <$> Nothing Nothing >>> show <$> Just 3 Just "3"Convert from an

>>> show <$> Left 17 Left 17 >>> show <$> Right 17 Right "17"Double each element of a list:

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

>>> even <$> (2,2) (2,True)