# Lecture 4: Variant Types and Polymorphism

## Variant types

Lists are very useful, but it turns out they are not really as special as they look. We can implement our own lists, and other more interesting data structures, such as binary trees.

In recitation you should have seen some simple examples of variant types sometimes known as algebraic datatypes or just datatypes. Variant types provide some needed power: the ability to have a variable that contains more than one kind of value.

Unlike tuple types and function types, but like record types, variant types cannot be anonymous; they must be declared with their names. Suppose we wanted to have a variable that could contain one of three values: Yes, No, or Maybe, very much like an `enum` in Java. Its type could be declared as a variant type:

```# type answer = Yes | No | Maybe;;
type answer = Yes | No | Maybe
# let x : answer = Yes;;
val x : answer = Yes
```

The `type` keyword declares a name for the new type.  The variant type is declared with a set of constructors that describe the possible ways to make a value of that type. In this case, we have three constructors: `Yes`, `No`, and `Maybe`. Constructor names must start with an uppercase letter, and all other names in OCaml must start with a lowercase letter.

The different constructors can also carry other values with them. For example, suppose we want a type that can either be a 2D point or a 3D point. It can be declared as follows:

```type eitherPoint = TwoD of float * float
| ThreeD of float * float * float
```

Some examples of values of type `eitherPoint` are: `TwoD (2.1, 3.0)` and `ThreeD (1.0, 0.0, -1.0)`.

Suppose we have a value of type `eitherPoint`, which is either a `TwoD` of something or `ThreeD` of something. We need a way to extract the "something". This can be done with pattern matching. Example:

```let lastTwoComponents (p : eitherPoint) : float * float =
match p with
TwoD (x, y) -> (x, y)
| ThreeD (x, y, z) -> (y, z)
```

## Variant type syntax

We use X as a metavariable to represent the name of a constructor, and T to represent the name of a type. Optional syntactic elements are indicated by brackets [ ]. Then a variant type declaration looks like this in general:

`type` T = X1``` ```[`of `t1] | ... | Xn [`of `tn]

Variant types introduce new syntax for terms e, patterns p, and values v:

e ::= ... |  X e |  `match` e `with `p1` -> ` e1 | ... | pn` -> ` en
p ::=  X  |  X`(`x1 : t1, ...,  xn : tn`)`
v ::= c | (v1, ..., vn) | `fun` p` -> ` e | X v

Note that the vertical bars in the expression "`match` e `with `p1` -> `e| ... | pn` -> `en" are part the syntax of this construct; the other vertical bars (|) are part of the BNF notation.

We can use variant types to define many useful data structures.  In fact, the `bool` is really just a variant type with constructors named `true` and `false`.

## Implementing integer lists

We can write our own version of lists using variant types. Suppose we want to define values that act like linked lists of integers. A linked list is either empty, or it has an integer followed by another list containing the rest of the list elements. This leads to a very natural variant type declaration:

```type intlist = Nil | Cons of (int * intlist)
```

This type has two constructors, `Nil` and `Cons`. It is a recursive type because it mentions itself in its own definition (in the `Cons` constructor), just like a recursive function is one that mentions itself in its own definition.

Any list of integers can be represented by using this type. For example, the empty list is just the constructor `Nil`, and `Cons` corresponds to the operator `::`. Here are some examples of lists:

```let list1 = Nil                     (* the empty list: [] *)
let list2 = Cons (1, Nil)           (* the list containing just 1: [1] *)
let list3 = Cons (2, Cons (1, Nil)) (* the list [2; 1] *)
let list4 = Cons (2, list2)         (* also the list [2; 1] *)
(* the list [1; 2; 3; 4; 5] *)
let list5 = Cons (1, Cons (2, Cons (3, Cons (4, Cons (5, Nil)))))
(* the list [6; 7; 8; 9; 10] *)
let list6 = Cons (6, Cons (7, Cons (8, Cons (9, Cons (10, Nil)))))
```

So we can construct any lists we want. We can also take them apart using pattern matching. For example, our `length` function above can be written for `intlist`s by just translating the list patterns into the corresponding patterns using constructors.  Similarly, we can implement many other functions over lists, as shown in the following examples.

