:: a -> (a -> b) -> b -package:rio -package:ghc -package:vivid -package:ghc-prim

& 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 $.

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

Postfix function application, for conveniently applying attributes. Unlike ($), (#) has a high precedence (8), so d # foo # bar can be combined with other things using operators like (|||) or (<>) without needing parentheses.

Flipped version of ($).

Helper to make code using records of clients more readable. Can be mixed with (/:) for supplying arguments. Example:

type Api = NamedRoutes RootApi

data RootApi mode = RootApi
{ subApi :: mode :- NamedRoutes SubApi
, …
} deriving Generic

data SubApi mode = SubApi
{ endpoint :: mode :- Get '[JSON] Person
, …
} deriving Generic

api :: Proxy API
api = Proxy

rootClient :: RootApi (AsClientT ClientM)
rootClient = client api

endpointClient :: ClientM Person
endpointClient = client // subApi // endpoint

& is a reverse application operator

Reverse function application which binds tighter than <$> and <*>. Useful for refining grammar specification.

<*> monoidalFieldAla "extensions"           (alaList' FSep MQuoted)       oldExtensions
^^^ deprecatedSince [1,12] "Please use 'default-extensions' or 'other-extensions' fields."

Field access, inspired by the lens library. This is merely reverse application, but allows us to write things like (1, 2)^._1 which is likely to be familiar to most Haskell programmers out there. Note that this is precisely equivalent to _1 (1, 2), but perhaps it reads a little nicer.

Left-associative apply operator. Read as "apply forward" or "pipe into". Use this to create long chains of computation that suggest which direction things move in.

>>> 3 |> succ |> recip |> negate
-0.25

Or use it anywhere you would use (&).

\ x -> (x |> f) == f x

\ x -> (x |> f |> g) == g (f x)

Function application. This function usually isn't necessary, but it can be more readable than some alternatives when used with higher-order functions like map.

>>> map (apply 2) [succ, recip, negate]
[3.0,0.5,-2.0]

In general you should prefer using an explicit lambda or operator section.

>>> map (\ f -> 2 |> f) [succ, recip, negate]
[3.0,0.5,-2.0]

>>> map (2 |>) [succ, recip, negate]
[3.0,0.5,-2.0]

>>> map (<| 2) [succ, recip, negate]
[3.0,0.5,-2.0]

\ x -> apply x f == f x

Left-associative apply' operator. Read as "strict apply forward" or "strict pipe into". Use this to create long chains of computation that suggest which direction things move in.

>>> 3 !> succ !> recip !> negate
-0.25

The difference between this and (|>) is that this evaluates its argument before passing it to the function.

>>> undefined |> const True
True

>>> undefined !> const True
*** Exception: Prelude.undefined
...

\ x -> (x !> f) == seq x (f x)

\ x -> (x !> f !> g) == let y = seq x (f x) in seq y (g y)

Strict function application. This function usually isn't necessary, but it can be more readable than some alternatives when used with higher-order functions like map.

>>> map (apply' 2) [succ, recip, negate]
[3.0,0.5,-2.0]

The different between this and apply is that this evaluates its argument before passing it to the function.

>>> apply undefined (const True)
True

>>> apply' undefined (const True)
*** Exception: Prelude.undefined
...

In general you should prefer using an explicit lambda or operator section.

>>> map (\ f -> 2 !> f) [succ, recip, negate]
[3.0,0.5,-2.0]

>>> map (2 !>) [succ, recip, negate]
[3.0,0.5,-2.0]

>>> map (<! 2) [succ, recip, negate]
[3.0,0.5,-2.0]

\ x -> apply' x f == seq x (f x)

The #-operator is the Haskell analog to the .-operator in JavaScript. Example:

grd # addColorStop(0, "#8ED6FF");

This can be seen as equivalent of grd.addColorStop(0, "#8ED6FF").

Operator for postfix notation (same as Data.Function.(&))

>>> 255 .@hex
"0x0000_0000_0000_00ff"

>>> 0xf1 .@bin
"0b1111_0001"

>>> 2^12 .@dec
"4096"

>>> 4 * giga .@pos1
[32]

0x0 .@color (bits 31 24)
0b0000_0000_0000_0000_0000_0000_0000_0000_1111_1111_0000_0000_0000_0000_0000_0000
^^^^ ^^^^

Hang on function application, a.k.a. non-operator version of &.

onApp = (&)

postfix function application (flip ($))

A flipped version of ($).

An operator that allows you to write C-style ternary conditionals of the form:

p ? t ?? f

Note that parentheses are required in order to chain sequences of conditionals together. This is probably a good thing.

Application operator. This operator is redundant, since ordinary application (f x) means the same as (f $ x). However, $ has low, right-associative binding precedence, so it sometimes allows parentheses to be omitted; for example:

f $ g $ h x  =  f (g (h x))

It is also useful in higher-order situations, such as map ($ 0) xs, or zipWith ($) fs xs. Note that ($) is representation-polymorphic in its result type, so that foo $ True where foo :: Bool -> Int# is well-typed.

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.

Delay inlining a function until late in the game (simplifier phase 0).

Application operator. This operator is redundant, since ordinary application (f x) means the same as (f $ x). However, $ has low, right-associative binding precedence, so it sometimes allows parentheses to be omitted; for example:

f $ g $ h x  =  f (g (h x))

It is also useful in higher-order situations, such as map ($ 0) xs, or zipWith ($) fs xs. Note that ($) is levity-polymorphic in its result type, so that foo $ True where foo :: Bool -> Int# is well-typed.

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.