09 Partial Application¶

You might not have ever seen this before!!

In [1]:

let add x y = x + y;;

Out[1]:

val add : int -> int -> int = <fun>

This is a pretty simple function, it adds two integers.

In [2]:

add 2;;

Out[2]:

- : int -> int = <fun>

Wait... what happened here? add 2 produces a <fun>, which has the argument 2 bound to it!

In [3]:

(add 2) 5;;

Out[3]:

- : int = 7

We can break this down to several steps to make it easier to understand!

In [4]:

let add_two = add 2;;

Out[4]:

val add_two : int -> int = <fun>

In [5]:

add_two 5;;

Out[5]:

- : int = 7

Wait why does that work? It's because Prof. Clarkson has been lying to us

Multi-argument functions don't exist.

fun x y -> e;;

is really just syntactic sugar for

fun x -> (fun y - e);;

Applied:

let add x y = x + y

is really syntactic sugar for

let add = fun x ->
    fun y ->
        x + y;;

This generalizes to any number of arguments.

This is really just a consequence of functions being values.

Functions can take functions as arguments
Functions can return functions as results

We're really just passing functions around.