```(* An intlist is either Nil or Cons of an int and a (shorter) intlist *)
type intlist = Nil | Cons of int * intlist

(* Returns the length of lst *)
let rec length (lst : intlist) : int =
match lst with
| Nil -> 0
| Cons (h, t) -> length t + 1

(* is the list empty? *)
let is_empty (lst : intlist) : bool =
match lst with
| Nil -> true
| Cons _ -> false

(* Notice that the match expressions for lists all have the same
* form -- a case for the empty list (Nil) and a case for a Cons.
* Also notice that for most functions, the Cons case involves a
* recursive function call. *)

(* Return the sum of the elements in the list *)
let rec sum (lst : intlist) : int =
match lst with
| Nil -> 0
| Cons (i, t) -> i + sum t

(* Create a string representation of a list *)
let rec to_string (lst : intlist) : string =
match lst with
| Nil -> ""
| Cons (i, Nil) -> string_of_int i
| Cons (i, Cons (j, t)) ->
string_of_int i ^ "," ^ to_string (Cons (j, t))

(* Return the head (first element) of the list *)
let head (lst : intlist) : int =
match lst with
| Nil -> failwith "empty list"
| Cons (i, t) -> i

(* Return the tail (rest of the list after the head) *)
let tail (lst : intlist) : intlist =
match lst with
| Nil -> failwith "empty list"
| Cons (i, t) -> t

(* Return the last element of the list (if any) *)
let rec last (lst : intlist) : int =
match lst with
| Nil -> failwith "empty list"
| Cons (i, Nil) -> i
| Cons (i, t) -> last t

(* Return the nth element of the list (starting from 0) *)
let rec nth (lst : intlist) (n : int) : int =
match lst with
| Nil -> failwith "index out of bounds"
| Cons (i, t) ->
if n = 0 then i
else nth t (n - 1)

(* Append two lists:  append [1; 2; 3] [4; 5; 6] = [1; 2; 3; 4; 5; 6] *)
let rec append (l1 : intlist) (l2 : intlist) : intlist =
match l1 with
| Nil -> l2
| Cons (i, t) -> Cons (i, append t l2)

(* Reverse a list:  reverse [1; 2; 3] = [3; 2; 1].
* First reverse the tail of the list
* (e.g., compute reverse [2; 3] = [3; 2]), then
* append the singleton list [1] to the end to yield [3; 2; 1].
* This is not the most efficient method. *)
let rec reverse (lst : intlist) : intlist =
match lst with
| Nil -> Nil
| Cons (h, t) -> append (reverse t) (Cons (h , Nil))

(******************************
* Examples
******************************)

(* Here is a way to perform a function on each element
* of a list.  We apply the function recursively.
*)

let inc (x : int) : int = x + 1
let square (x : int) : int = x * x

(* Given [i1; i2; ...; in], return [i1+1; i2+1; ...; in+n] *)
let rec addone_to_all (lst : intlist) : intlist =
match lst with
| Nil -> Nil
| Cons (h, t) -> Cons (inc h, addone_to_all t)

(* Given [i1; i2; ...; in], return [i1*i1; i2*i2; ...; in*in] *)
let rec square_all (lst : intlist) : intlist =
match lst with
| Nil -> Nil
| Cons (h, t) -> Cons (square h, square_all t)

(* Here is a more general method. *)

(* Given a function f and [i1; ...; in], return [f i1; ...; f in].
* Notice how we factored out the common parts of addone_to_all
* and square_all. *)
let rec do_function_to_all (f : int -> int) (lst : intlist) : intlist =
match lst with
| Nil -> Nil
| Cons (h, t) -> Cons (f h, do_function_to_all f t)

let addone_to_all (lst : intlist) : intlist =
do_function_to_all inc lst

let square_all (lst : intlist) : intlist =
do_function_to_all square lst

(* Even better: use anonymous functions. *)

let addone_to_all (lst : intlist) : intlist =
do_function_to_all (fun x -> x + 1) lst

let square_all (lst : intlist) : intlist =
do_function_to_all (fun x -> x * x) lst

(* Equivalently, we can partially evaluate by applying
* do_function_to_all just to the first argument. *)

let addone_to_all : intlist -> intlist =
do_function_to_all (fun x -> x + 1)

let square_all : intlist -> intlist =
do_function_to_all (fun x -> x * x)

(* Say we want to compute the sum and product of integers
* in a list. *)

(* Explicit versions *)
let rec sum (lst : intlist) : int =
match lst with
| Nil -> 0
| Cons (i, t) -> i + sum t

let rec product (lst : intlist) : int =
match lst with
| Nil -> 1
| Cons (h, t) -> h * product t

(* Better: use a general function collapse that takes an
* operation and an identity element for that operation.
*)

(* Given f, b, and [i1; i2; ...; in], return f(i1, f(i2, ..., f (in, b))).
* Again, we factored out the common parts of sum and product. *)
let rec collapse (f : int -> int -> int) (b : int) (lst : intlist) : int =
match lst with
| Nil -> b
| Cons (h, t) -> f h (collapse f b t)

(* Now we can define sum and product in terms of collapse *)
let sum (lst : intlist) : int =
let add (i1 : int) (i2 : int) : int = i1 + i2 in

let product (lst : intlist) : int =
let mul (i1 : int) (i2 : int) : int = i1 * i2 in
collapse mul 1 lst

(* Here, we use anonymous functions instead of defining add and mul.
* After all, what's the point of giving those functions names if all
* we're going to do is pass them to collapse? *)
let sum (lst : intlist) : int =
collapse (fun i1 i2 -> i1 + i2) 0 lst

let product (lst : intlist) : int =
collapse (fun i1 i2 -> i1 * i2) 1 lst

(* Trees of integers *)

type inttree = Empty | Node of node
and node = { value : int; left : inttree; right : inttree }

(* Return true if the tree contains x. *)
let rec search (t : inttree) (x : int) : bool =
match t with
| Empty -> false
| Node {value=v; left=l; right=r} ->
v = x || search l x || search r x

let tree1 =
Node {value=2; left=Node {value=1; left=Empty; right=Empty};
right=Node {value=3; left=Empty; right=Empty}}

let z = search tree1 3
```

