CSCI 2041

Functions as values

Types we’ve seen so far, again:

Primitives:	`int`, `char`, `string`, `float`, `unit`, `bool`, …
Product:	`t1 * t2`, `{f1 : t1 ; f2 : t2}`
Union:	`'a list`, `'a option`, `boolExpr`
Function:	`t1 -> t2`

Programs in “functional” languages can create, pass and return functions as “first class” values

When would we use values of function type?

How do we construct values of function type?

Example: many searching tasks, such as

mem : 'a -> 'a list -> bool
find_all : 'a -> 'a list -> 'a list
assoc : 'a -> ('a * 'b) list -> 'b option

Require equality tests. But what makes two elements of type 'a equal?

find : ('a -> bool) -> 'a list -> bool
find_all : ('a -> bool) -> 'a list -> 'a list
assoc_by : ('a -> bool) -> ('a * 'b) list -> 'b option

How can we specify the function arguments?

From early history of computer science: λx → x+1

In Ocaml, fun param -> body:

find (fun x -> 3*x  < 17) l

find (fun a -> List.length a = 1) l

let mem x l = find ...

In the previous example, the function argument

(fun y -> x=y)

to find “remembers” what x was bound to in its scope.

Lambda expressions “capture” the bindings of names when they are defined

When a function references bindings from its enclosing scope but outside the scope of the call site it is called a “closure.”

let cmaker x =
  let y = x+7 in
    fun () -> y
let y = 3
let cl = cmaker 2
let now = cl () ;;

val cmaker : int -> unit -> int
val y : int = 3
val cl : unit -> int
val now : int = 9

Multi-argument functions in Ocaml are “curried”, e.g.:

(+) : int -> (int -> int)
(=) : 'a -> ('a -> bool)

“Partially” applying these functions creates new function values:

# (+) 2;;
- : int -> int

# (=) "The Doctor" ;;
- : string -> bool

Define mem in terms of find using partial application…

let compose f g x = f (g x)

OCaml has a built-in operator |> similar to compose:

let (|>) x f = f x

This can be used to build “chains” of functions:

fun x -> x |> f |> g |> h

Also useful is swap:

let swap f x y = f y x