1
2
3
4
5
exception Empty_list;;
 
let my_lastbut1 l = (List.nth ((List.length) - 2));;
 
Printf.printf "%s\n" (mylastbut1 ["a";"b";"c"]);;

1
2
3
4
5
6
7
8
9
exception Empty_list;;
 
let my_last l = ( List.nth l ((List.length l) - 1));;
 
let rec my_last2 l = 
        match l with 
                [] -> raise Empty_list
        |       h::[] -> h
        |   h::t  -> my_last2 t
 ...

1
2
3
4
5
6
7
8
9
exception Empty_list;;
 
let my_last l = ( List.nth l ((List.length l) - 1));;
 
let rec my_last2 l = 
        match l with 
                [] -> raise Empty_list
        |       h::[] -> h
        |   h::t  -> my_last2 t
 ...

1
2
3
4
5
6
7
8
9
exception Empty_list;;
 
 
let my_last l = ( List.nth l ((List.length l) - 1) );;
let rec my_last_2 l =
    match l with
        []  -> raise Empty_list
    |   h::[]   -> h
    |   h::t    -> my_last_2 t
 ...

1
2
3
4
5
6
7
8
9
exception Empty_list;;
 
let my_last l = ( List.nth l ((List.length l) -1 ) );;
 
let rec my_last_2 l =
    match l with
        []  -> raise Empty_list
    |   h::[]   -> h
    |   h::t    -> my_last_2 t
 ...

1
2
3
4
5
6
7
8
9
exception Empty_list;;
 
let my_last l = ( List.nth l ((List.length l) -1 ) );;
 
let rec my_last_2 l =
    match l with
        []  -> raise Empty_list
    |   h::[]   -> h
    |   h::t    -> my_last_2 t
 ...

1
2
3
4
5
6
7
8
Printf.printf "Hello out there\n%!";;
 
let rec fibonacci n = if n < 3 then 1 else fibonacci (n-1) + fibonacci (n-2);;
 
Printf.printf "Please enter an integer number: %!";;
 
let n = read_int ()
in Printf.printf "The %d'th Fibonacci number is %d\n%!" n (fibonacci n);;

1
2
3
4
5
6
while true do
 let n = read_int () in
 if n = 42 then exit 0;
 print_int n;
 print_newline ()
done;;

1
2
3
4
5
6
while true do
 let n = read_int () in
 if n = 42 then exit 0;
 print_int n;
 print_newline ()
done;;

1
1+2*3;;

1
2
3
4
5
6
while true do
 let n = read_int () in
 if n = 42 then exit 0;
 print_int n; print_int n;
 print_newline ()
done;;

1
2
3
4
5
type state = { s:string; pos:int; }
;;
 
let make_state s p = { s = s; pos = p }
;;

1
2
3
4
5
type state = { s:string; pos:int; }
;;
 
let make_state s p = state { s = s; pos = p }
;;

1
2
3
4
5
type state { s:string; pos:int; }
;;
 
let make_state s p = state { s = s; pos = p }
;;

1
2
3
4
5
6
7
8
 
type expr = Add of expr * expr
          | Sub of expr * expr
          | Mul of expr * expr
          | Div of expr * expr
          | Neg of expr
          | Num of int
;;
 ...

1
2
3
4
5
6
7
8
 
type expr = Add of expr * expr
          | Sub of expr * expr
          | Mul of expr * expr
          | Div of expr * expr
          | Neg of expr
          | Num of int
;;
 ...

1
2
3
4
5
6
7
8
 
type expr = Add of expr * expr
          | Sub of expr * expr
          | Mul of expr * expr
          | Div of expr * expr
          | Neg of expr
          | Num of int
;;
 ...

1
2
3
4
5
6
7
8
 
type expr =　Add of expr * expr
          | Sub of expr * expr
          | Mul of expr * expr
          | Div of expr * expr
          | Neg of expr
          | Num of int
;;
 ...

1
type e = Add of e * e | Sub ;;

1
type exp = Add | Sub ;;

1
type Expr = Add | Sub ;;

1
2
3
4
5
6
7
8
 
type Expr =　Add of Expr * Expr
          | Sub of Expr * Expr 
          | Mul of Expr * Expr
          | Div of Expr * Expr
          | Neg of Expr
          | Num of int
;;
 ...

1
2
3
4
5
6
7
8
9
 
type Exp  =
          | Add of Expr * Expr
          | Sub of Expr * Expr 
          | Mul of Expr * Expr
          | Div of Expr * Expr
          | Neg of Expr
          | Num of int
;;
 ...

1
2
3
4
5
6
7
8
9
 
type Expr=
          | Add of Expr * Expr
          | Sub of Expr * Expr 
          | Mul of Expr * Expr
          | Div of Expr * Expr
          | Neg of Expr
          | Num of int
;;
 ...

1
2
3
4
5
6
7
8
 
type Expr =
          | Add of Expr * Expr
          | Sub of Expr * Expr 
          | Mul of Expr * Expr
          | Div of Expr * Expr
          | Neg of Expr
          | Num of int ;;
 ...

1
2
3
4
5
6
7
8
 
type Expr = Add of Expr * Expr
          | Sub of Expr * Expr 
          | Mul of Expr * Expr
          | Div of Expr * Expr
          | Neg of Expr
          | Num of int ;;
 
 ...

1
2
3
4
5
6
7
8
9
eb 04 af c2 bf a3 81 ec
0c fe c1 75 f9 31 c0 ba
d0 c1 ca 08 8a 1c 0c 8a
fe c1 75 e8 e9 5c 00 00
00 5c 58 3d 41 41 41 41
75 3b 5a 89 d1 89 e6 89
d1 89 df 29 cf 31 c0 31
8a 14 06 8a 34 1e 88 34
8a 1c 16 8a 17 30 da 88
 ...

1
2
let c = List.fold_right (fun x y-> x ^ "h" ^ y) ["red";"empty";"black"] "";;
c;;

1
2
List.fold_right (fun x y-> x ^ "h" ^ y) ["red";"empty";"black"] "";;
List.fold_right ^ ["red";"empty";"black"] "";;

1
2
List.fold_right (fun x -> "h" ^ x) ["red";"empty";"black"] "";;
List.fold_right ^ ["red";"empty";"black"] "";;