### Representing trees with a recursive type

Trees are another very useful data structure. Unlike lists, they are not built into OCaml. A binary tree is either

• the empty tree (no children), or
• a node containing a value and two children that are binary trees.
Just for variety, let's use a record type to represent a tree node. In OCaml we have to define two mutually recursive types, one to represent a tree node, and one to represent a (possibly empty) tree:
```type inttree = Empty | Node of node
and node = { value : int; left : inttree; right : inttree }
```

The rule for when mutually recursive type declarations are legal is a little tricky. Essentially, any cycle of recursive types must include at least one record or variant type. Since the cycle between `inttree` and `node` includes both kinds of types, this declaration is legal.

```  2
/ \        Node {value=2; left=Node {value=1; left=Empty; right=Empty};
1   3                      right=Node {value=3; left=Empty; right=Empty}}
```

Because there are several things stored in a tree node, it's helpful to use a record rather than a tuple to keep them all straight. But a tuple would also have worked.

We can use pattern matching to write the usual algorithms for recursively traversing trees. For example, here is a recursive search over the tree:

```(* Return true if the tree contains x. *)
let rec search ((t: inttree), (x:int)): bool =
match t with
Empty -> false
| Node {value=v; left=l; right=r} ->
v = x || search (l, x) || search (r, x)
```

Of course, if we knew the tree obeyed the binary search tree invariant, we could have written a more efficient algorithm.

### Representing natural numbers with a recursive type

We can even define data structures that act like numbers, demonstrating that we don't really have to have numbers built into OCaml either! A natural number is either the value zero or the successor of some other natural number. This definition leads naturally to the following definition for values that act like natural numbers `nat`:

```type nat = Zero | Next of nat
```

This is how you might define the natural numbers in a mathematical logic course. We have defined a new type `nat`, and `Zero` and `Next` are constructors for values of this type. The type `nat` is a recursive type, which allows us to build expressions that have an arbitrary number of nested `Next` constructors. Such values act like natural numbers:

```let zero = Zero
and one = Next Zero
and two = Next (Next Zero)
let three = Next two
let four = Next three
```

When we ask the interpreter what four represents, we get

```four;;
- : nat = Next (Next (Next (Next Zero)))
```

The equivalent Java definitions would be

