applyFlipped, ‘#’#

Type signature:

applyFlipped :: ∀ a b. a -> (a -> b) -> b

Compare with apply:

       apply :: ∀ a b. (a -> b) -> a -> b
applyFlipped :: ∀ a b. a -> (a -> b) -> b

Given the type signatures, it is clear that applyFlipped is really the flipped version of apply. Under the light of that piece of insight, one way to implement applyFlipped is in terms of apply.

applyFlipped :: ∀ a b. a -> (a -> b) -> b
applyFlipped = flip apply

By writing applyFlipped in terms of apply, we can make it point-free.

Or we can write it “manually”, without reusing apply:

applyFlipped :: ∀ a b. a -> (a -> b) -> b
applyFlipped x f = f x

This is how we would use it. Let’s compare with apply:

> apply show 1
"1"

> applyFlipped 1 show
"1"

We apply the show function to the value 1, or, using the flipped version, we first provide the value, then the function.

apply f to x or apply x to f

We have function application, not value application. By definition, it is correct to say that “we apply a function to a value”, and not that “we apply a value to a function”. Still, it is becoming more common to say or write both interchangeably. See my question about this on the PureScript Discord server.

> import Prelude (show, identity)

> apply show 1
"1"

> applyFlipped 1 show
"1"

> apply show (identity 1)
"1"

> applyFlipped (identity 1) show
"1"

Using ‘#’ (number/hash/pound symbol) infixl applyFlipped operator#

Whatever implementation we may chose for applyFlipped, we can write it as an infixl operator:

applyFlipped :: ∀ a b. a -> (a -> b) -> b
applyFlipped = flip apply

infixl 0 applyFlipped as #

Here too, as in apply, we need the precedence to be 0 (the lowest possible) so we first evaluate things on the left (infixl) and only then evalutate things on the right.

And some examples of its use (comparing with $/apply):

> import Effect.Console (log)
> import Prelude (identity, show)

> log $ show $ identity 1
1

> identity 1 # show # log
1

The # operator makes it more readable (at last to some people). In the book Functional Programming Made Easier, Charles Scalfani shows an example comparing $ and #:

f x $ step3 $ step2 $ step1 x
f x $ step1 # step2 # step3 x

Indeed, # (applyFlipped) does help with readability and reasoning about code in some situations.

If you have ever used Ramda, apply is like compose(), while applyFlipped is like pipe().