I don't know why this is, but of all the features of the OCaml language, somehow remembering how to make use of labeled or optional arguments is difficult for me. I find when I need to use them, I have to go back and "relearn" the syntax every time. For that reason, I've written these summary notes for myself (based mostly on Jacques Garrigue's "Labels and Variants" chapter of the OCaml reference) and I hope they might be of help you too!

### Labels

I've seen people write this function from time to time.let flip (f : 'a -> 'b -> 'c) = fun y x -> f x y

`flip`

applied to a function `f`

in two arguments, produces a new function that when presented reverses their order in the application of `f`

. For example, if `sub`

is defined by `let sub x y = x - y`

, then `sub 3 2`

will give the result *1* whereas `(flip sub) 3 2`

will produce the value *-1*.

The reason you'd find yourself wanting a function like `flip`

is because you want to partially apply `f`

but the argument you want to bind is inconveniently in the 'wrong' position. For example, the function that subtracts *2* from it's argument can be written `(flip sub 2)`

(whereas `sub 2`

is the function that subtracts its argument from *2*).

Labeled arguments do away with the need for functions like `flip`

. You see, arguments in function types can be annotated.

val sub : (x:int) -> (y:int) -> intIn the above,

`x`

and `y`

are *labels*. When you define a function with labeled arguments, you prefix the labels with a tilde

`~`

.
let sub : (x:int -> y:int -> int) = fun ~x ~y -> x - y

Labels and variables are not the same things. A label is a name associated with a variable e.g. ```
let u = 3 and v = 2 in sub ~x:u
~y:v
```

(`u`

, `v`

are variables `x`

, `y`

labels) and this also works when the variables are replaced with literals as in `sub ~x:3 ~y:2`

.

The expression `~x`

on it's own is shorthand for `~x:x`

which means that you can conveniently write `let x = 3 and y = 2 in sub ~x ~y`

for example. This is "punning" - meaning if the variable name and the label are the same, the variable name is permitted to be elided in the application.

Labels enable making function application commutative (changing the order of the arguments does not change the result); one can write `sub ~y ~x`

and that will yield the same result as `sub ~x ~y`

. Where this is useful of course is partial application of a function on any any argument. For example, we can create functions from `sub`

by binding either of `x`

or `y`

such as `sub ~x:3`

or `sub ~y:2`

without having to resort to ad-hoc trickery like `flip sub`

.

Some technical details:

- If more than one argument of a function has the same label (or no label), position prevails and they will not commute among themselves;
- If an application is total, labels can be omitted (e.g. like in
`sub 3 2`

). Be wary though - when a function is polymorphic in its return type, it will never be considered as totally applied. Consider for example ,`let app ~f ~x = f x`

. Then`app`

has type`f:('a -> 'b') -> x:'a -> 'b`

. Now we attempt total application but omit the required labels`app (fun x -> x) 1`

and this types to`f:('a -> ('b -> 'b) -> int -> 'c) -> x:'a -> 'c`

. You can see that the arguments have been "stacked up" in anticipation of presentation of`f`

and`x`

and the result although it types, is not at all what we were going for! - When a function is passed to a higher order function, labels must match in both types, labels may not be added or removed.

### Optional arguments

In a function type involving an optional argument, the annotation`?`

appears.
val range : ?step:int -> int -> int -> int listThe

`?`

appears again in the value syntax of a function definition involving an optional argument. Additionally, at that time, optional parameters can be given default values. When calling a function with a value for an optional parameter, well, you use the fact it is a labeled argument and provide a `~`

as normal.
let rec range ?(step:int = 1) (m : int) (n : int) : int list = if m >= n then [] else m :: (range ~step (m + step) n)

Now, this bit is important. A function can not take optional arguments alone. There must be some non-optional ones there too and it is when a non-optional parameter that comes after an optional one in the function type is encountered is it determined if the optional parameter has been omitted or not. For example, if we reorder the argument list as in the below, we find we can't 'erase' the optional argument anymore.

let rec range (m : int) (n : int) ?(step : int = 1): int list = ... Warning 16: this optional argument cannot be erased.That said, optional parameters may commute with non-optional or unlabeled ones, as long as they are applied simultaneously. That is, going back to this definition,

let rec range ?(step:int = 1) (m : int) (n : int) : int list = if m >= n then [] else m :: (range ~step (m + step) n)

`(range 0 ~step:2) 100`

is valid whereas, `(range 0) ~step:2 100`

is not.
Optional arguments are implemented as option types. In the event no default is given, you can treat them as exactly that by matching on `None`

or `Some x`

to switch behaviors. Here's a schematic of what that looks like.

let f ?s y = match s with | None -> ... | Some x -> ...

When you are just "passing through" an optional argument from one function call to another, you can prefix the applied argument with `?`

as in the following.

let g ?s x = ... let h ?s x = g ?s x (*[s] is passed through to [g]*)