```public interface nat { }
public class Zero implements nat {}
public class Next implements nat {
nat v;
Next(nat v) { v = this.v; }
}

nat zero = new Zero();
nat one = new Next(new Zero());
nat two = new Next(new Next(new Zero()));
nat three = new Next(two);
nat four = new Next(three);
```

And in fact the implementation is similar.

Now we can write functions to manipulate values of this type.

```let isZero (n : nat) : bool =
match n with
Zero -> true
| Next m -> false
```

Here we're pattern-matching a value with type `nat`. If the value is `Zero` we evaluate to `true`; otherwise we evaluate to `false`.

```let pred (n : nat) : nat =
match n with
Zero -> failwith "Zero has no predecessor"
| Next m -> m
```

Here we determine the predecessor of a number. If the value of `n` matches `Zero` then we raise an exception, since zero has no predecessor in the natural numbers. If the value matches `Next m` for some value `m` (which of course also must be of type `nat`), then we return `m`.

Similarly we can define a function to add two numbers:

```let rec add (n1 : nat) (n2 : nat) : nat =
match n1 with
Zero -> n2
| Next m -> add m (Next n2)
```

If you were to try evaluating `add four four`, the interpreter would respond with:

```add four four;;
- : nat = Next (Next (Next (Next (Next (Next (Next (Next Zero)))))))
```

which is the `nat` representation of 8.

To better understand the results of our computation, we would like to convert such values to type `int`:

```let rec toInt (n : nat) : int =
match n with
Zero -> 0
| Next n -> 1 + toInt n
```

That was pretty easy. Now we can write `toInt (add four four)` and get 8. How about the inverse operation?

```let rec toNat (i : int) : nat =
if i < 0 then failwith "toNat on negative number"
else if i = 0 then Zero
else Next (toNat (i - 1))
```

To determine whether a natural number is even or odd, we can write a pair of mutually recursive functions:

```let rec even (n : nat) : bool =
match n with
Zero -> true
| Next n -> odd n
and odd (n : nat) : bool =
match n with
Zero -> false
| Next n -> even n
```

You have to use the keyword `and` to combine mutually recursive functions like this. Otherwise the compiler would give an error when you refer to `odd` before it has been defined.

Finally we can define multiplication in terms of addition.

```let rec mul (n1 : nat) (n2 : nat) : nat =
match n1 with
Zero -> Zero
| Next m -> add n2 (mul m n2)
```

which gives

```toInt (mul (toNat 5) (toNat 20));;
- : int = 100
```

## Pattern matching

It turns out that the syntax of OCaml patterns is richer than what we saw in the last lecture. In addition to new kinds of terms for creating and projecting tuple and record values, and creating and examining variant type values, we also have the ability to match patterns against values to pull them apart into their parts.

When used properly, pattern matching leads to concise, clear code.  This is because  OCaml pattern matching allows one pattern to appear as a subexpression of another pattern. For example, we see above that `Next n` is a pattern, but so is `Next (Next n)`. This second pattern matches only on a value that has the form `Next (Next `v`)` for some value v (that is, the successor of the successor of something), and binds the variable `n` to that something, v.

Similarly, in our implementation of the `nth` function, earlier, a neat trick is to use pattern matching to do the `if n = 0` and the `match` at the same time. We pattern-match on the tuple `(lst, n)`:

```(* Returns the nth element of lst *)
let rec nth lst n =
match (lst, n) with
(h :: t, 0) -> h
| (h :: t, _) -> nth (t, n - 1)
| ([], _) -> failwith "nth applied to empty list"
```

Here, we've also added a clause to catch the empty list and raise an exception. We're also using the wildcard pattern `_` to match on the `n` component of the tuple, because we don't need to bind the value of `n` to another variable—we already have `n`. We can make this code even shorter; can you see how?

### Example: Pattern matching on records

All natural numbers are nonnegative, but we can simulate integers in terms of the naturals by using a representation consisting of a sign and magnitude:

```type sign = Pos | Neg
type integer = { sign : sign; mag : nat }
```

Here we've defined integer to refer to a record type with two fields: sign and mag. Remember that records are unordered, so there is no concept of a "first" field.

The declarations of `sign` and `integer` both create new types.  However, it is possible to write type declarations that simply introduce a new name for an existing type. For example, if we wrote `type number = int`, then the types `number` and `int` could be used interchangeably.

