# OCaml Tutorial: List, Array, Tuple

## Lists

The syntax for list is

`[ `

`element_1` ; `element_2` ; `element_3` ; … ]

The last `;`

is optional.

All elements must be of the same type.

(* list syntax *) (* elements must all be the same type *) let x = [ 2; 8; 5; ];;

### list length

let x = [ 2; 8; 5; ];; List.length x;; (* ⇒ 3 *)

### list first, rest

let x = [ 2; 8; 5; ];; (* first element, called “head”. *) List.hd x;; (* ⇒ 2 *) (* rest elements, from 2nd to last, called “tail”. *) List.tl x;; (* ⇒ [8; 5] *)

The `List.hd`

is a form of calling the “hd” function from the module “List”.

A list allows you to efficiently grow the list, by adding to or removing the first element of the list. However, accessing nth element takes time proportional to n.

### Prepend List

→ prepends `x`::`list``x` to the front of list `list`

let x = [ 2; 8; 5; ];; (* prepending a element *) 4::x;; (* ⇒ [4; 2; 8; 5; ] *) (* prepending several elements *) 1::9::4::x;; (* ⇒ [1; 9; 4; 2; 8; 5] *)

The syntax

`[`

`a` ; `b` ; `c`]

is equivalent to

`a`::`b`::`c`

The operator `::`

is right-associative. So,

means
`a`::`b`::`c``a`::(`b`::`c`)

### Join Lists

2 lists can be joined by the operator `@`

.

(* join 2 lists *) [ 2; 8; 5; ] @ [ 3; 4; ]

The time to join 2 list is proportional to the number of items in first list.

## Array

Array is like a list of fixed length, and every element must be the same type.

The syntax for array is

`[| `

`element_1` ; `element_2` ; `element_3` ; … |]

(* array syntax. Elements must be same type *) let x = [| 2; 8; 3 |];;

### array get

Here's array element access.

(* array *) let x = [| 2; 8; 3 |];; (* getting a element *) print_int x.(1);; (* prints 8. Index starts at 0 *)

### array set

Here's how to change a slot's value.

(* array *) let x = [| 2; 8; 3 |];; (* changing array element *) x.(1) <- 9;; (* set 1st index element to 9 *)

### create array

(* creating array programmatically *) (* first arg is num of items, second is init value *) let x = Array.make 9 4;;

The difference between list and array is that you cannot add or remove items in array. However, getting and setting arbitrary elements in array is fast, while getting/setting arbitrary elements in list is slow.

## n-tuples

n-tuple is like array but the elements need not be the same type.

(* arbitrary n-tuple can be created *) let x = 3,4,8 ;; (* 3-tuple *) let y = 7.8, "abc", 4, 8;; (* 4-tuple *) (* when ambiguous, tuple needs to have parenthesis around *)

### get tuple element, pattern matching

use pattern matching to access tuple element.

(* pattern matching, to access tuple elements *) let (a,b,c) = 3,4,7;; print_int b;; (* 4 *)

## Nesting List-Like Things

List, array, tuple can be nested arbitrarily, but remember, for list and array, their elements must all have the same type.

(* nesting. Remeber, all elements must be same type. *) let x = [ [1;2]; [3;4;5]; [6;7] ];; (* list of lists *) let x = [ [|1;2|]; [|3;4;5|]; [|6;7|] ];; (* list of arrays *) let x = [ (1,2); (3,4); (5,6) ];; (* list of tuples *)

(* nested array examples *) let x = [| [|3; 4|]; [| 5; 6|] |] ;; (* array of arrays *) let x = [| [3; 4]; [ 5; 6] |] ;; (* array of lists *) let x = [| (3, "4"); (5, "7") |] ;; (* array of tuples *)

Note: when you have tuples as elements to list or array, each tuple must be the same type. That means, you cannot have tuples `(3,4)`

and `(3.1, 4)`

because the first is of type “int*int” and the second is “float*int”.

Note also the length of tuple must match. You cannot have elements `(3,4)`

and `(3,4,5)`

in a array or list. This is because, technically, `(3,4)`

is of type “int*int” but `(3,4,5)`

is of type “int*int*int”.

[| (3 , "4"); (3. , "4") |] ;; (* compiler error. *) [| (3 , "4"); (3 , "4", 5) |] ;; (* compiler error. *)

(* a tuple, with elements being int, list, tuple, array *) let x = (3, [4;5;6], (7,8), [| 9; 10 |]);;

Tuple is the most flexible about types.