GHC.Internal.Data.Functor

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:

Identity

fmap id == id

Composition

fmap (f . g) == fmap f . fmap g

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. See these articles by School of Haskell or David Luposchainsky for an explanation.

Flipped version of <$.

Examples

Replace the contents of a Data.Maybe.Maybe Data.Int.Int with a constant Data.String.String:

>>> Nothing $> "foo"Nothing

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

Replace the contents of an Data.Either.Either Data.Int.Int Data.Int.Int with a constant Data.String.String, resulting in an Data.Either.Either Data.Int.Int Data.String.String:

>>> Left 8675309 $> "foo"Left 8675309

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

Replace each element of a list with a constant Data.String.String:

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

Replace the second element of a pair with a constant Data.String.String:

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

An infix synonym for fmap.

The name of this operator is an allusion to Prelude.$. Note the similarities between their types:

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

Whereas Prelude.$ is function application, <$> is function application lifted over a Functor.

Examples

Convert from a Data.Maybe.Maybe Data.Int.Int to a Data.Maybe.Maybe Data.String.String using Prelude.show:

>>> show <$> NothingNothing

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

Convert from an Data.Either.Either Data.Int.Int Data.Int.Int to an Data.Either.Either Data.Int.Int Data.String.String using Prelude.show:

>>> show <$> Left 17Left 17

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

Double each element of a list:

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

Apply Prelude.even to the second element of a pair:

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

Flipped version of <$>.

(<&>) = flip fmap

Examples

Apply (+1) to a list, a Data.Maybe.Just and a Data.Either.Right:

>>> Just 2 <&> (+1)Just 3

>>> [1,2,3] <&> (+1)[2,3,4]

>>> Right 3 <&> (+1)Right 4

Generalization of Data.List.unzip.

Examples

>>> unzip (Just ("Hello", "World"))(Just "Hello",Just "World")

>>> unzip [("I", "love"), ("really", "haskell")](["I","really"],["love","haskell"])

void value discards or ignores the result of evaluation, such as the return value of an System.IO.IO action.

Examples

Replace the contents of a Data.Maybe.Maybe Data.Int.Int with unit:

>>> void NothingNothing

>>> void (Just 3)Just ()

Replace the contents of an Data.Either.Either Data.Int.Int Data.Int.Int with unit, resulting in an Data.Either.Either Data.Int.Int ():

>>> void (Left 8675309)Left 8675309

>>> void (Right 8675309)Right ()

Replace every element of a list with unit:

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

Replace the second element of a pair with unit:

>>> void (1,2)(1,())

Discard the result of an System.IO.IO action:

>>> mapM print [1,2]12[(),()]

>>> void $ mapM print [1,2]12