We can use the definition of `integer` to write some integers:

```let zero   = {sign=Pos; mag=Zero}
let zero'  = {sign=Neg; mag=Zero}
let one    = {sign=Pos; mag=Next Zero}
let negOne = {sign=Neg; mag=Next Zero}
```

Now we can write a function to determine the successor of any integer:

```let inc (i : integer) : integer =
match i with
{sign = _; mag = Zero} -> {sign = Pos; mag = Next Zero}
| {sign = Pos; mag = n} -> {sign = Pos; mag = Next n}
| {sign = Neg; mag = Next n} -> {sign = Neg; mag = n}
```

Here we're pattern-matching on a record type. Notice that in the third pattern we are doing pattern matching because the `mag` field is matched against a pattern itself, `Next n`. Remember that the patterns are tested in order. How does the meaning of this function change if the first two patterns are swapped?

The predecessor function is very similar, and it should be obvious that we could write functions to add, subtract, and multiply integers in this representation.

### OCaml syntax

Taking into account the ability to write complex patterns, we can now write down a more comprehensive syntax for OCaml.

syntactic class syntactic variables and grammar rule(s) examples
identifiers x y `a`, `x`, `y`, `x_y`, `foo1000`, ...
datatypes, datatype constructors X, Y `Nil`, `Cons``list`
constants c ...`~2`, `~1`, `0`, `1`, ` 2` (integers)
`1.0`, `~0.001`, ` 3.141` (floats)
`true`, ` false` (booleans)
``` "hello"```, ` ""`, ` "!"` (strings)
``` #"A"```,` #" " ` (characters)
unary operator u `~`, `not`, `size`, ...
binary operators b `+`, `*`, `-`, ` >`, ` <`, ` >=`, ` <=`, ` ^`, ...
expressions (terms) e ::-  x  |  u e  |  e1 b e2  | `if` e1 `then` e2 `else` e3  |  `let` d1...dn `in` e `end`  |  e `(`e1`,` ...`,` en`)`  ```| (```e1`,`...`,`en`)`  `| #`n e  |   `{`x1`=`e1`,` ...`,` xn`=`en`}`  ```| #```x e  |   X`(`e`)`  |  `match` e `with `p1`->`e1 | ... | pn`->`en `~0.001`, `foo`, `not` `b`,``` 2 + 2````Cons(2, Nil)`
patterns

p ::= x  |  `(`p1`,`...`,` pn`)`  |  `{`x1`=` p1`,`...`,`xn`=` pn`}`  |  X  |  X `(` p `)`

`a:int`, `(x:int,y:int), I(x:int)`
declarations d ::= `val` p = e  |  `fun` y p `:` t - e  |  `da``tatype` Y X1` `[`of `t1] `|` ... `|` X[```of ```tn] ```val one = 1 fun square(x: int):  int datatype d - N | I of int```
types t ::= `int`  |  `float`  |  `bool`  |  `string`  |  `char`  |  t1`->`t2  |  t1`*`...`*`tn  |  `{`x1:t1x2:t2,..., xn:tn`}`  |  Y `int`, `string`, `int->int`, `bool*int->bool`
values v ::= c  |  `(`v1`,`...`,`vn`)` |  `{`x1`=`v1`,` ...`,` xn`=`vn`}`  |  X`(`v`)` `2`, `(2,"hello")`, `Cons(2,Nil)`

Note: pattern-matching floating point constants is not possible. So in the production "p ::= | .." above, c is an integer, boolean, string, or character constant, but not float.

## Polymorphism

There is a nice feature that allows us to avoid rewriting the same code over and over so that it works for different types. Suppose we want to write a function that swaps the position of values in an ordered pair:

