Sequence actions, discarding the value of the first argument.

Examples

>>> Just 2 *> Just 3
Just 3

>>> Nothing *> Just 3
Nothing

>>> import Data.Char
>>> import Text.ParserCombinators.ReadP
>>> let p = string "my name is " *> munch1 isAlpha <* eof
>>> readP_to_S p "my name is Simon"
[("Simon","")]

Sequence actions, discarding the value of the second argument.

Sequential application.

A few functors support an implementation of <*> that is more efficient than the default one.

Example

>>> data MyState = MyState {arg1 :: Foo, arg2 :: Bar, arg3 :: Baz}

>>> produceFoo :: Applicative f => f Foo

>>> produceBar :: Applicative f => f Bar
>>> produceBaz :: Applicative f => f Baz

>>> mkState :: Applicative f => f MyState
>>> mkState = MyState <$> produceFoo <*> produceBar <*> produceBaz

A variant of <*> with the types of the arguments reversed. It differs from flip (<*>) in that the effects are resolved in the order the arguments are presented.

Examples

>>> (<**>) (print 1) (id <$ print 2)
1
2

>>> flip (<*>) (print 1) (id <$ print 2)
2
1

An associative binary operation

Right-to-left composition of Kleisli arrows. (>=>), with the arguments flipped.

Note how this operator resembles function composition (.):

(.)   ::            (b ->   c) -> (a ->   b) -> a ->   c
(<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c

Same as >>=, but with the arguments interchanged.

Left-to-right composition of Kleisli arrows.

'(bs >=> cs) a' can be understood as the do expression

do b <- bs a
   cs b

Sequentially compose two actions, discarding any value produced by the first, like sequencing operators (such as the semicolon) in imperative languages.

'as >> bs' can be understood as the do expression

do as
   bs

Sequentially compose two actions, passing any value produced by the first as an argument to the second.

'as >>= bs' can be understood as the do expression

do a <- as
   bs a

Bitwise "and"

Bitwise "or"

Boolean "and", lazy in the second argument

Boolean "or", lazy in the second argument

($) is the function application operator.

Applying ($) to a function f and an argument x gives the same result as applying f to x directly. The definition is akin to this:

($) :: (a -> b) -> a -> b
($) f x = f x

This is id specialized from a -> a to (a -> b) -> (a -> b) which by the associativity of (->) is the same as (a -> b) -> a -> b.

On the face of it, this may appear pointless! But it's actually one of the most useful and important operators in Haskell.

The order of operations is very different between ($) and normal function application. Normal function application has precedence 10 - higher than any operator - and associates to the left. So these two definitions are equivalent:

expr = min 5 1 + 5
expr = ((min 5) 1) + 5

($) has precedence 0 (the lowest) and associates to the right, so these are equivalent:

expr = min 5 $ 1 + 5
expr = (min 5) (1 + 5)

Examples

-- | Sum numbers in a string: strSum "100  5 -7" == 98
strSum :: String -> Int
strSum s = sum (mapMaybe readMaybe (words s))

-- | Sum numbers in a string: strSum "100  5 -7" == 98
strSum :: String -> Int
strSum s = sum $ mapMaybe readMaybe $ words s

applyFive :: [Int]
applyFive = map ($ 5) [(+1), (2^)]
>>> [6, 32]

Technical Remark (Representation Polymorphism)

fastMod :: Int -> Int -> Int
fastMod (I# x) (I# m) = I# $ remInt# x m

& is a reverse application operator. This provides notational convenience. Its precedence is one higher than that of the forward application operator $, which allows & to be nested in $.

This is a version of flip id, where id is specialized from a -> a to (a -> b) -> (a -> b) which by the associativity of (->) is (a -> b) -> a -> b. flipping this yields a -> (a -> b) -> b which is the type signature of &

Examples

>>> 5 & (+1) & show
"6"

>>> sqrt $ [1 / n^2 | n <- [1..1000]] & sum & (*6)
3.1406380562059946

Since: base-4.8.0.0

Right to left function composition.

(f . g) x = f (g x)

f . id = f = id . f

Examples

>>> map ((*2) . length) [[], [0, 1, 2], [0]]
[0,6,2]

>>> foldr (.) id [(+1), (*3), (^3)] 2
25

>>> let (...) = (.).(.) in ((*2)...(+)) 5 10
30

Flipped version of <$.

Examples

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

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

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

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

Since: base-4.7.0.0

Replace all locations in the input with the same value. The default definition is fmap . const, but this may be overridden with a more efficient version.

Examples

>>> 'a' <$ Just 2
Just 'a'
>>> 'a' <$ Nothing
Nothing

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

Replace all locations in the output with the same value. The default definition is contramap . const, but this may be overridden with a more efficient version.

This is an infix alias for contramap.

This is an infix version of contramap with the arguments flipped.

This is >$ with its arguments flipped.

Forms the ratio of two integral numbers.

An associative operation.

Examples

>>> [1,2,3] <> [4,5,6]
[1,2,3,4,5,6]

>>> Just [1, 2, 3] <> Just [4, 5, 6]
Just [1,2,3,4,5,6]

>>> putStr "Hello, " <> putStrLn "World!"
Hello, World!

Strict (call-by-value) application operator. It takes a function and an argument, evaluates the argument to weak head normal form (WHNF), then calls the function with that value.

Fractional division.

raise a number to a non-negative integral power

raise a number to an integral power