ocaml
        Objective Caml version 3.04

# let l 1 :: [];;
Toplevel input:
# let l 1 :: [];;
          ^^
Syntax error
# let l = 1 :: [];;
val l : int list = [1]
# let l2 = 1,2 :: [];;
val l2 : int * int list = 1, [2]
# let l2 = (1,2) :: [];;
val l2 : (int * int) list = [(1, 2)]
# type number = Int of int | Float of float;;
type number = Int of int | Float of float
# let rec addl = function
     h :: t ->
       (match h with
           Int i -> 0
         | Float x -> 1)
   | [] ->
       3;;
val addl : number list -> int = <fun>
# addl [Int 1; Float 2.0];;
- : int = 0
# type entry = { name : string; salary : float };;;
type entry = { name : string; salary : float; } 
# let jyh = { name = "Jason"; salary = 1 };;
Toplevel input:
# let jyh = { name = "Jason"; salary = 1 };;
                                       ^
This expression has type int but is here used with type float
# let jyh = { name = "Jason"; salary = 1.0 };;
val jyh : entry = {name = "Jason"; salary = 1}
# jyh.name;;
- : string = "Jason"
# jyh.salary ;;
- : float = 1
# let f ({ name = n; salary = x }) = n, x;;
val f : entry -> string * float = <fun>
# f jyh;;
- : string * float = "Jason", 1
# let f = function
  { name = "Jason" } -> 20000.0
  | { salary = x } -> x;;
val f : entry -> float = <fun>
# f jyh;;
- : float = 20000
# f { name = "Cristian"; salary = 1.0 };;
- : float = 1
# jyh.name <- "Jason2";;
Toplevel input:
# jyh.name <- "Jason2";;
  ^^^^^^^^^^^^^^^^^^^^
The record field label name is not mutable
# type entry =
  { name : string;
    mutable salary : float
  };;
type entry = { name : string; mutable salary : float; } 
# let jyh = { name = "Jason"; salary = 1.0 };;
val jyh : entry = {name = "Jason"; salary = 1}
# jyh.name <- "Jason2";;
Toplevel input:
# jyh.name <- "Jason2";;
  ^^^^^^^^^^^^^^^^^^^^
The record field label name is not mutable
# jyh.salary <- 10000000.0;;
- : unit = ()
# jyh;;
- : entry = {name = "Jason"; salary = 10000000}
# let flag = ref false;;
val flag : bool ref = {contents = false}
# flag := true;;
- : unit = ()
# flag;;
- : bool ref = {contents = true}
# !flag;;
- : bool = true
# flag := false;;
- : unit = ()
# !flag;;
- : bool = false
# if !flag then Printf.printf "Hello world\n";;
- : unit = ()
# flag := true;;
- : unit = ()
# if !flag then Printf.printf "Hello world\n";;
Hello world
- : unit = ()
# let a = [| 17; 56; 92 |];;
val a : int array = [|17; 56; 92|]
# a.(2);;
- : int = 92
# a.(2) <- 109;;
- : unit = ()
# a;;
- : int array = [|17; 56; 109|]
# let s = "Hello";;
val s : string = "Hello"
# s.[0];;
- : char = 'H'
# s.[0] <- 'Y';;
- : unit = ()
# s;;
- : string = "Yello"
# a.(2);;
- : int = 109
# s.(2);;
Toplevel input:
# s.(2);;
  ^
This expression has type string but is here used with type 'a array
# jyh;;
- : entry = {name = "Jason"; salary = 10000000}
# let f { name = name; salary = salary } =
  name;;
val f : entry -> string = <fun>
# type 'a option = Some of 'a | None;;
type 'a option = Some of 'a | None
# None;;
- : 'a option = None
# let l =  ref None;;
val l : '_a option ref = {contents = None}
# l;;
- : '_a option ref = {contents = None}
# (l : int option ref);;
- : int option ref = {contents = None}
# l;;
- : int option ref = {contents = None}
# let module X = struct int i = 1 end in X.i;;
Toplevel input:
# let module X = struct int i = 1 end in X.i;;
                        ^^^
Unbound value int
# let module X = struct let i = 1 end in X.i;;
- : int = 1
#