```let swapInt ((x : int), (y : int)) : int * int = (y, x)
and swapReal ((x : float), (y : float)) : float * float = (y, x)
and swapString ((x : string), (y : string)) : string * string = (y, x)
```
This is tedious, because we're writing exactly the same algorithm each time. It gets worse! What if the two pair elements have different types?
```let swapIntReal ((x : int), (y : float)) : float * int = (y, x)
and swapRealInt ((x : float), (y : int)) : int * float = (y, x)
```
And so on. There is a better way:
```# let swap ((x : 'a), (y : 'b)) : 'b * 'a = (y, x);;
val swap : 'a * 'b -> 'b * 'a = <fun>
```
Instead of writing explicit types for `x` and `y`, we write type variables `'a` and `'b`.  The type of ` swap` is `'a * 'b` `->` `'b * 'a`. This means that we can use swap as if it had any type that we could get by consistently replacing `'a` and `'b` in its type with a type for `'a` and a type for `'b`. We can use the new swap in place of all the old definitions:
```swap (1, 2)         (* (int * int) -> (int * int) *)
swap (3.14, 2.17)   (* (float * float) -> (float * float) *)
swap ("foo", "bar") (* (string * string) -> (string * string) *)
swap ("foo", 3.14)  (* (string * float) -> (float * string) *)
```

In fact, we can leave out the type declarations in the definition of `swap`, and OCaml will figure out the most general polymorphic type it can be given, automatically:

```# let swap (x, y) = (y, x);;
val swap : 'a * 'b -> 'b * 'a = <fun>
```

The ability to use swap as though it had many different types is known as polymorphism, from the Greek for "many forms".

Notice that the type variables must be substituted consistently in any use of a polymorphic expression. For example, it is impossible for `swap` to have the type `(int * float) -> (string * int)`, because that type would consistently substitute for the type variable `'a` but not for `'b`.

OCaml programmers typically read the types `'a` and `'b` as "alpha" and "beta". This is easier than saying "single quotation mark a" or "apostrophe a". They also they wish they could write Greek letters instead. A type variable may be any identifier preceded by a single quotation mark; for example, `'key` and `'value` are also legal type variables. The OCaml compiler needs to have these identifiers preceded by a single quotation mark so that it knows it is seeing a type variable.

It is important to note that to be polymorphic in a parameter `x`, a function may not use `x` in any way that would identify its type. It must treat `x` as a black box. Note that `swap` doesn't use its arguments `x` or `y` in any interesting way, but treats them as black boxes. When the OCaml type checker is checking the definition of `swap`, all it knows is that ` x` is of some arbitrary type `'a`. It doesn't allow any operation to be performed on `x` that couldn't be performed on an arbitrary type. This means that the code is guaranteed to work for any `x` and `y`. However, we can apply other polymorphic functions. For example,

```# let appendToString ((x : 'a), (s : string), (convert : 'a -> string)) : string =
(convert x) ^ " " ^ s;;
val appendToString : 'a * string * ('a -> string) -> string = <fun>
# appendToString (3110, "class", string_of_int);;
- : string = "3110 class"
# appendToString ("ten", "twelve", fun (s : string) -> s ^ " past");;
- : string = "ten past twelve"
```

## Parameterized Types

We can also define polymorphic datatypes. For example, we defined lists of integers as

`type intList = Nil | Cons of (int * intList)`
But we can make this more general by using a parameterized variant type instead:
`type 'a list_ = Nil | Cons of ('a * 'a list_)`

A parameterized datatype is a recipe for creating a family of related datatypes. The name `'a` is a type parameter for which any other type may be supplied. For example, `int list_` is a list of integers, `float list_` is a list of float, and so on. However, `list_` itself is not a type. Notice also that we cannot use `list_` to create a list each of whose elements can be any type. All of the elements of a ```T list_``` must be `T`'s.

```let il : int list_ = Cons (1, Cons (2, Cons (3, Nil)))  (* [1; 2; 3] *)
let fl : float list_ = Cons (3.14, Cons (2.17, Nil))    (* [3.14; 2.17] *)
let sl : string list_ = Cons ("foo", Cons ("bar", Nil)) (* ["foo"; "bar"] *)
let sil : (string * int) list_ =
Cons (("foo", 1), Cons (("bar", 2), Nil))  (* [("foo", 1); ("bar", 2)] *)
```

Notice `list_` itself is not a type. We can think of `list_` as a function that, when applied to a type like `int`, produces another type (`int` `list_`). It is a parameterized type constructor: a function that takes in parameters and gives back a type. Other languages have parameterized type constructors. For example, in Java you can declare a parameterized class:

```class List<T> {
List <T> tail;
...
}
```

