apply, ‘$’#

Type signature:

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

It takes a function a from a to b, a parameter of type a, and returns something of the type b. Presumably, the given function turns a into b.

The implementation couldn’t be simpler. We take a function and some other value (could be another function, as functions are also values) and apply the function to the value:

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

And then we call it like this:

> apply identity 1

Or

> import Prelude ((/))

> apply (_ / 2.0) 5.0
2.5

> apply (2.0 / _) 5.0  
0.4

We partially-apply the / function through the use of sectioning. The result is a function that takes the remaining argument.

There is no real benefit in using apply like this. We mostly care about its infixr operation version, $. Let’s define it:

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

infixr 0 apply as $

Remember that 0 (zero) is the lowest possible precedence. Something of precedence 0 is evaluated last.

Using $ (dollar symbol) infixr apply operator#

We attempt this:

> import Effect.Console (log)

> log identity "hello"
... error ...

log takes a string, but we are passing it a function (identity). We need to parenthesize it like this:

> log (identity "hello")
hello

If we want to log a number, first convert it to a string (since log takes a string):

> import Prelude (show, identity)

> log (show (identity 1))
1

We can replace parentheses with $:

> log $ identity "hello"
hello

> log $ show $ identity 1
1

Because $ is infixr, it associates to the right, meaning it will first evaluate things on the right, passing the result those evaluations to the things on the left, which end up being evaluated last. This should help to illustrate:

log (identity "hello")
log $ identity "hello"

log (show (identity 1))
log $ show $ identity 1