utop[1]> type 'a mylist = Nil | C of 'a * 'a mylist;;
type 'a mylist = Nil | C of 'a * 'a mylist
utop[2]> let rec concat l1 l2 =
  match l1 with
    Nil -> l2
  | C(x, tl) -> C(x, concat tl l2);;
val concat : 'a mylist -> 'a mylist -> 'a mylist = <fun>
utop[3]> let rec make_list x n =
  if  n = 0 then
    Nil
  else
    C(x, make_list x (pred n));;
val make_list : 'a -> int -> 'a mylist = <fun>
utop[4]> make_list 3 5;;
- : int mylist = C (3, C (3, C (3, C (3, C (3, Nil)))))
utop[5]> let l1 = make_list 3 5;;
val l1 : int mylist = C (3, C (3, C (3, C (3, C (3, Nil)))))
utop[6]> let l2 = make_list 5 3;;
val l2 : int mylist = C (5, C (5, C (5, Nil)))
utop[7]> concat l1 l2;;
- : int mylist = C (3, C (3, C (3, C (3, C (3, C (5, C (5, C (5, Nil))))))))
utop[8]> let rec fact_aux n p =
  if n = 0 then p
  else fact_aux (pred n) (n * p);;
val fact_aux : int -> int -> int = <fun>
utop[9]> let fact n = fact_aux n 1;;
val fact : int -> int = <fun>
utop[10]> let fact n = 
  let rec aux n p =
    if n = 0 then p
    else aux (pred n) (n * p)
  in aux n 1;;
val fact : int -> int = <fun>
utop[11]> fact 10000;;
- : int = 0
utop[12]> fact 4;;
- : int = 24
utop[13]> let length_rt l =
  let rec aux l lg =
    match l with
      Nil -> lg
    | C(_, tl) -> aux tl (succ lg)
  in aux l 0;;
val length_rt : 'a mylist -> int = <fun>
utop[14]> length_rt l1;;
- : int = 5
utop[15]> length_rt l2;;
- : int = 3
utop[16]> let make_list_rt x n =
  let rec aux n l =
    if n = 0 then l
    else aux (pred n) (C (x,l));;
Error: Syntax error
utop[17]> let make_list_rt x n =
  let rec aux n l =
    if n = 0 then l
    else aux (pred n) (C (x,l))
  in aux n Nil;;
val make_list_rt : 'a -> int -> 'a mylist = <fun>
utop[18]> let reverse l =
  match l with
    Nil -> Nil
  | C(x, tl) -> concat (reverse tl) (C(x, Nil));;
Error: Unbound value reverse
Hint: If this is a recursive definition,
you should add the 'rec' keyword on line 1
utop[19]> let rec reverse l =
  match l with
    Nil -> Nil
  | C(x, tl) -> concat (reverse tl) (C(x, Nil));;
val reverse : 'a mylist -> 'a mylist = <fun>
utop[20]> let l = C(1, C(2, C(3, NIL)));;
Error: This variant expression is expected to have type int mylist
       There is no constructor NIL within type mylist
utop[21]> let l = C(1, C(2, C(3, Nil)));;
val l : int mylist = C (1, C (2, C (3, Nil)))
utop[22]> reverse l;;
- : int mylist = C (3, C (2, C (1, Nil)))
utop[23]> let reverse_rt l =
  let rec aux l rl =
    match l with
      Nil -> rl
    | C(x, tl) -> aux tl (C(x,rl));;
Error: Syntax error
utop[24]> let reverse_rt l =
  let rec aux l rl =
    match l with
      Nil -> rl
    | C(x, tl) -> aux tl (C(x,rl))
  in aux l Nil;;
val reverse_rt : 'a mylist -> 'a mylist = <fun>
utop[25]> let l make_list_let make_list_rt x n =
  let rec aux n l =
    if n = 0 then l
    else aux (pred n) (C (x,l))
  in aux n Nil;;
val l : 'a -> 'b -> 'c -> int -> 'c mylist = <fun>
utop[26]> let l = make_list_rt 1000;;
val l : int -> int mylist = <fun>
utop[27]> let l = make_list_rt 10;;
val l : int -> int mylist = <fun>
utop[28]> reverse l;;
Error: This expression has type int -> int mylist
       but an expression was expected of type 'a mylist
utop[29]> let l = make_list_rt 2 10;;
val l : int mylist =
  C (2, C (2, C (2, C (2, C (2, C (2, C (2, C (2, C (2, C (2, Nil))))))))))
utop[30]> reverse l;;
- : int mylist =
C (2, C (2, C (2, C (2, C (2, C (2, C (2, C (2, C (2, C (2, Nil))))))))))
utop[31]> let _ = reverse l;;
- : int mylist =
C (2, C (2, C (2, C (2, C (2, C (2, C (2, C (2, C (2, C (2, Nil))))))))))
utop[32]> let l = make_list_rt 2 10;;
val l : int mylist =
  C (2, C (2, C (2, C (2, C (2, C (2, C (2, C (2, C (2, C (2, Nil))))))))))
