Copyright | (c) The University of Glasgow 2001 |
---|---|

License | BSD-style (see the file libraries/base/LICENSE) |

Maintainer | libraries@haskell.org |

Stability | provisional |

Portability | portable |

Safe Haskell | Trustworthy |

Language | Haskell2010 |

A type `f`

is a Functor if it provides a function `fmap`

which, given any types `a`

and `b`

,
lets you apply any function of type `(a -> b)`

to turn an `f a`

into an `f b`

, preserving the
structure of `f`

.

#### Examples

`>>>`

Just "1" -- (Int -> String) -> Maybe Int -> Maybe String`fmap show (Just 1) -- (a -> b) -> f a -> f b`

`>>>`

Nothing -- (Int -> String) -> Maybe Int -> Maybe String`fmap show Nothing -- (a -> b) -> f a -> f b`

`>>>`

["1", "2", "3"] -- (Int -> String) -> [Int] -> [String]`fmap show [1,2,3] -- (a -> b) -> f a -> f b`

`>>>`

[] -- (Int -> String) -> [Int] -> [String]`fmap show [] -- (a -> b) -> f a -> f b`

The `fmap`

function is also available as the infix operator `<$>`

:

`>>>`

Just "1"`fmap show (Just 1) -- (Int -> String) -> Maybe Int -> Maybe String`

`>>>`

Just "1"`show <$> (Just 1) -- (Int -> String) -> Maybe Int -> Maybe String`

# Documentation

class Functor f where Source #

A type `f`

is a Functor if it provides a function `fmap`

which, given any types `a`

and `b`

lets you apply any function from `(a -> b)`

to turn an `f a`

into an `f b`

, preserving the
structure of `f`

. Furthermore `f`

needs to adhere to the following:

Note, that the second law follows from the free theorem of the type `fmap`

and
the first law, so you need only check that the former condition holds.

fmap :: (a -> b) -> f a -> f b Source #

Using `ApplicativeDo`

: '

' can be understood as
the `fmap`

f as`do`

expression

do a <- as pure (f a)

with an inferred `Functor`

constraint.

#### Instances

($>) :: Functor f => f a -> b -> f b infixl 4 Source #

Flipped version of `<$`

.

Using `ApplicativeDo`

: '`as `

' can be understood as the
`$>`

b`do`

expression

do as pure b

with an inferred `Functor`

constraint.

#### Examples

Replace the contents of a

with a constant
`Maybe`

`Int`

`String`

:

`>>>`

Nothing`Nothing $> "foo"`

`>>>`

Just "foo"`Just 90210 $> "foo"`

Replace the contents of an

with a constant `Either`

`Int`

`Int`

`String`

, resulting in an

:`Either`

`Int`

`String`

`>>>`

Left 8675309`Left 8675309 $> "foo"`

`>>>`

Right "foo"`Right 8675309 $> "foo"`

Replace each element of a list with a constant `String`

:

`>>>`

["foo","foo","foo"]`[1,2,3] $> "foo"`

Replace the second element of a pair with a constant `String`

:

`>>>`

(1,"foo")`(1,2) $> "foo"`

*Since: 4.7.0.0*

(<$>) :: Functor f => (a -> b) -> f a -> f b infixl 4 Source #

An infix synonym for `fmap`

.

The name of this operator is an allusion to `$`

.
Note the similarities between their types:

($) :: (a -> b) -> a -> b (<$>) :: Functor f => (a -> b) -> f a -> f b

Whereas `$`

is function application, `<$>`

is function
application lifted over a `Functor`

.

#### Examples

Convert from a

to a `Maybe`

`Int`

using `Maybe`

`String`

`show`

:

`>>>`

Nothing`show <$> Nothing`

`>>>`

Just "3"`show <$> Just 3`

Convert from an

to an
`Either`

`Int`

`Int`

`Either`

`Int`

`String`

using `show`

:

`>>>`

Left 17`show <$> Left 17`

`>>>`

Right "17"`show <$> Right 17`

Double each element of a list:

`>>>`

[2,4,6]`(*2) <$> [1,2,3]`

Apply `even`

to the second element of a pair:

`>>>`

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

void :: Functor f => f a -> f () Source #

discards or ignores the result of evaluation, such
as the return value of an `void`

value`IO`

action.

Using `ApplicativeDo`

: '

' can be understood as the
`void`

as`do`

expression

do as pure ()

with an inferred `Functor`

constraint.

#### Examples

Replace the contents of a

with unit:`Maybe`

`Int`

`>>>`

Nothing`void Nothing`

`>>>`

Just ()`void (Just 3)`

Replace the contents of an

with unit, resulting in an `Either`

`Int`

`Int`

:`Either`

`Int`

`()`

`>>>`

Left 8675309`void (Left 8675309)`

`>>>`

Right ()`void (Right 8675309)`

Replace every element of a list with unit:

`>>>`

[(),(),()]`void [1,2,3]`

Replace the second element of a pair with unit:

`>>>`

(1,())`void (1,2)`

Discard the result of an `IO`

action:

`>>>`

1 2 [(),()]`mapM print [1,2]`

`>>>`

1 2`void $ mapM print [1,2]`