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

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

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

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

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

Flipped version of <$>.

(<&>) = flip fmap

Examples

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

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

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

Since: base-4.11.0.0

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

>>> fmap show Nothing
Nothing
>>> fmap show (Just 3)
Just "3"

>>> fmap show (Left 17)
Left 17
>>> fmap show (Right 17)
Right "17"

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

>>> fmap even (2,2)
(2,True)

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

Map with access to the index.

Non-infix version of (<&>).

Flipped version of imap.

A variant of <*> with the arguments reversed.

Non-infix version of (<*>).

Flipped version of apply. Non-infix version of (<**>).

Non-infix version of (>>=).

Indexed version of bind.

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

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

>>> 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"

Map each element of the structure to a semigroup, and combine the results.

>>> foldMap1 Sum (1 :| [2, 3, 4])
Sum {getSum = 10}

Since: base-4.18.0.0

foldMap through an Applicative functor.

foldMap1 through an Applicative functor.

Fold a container by mapping value to an arbitrary Monoid with access to the index i.

When you don't need access to the index then foldMap is more flexible in what it accepts.

foldMap ≡ ifoldMap . const

ifoldMap through an Applicative functor.

Flipped version of foldMap.

Flipped version of foldMap1.

Flipped version of foldMapA.

Flipped version of foldMapA1.

Flipped version of ifoldMap.

Flipped version of foldMapA.

A version of foldl' taking the accumulator first, then the Foldable.

A version of foldl1' taking the accumulator first, then the Foldable1.

A version of foldr taking the accumulator first, then the Foldable.

A version of foldr1 taking the accumulator first, then the Foldable.

Map each element of a structure to an action, evaluate these actions from left to right, and collect the results. For a version that ignores the results see traverse_.

Examples

>>> traverse Just [1,2,3,4]
Just [1,2,3,4]

>>> traverse id [Right 1, Right 2, Right 3, Right 4]
Right [1,2,3,4]

>>> traverse (const Nothing) [1,2,3,4]
Nothing

>>> traverse (\x -> if odd x then Just x else Nothing)  [1,2,3,4]
Nothing

>>> traverse id [Right 1, Right 2, Right 3, Right 4, Left 0]
Left 0

Traverse an indexed container.

itraverse ≡ itraverseOf itraversed

Traverse elements with access to the index i, discarding the results.

When you don't need access to the index then traverse_ is more flexible in what it accepts.

traverse_ l = itraverse . const

for is traverse with its arguments flipped. For a version that ignores the results see for_.

Traverse with an index (and the arguments flipped).

for a ≡ ifor a . const
ifor ≡ flip itraverse

Traverse elements with access to the index i, discarding the results (with the arguments flipped).

ifor_ ≡ flip itraverse_

When you don't need access to the index then for_ is more flexible in what it accepts.

for_ a ≡ ifor_ a . const

A version of maybe with the Maybe argument first.

Act on the empty or NonEmpty cases of a regular list.

An infix alias for mapMaybe. The name of the operator alludes to <$>, and has the same fixity.

Since: witherable-0.3.1

Flipped version of <$?>, the Filterable version of <&>. It has the same fixity as <&>.

(<&?>) = flip mapMaybe

Since: witherable-0.3.1

filter f . filter g ≡ filter (liftA2 (&&) g f)

ifilter f . ifilter g ≡ ifilter (i -> liftA2 (&&) (f i) (g i))

Flipped version of filter.

Flipped version of ifilter.

Like mapMaybe.

Flipped version of Filterable.

Flipped version of imapMaybe.

Flipped version of filterA.

Flipped version of ifilterA.

Effectful mapMaybe.

wither (pure . f) ≡ pure . mapMaybe f

Effectful imapMaybe.

iwither ( i -> pure . f i) ≡ pure . imapMaybe f

forMaybe = flip wither

Flipped version of iwither.