utop[35]> List.append;;
- : 'a list -> 'a list -> 'a list = <fun>
utop[36]> C(1, Nil)
;;
- : int mylist = C (1, Nil)
utop[37]> 1 :: [];;
- : int list = [1]
utop[38]> 2 :: 1 :: [];;
- : int list = [2; 1]
utop[39]> 3 :: 2 :: 1 :: [];;
- : int list = [3; 2; 1]
utop[40]> let l = 3 :: 2 :: 1 :: [];;
val l : int list = [3; 2; 1]
utop[41]> List.length l;;
- : int = 3
utop[42]> List.hd l;;
- : int = 3
utop[43]> List.tl l;;
- : int list = [2; 1]
utop[44]> [3;5;6;7];;
- : int list = [3; 5; 6; 7]
utop[45]> l;;
- : int list = [3; 2; 1]
utop[46]> 4 * 5 :: l;;
- : int list = [20; 3; 2; 1]
utop[47]> 4 :: (succ 3) :: [];;
- : int list = [4; 4]
utop[48]> [2 * 3; 4];;
- : int list = [6; 4]
utop[49]> List.append;;
- : 'a list -> 'a list -> 'a list = <fun>
utop[50]> (*) 4 5;;
Line 1, characters 0-3:
Warning 1 [comment-start]: this `(*' is the start of a comment.
Hint: Did you forget spaces when writing the infix operator `( * )'?
Error: Line 1, characters 0-3:
Error: Comment not terminated

utop[51]> ( * ) 4 5;;
- : int = 20
utop[52]> List.append l [3;4;5];;
- : int list = [3; 2; 1; 3; 4; 5]
utop[53]> l @ [3;4;5];;
- : int list = [3; 2; 1; 3; 4; 5]
utop[54]> let l3 = l @ [3;4;5];;
val l3 : int list = [3; 2; 1; 3; 4; 5]
utop[55]> List.mem;;
- : 'a -> 'a list -> bool = <fun>
utop[56]> List.mem 10 l3;;
- : bool = false
utop[57]> List.mem 5 l3;;
- : bool = true
utop[58]> List.sort;;
- : ('a -> 'a -> int) -> 'a list -> 'a list = <fun>
utop[59]> List.sort (fun x y = if x > y then 1 elif x < y then -1 else 0) l3;;
Error: Syntax error
utop[60]> List.sort (fun x y -> if x > y then 1 elif x < y then -1 else 0) l3;;
Error: Syntax error: ')' expected, the highlighted '(' might be unmatched
utop[61]> List.sort (fun x y -> if x > y then 1 elif x < y then (-1) else 0) l3;;;;
Error: Syntax error: ')' expected, the highlighted '(' might be unmatched
utop[62]> List.sort (fun x y -> if x > y then 1 else if x < y then -1 else 0) l3;;
- : int list = [1; 2; 3; 3; 4; 5]
utop[63]> List.sort (fun x y -> if x > y then 1 elif x < y then -1 else 0) l3;;
Error: Syntax error: ')' expected, the highlighted '(' might be unmatched
utop[64]> List.sort (fun x y -> if x > y then 1 else if x < y then -1 else 0) l3;;
- : int list = [1; 2; 3; 3; 4; 5]
utop[65]> List.sort;;
- : ('a -> 'a -> int) -> 'a list -> 'a list = <fun>
utop[66]> List.filter;;
- : ('a -> bool) -> 'a list -> 'a list = <fun>
utop[67]> List.filter (fun x -> x mod 2 = 0) l3;;
- : int list = [2; 4]
utop[68]> List.filter (fun x -> x < 3 = 0) l3;;
Error: This expression has type int but an expression was expected of type bool
utop[69]> List.filter (fun x -> x < 3) l3;;
- : int list = [2; 1]
utop[70]> l3;;
- : int list = [3; 2; 1; 3; 4; 5]
utop[71]> List.map;;
- : ('a -> 'b) -> 'a list -> 'b list = <fun>
utop[72]> List.map (fun x -> x * x) l3;;
- : int list = [9; 4; 1; 9; 16; 25]
utop[73]> List.find;;
- : ('a -> bool) -> 'a list -> 'a = <fun>
utop[74]> List.find (fun x -> x < 10) l3;;
- : int = 3
utop[75]> l3
;;
- : int list = [3; 2; 1; 3; 4; 5]
utop[76]> List.find (fun x -> x > 10) l3;;
Exception: Not_found.
utop[77]> List.find_all;;
- : ('a -> bool) -> 'a list -> 'a list = <fun>
utop[78]> List.find_all (fun x -> x > 10) l3;;
- : int list = []
utop[79]> List.find_all (fun x -> x < 5) l3;;
- : int list = [3; 2; 1; 3; 4]
utop[80]> List.assoc;;
- : 'a -> ('a * 'b) list -> 'b = <fun>
utop[81]> None;;
- : 'a option = None
utop[82]> Some 4;;
- : int option = Some 4
utop[83]> let rec find_if pred l =
  match l with
    [] -> None
  | e :: tl -> if pred e then Some e
               else find_if pred tl;;
val find_if : ('a -> bool) -> 'a list -> 'a option = <fun>
utop[84]> find_if (fun x -> x < 10) l3;;
- : int option = Some 3
utop[85]> find_if (fun x -> x > 10) l3;;
- : int option = None
utop[86]> type pair = P of int * int;;
type pair = P of int * int
utop[87]> let pair_cmp pair =
  let P(x,y) = pair in
  if x > y then 1 else if x < y then -1 else 0;;
val pair_cmp : pair -> int = <fun>
utop[88]> pair_cmp (P(2,3));;
- : int = -1
utop[89]> pair_cmp (P(3,2));;
- : int = 1
utop[90]> pair_cmp (P(3,3));;
- : int = 0
utop[91]> let pair_cmp pair =
  match pair with
    P(x,y) ->
    if x > y then 1 else if x < y then -1 else 0;;
val pair_cmp : pair -> int = <fun>
utop[92]> let pair_cmp pair =
  match pair with
    P(x,y) when x > y -> 1
  | P(x,y) when x < y -> -1
  | _ -> 0;;
val pair_cmp : pair -> int = <fun>
utop[93]>