In OCaml, we can define polymorphic functions that know how to manipulate any kind of list:

```(* polymorphic lists *)

type 'a list_ = Nil | Cons of 'a * 'a list_

(* is the list empty? *)
let is_empty (lst : 'a list_) : bool =
match lst with
| Nil-> true
| _ -> false

(* length of the list *)
let rec length (lst : 'a list_) : int =
match lst with
| Nil-> 0
| Cons (_, rest) -> 1 + length rest

(* append [a; b; c] [d; e; f] = [a; b; c; d; e; f] *)
let rec append (x : 'a list_) (y : 'a list_) : 'a list_ =
match x with
| Nil-> y
| Cons (h, t) -> Cons (h, append t y)

(* [1; 2; 3] *)
let il = Cons (1, Cons (2, Cons (3, Nil)))
let il2 = append il il
let il4 = append il2 il2
let il8 = append il4 il4
(* ["a"; "b"; "c"] *)
let sl = Cons ("a", Cons ("b", Cons ("c", Nil)))
let sl2 = append sl sl
let sl4 = append sl2 sl2

(* reverse the list:  reverse [1; 2; 3; 4] = [4; 3; 2; 1] *)
let rec reverse (x : 'a list_) : 'a list_ =
match x with
| Nil-> Nil
| Cons (h, t) -> append (reverse t) (Cons (h, Nil))

let il4r = reverse il4
let sl4r = reverse sl4

(* apply the function f to each element of x
* map f [a; b; c] = [f a; f b; f c] *)
let rec map (f : 'a -> 'b) (x : 'a list_) : 'b list_ =
match x with
| Nil-> Nil
| Cons (h, t) -> Cons (f h, map f t)

let mil4 = map string_of_int il4

(* insert sep between each element of x:
* separate s [a; b; c; d] = [a; s; b; s; c; s; d] *)
let rec separate (sep : 'a) (x : 'a list_) : 'a list_ =
match x with
| Nil-> Nil
| Cons (h, Nil) -> x
| Cons (h, t) -> Cons (h, Cons (sep, separate sep t))

let s0il4 = separate 0 il4
```
For trees,
```type 'a tree = Leaf | Node of ('a tree) * 'a * ('a tree)
```

If we use a record type for the nodes, the record type also must be parameterized, and instantiated on the same element type as the tree type:

```type 'a tree = Leaf | Node of 'a node
and 'a node = {left: 'a tree; value: 'a; right: 'a tree}
```

It is also possible to have multiple type parameters on a parameterized type, in which case parentheses are needed:

```type ('a, 'b) pair = {first: 'a; second: 'b};;
let x = {first=2; second="hello"};;
val x: (int, string) pair = {first = 2; second = "hello"}
```

## Abstract syntax and variant types

Earlier we noticed that there is a similarity between BNF declarations and variant type declarations. In fact, we can define variant types that act like the corresponding BNF declarations. The values of these variant types then represent legal expressions that can occur in the language. For example, consider a BNF definition of legal OCaml type expressions:

 (base types) b ::= `int` | `float` | `string` | `bool` | ```char ``` (types) t ::= b | t `->` t | t1 `*` t2 `*`...`*` tn | `{` x1 ` :` t1`;` ...`;` xn `:` tn `}` | X
``` ```This grammar has exactly the same structure as the following type declarations:
```type id = string
type baseType = Int | Real | String | Bool | Char
type mlType = Base of baseType | Arrow of mlType * mlType
| Product of mlType list | Record of (id * mlType) list
| DatatypeName of id
```

Any legal OCaml type expression can be represented by a value of type `mlType` that contains all the information of the corresponding type expression. This value is known as the abstract syntax for that expression. It is abstract because it doesn't contain any information about the actual symbols used to represent the expression in the program. For example, the abstract syntax for the expression `int * bool -> {name : string}` would be:

```Arrow (Product (Cons (Base Int, Cons (Base Bool, Nil))),
Record (Cons (("name", Base String), Nil)))
```

The abstract syntax would be exactly the same even for a more verbose version of the same type expression: `((int * bool) -> {name : string})`. Compilers typically use abstract syntax internally to represent the program that they are compiling. We will see a lot more abstract syntax later in the course when we see how OCaml works.