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

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

Maintainer | [email protected] |

Stability | provisional |

Portability | portable |

Safe Haskell | Trustworthy |

Language | Haskell2010 |

Functors: uniform action over a parameterized type, generalizing the
`map`

function on lists.

# Documentation

class Functor f where Source #

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, `Maybe`

and `IO`

satisfy these laws.

## Instances

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

Flipped version of `<$`

.

#### 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: base-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.

#### 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]`