23;;

1 + 2 * 3;;

let square x = x * x;;

square 7;;

let rec fac n =
  if n = 1
  then 1
  else n * (fac (n - 1)) ;;

fac 5 ;;

1 < 2;;

2 < 1;;

false;;

true;;

'a';;

"Mike ist doof";;

(* # 'a' < 1;;
   File "tutorial-1.ml", line 28, characters 0-3:
   This expression has type char but is here used with type int *)

[1 ; 2 ; 3];;

(* # [1; 'a'; 2];;
   File "tutorial-1.ml", line 34, characters 4-7:
   This expression has type char but is here used with type int *)

1 :: [];;

1 :: [2 ; 3];;

let add a b = a + b;;

add 23 42;;

let add_7 = add 7;;

add_7 9;;

let compose f g = function x -> f (g x);;

let add_65 = compose (add 23) (add 42);;

add_65 0;;

(1, 2, 3);;

type 'label binary_tree =
    Empty_tree
  | Node of 'label * 'label binary_tree * 'label binary_tree;;

let t1 =
  Node ("Mike",
	Node ("Martin",
	      Empty_tree,
	      Node ("Christos", Empty_tree, Empty_tree)),
	Empty_tree);;

let rec count_nodes tree =
  match tree with
    Empty_tree -> 0
  | Node (label, left, right) ->
      1 + (count_nodes left) + (count_nodes right);;

count_nodes t1;;

type 'label search_tree =
    { tree : 'label binary_tree;
      equal : 'label -> 'label -> bool;
      less_than : 'label -> 'label -> bool;
    };;

let empty_search_tree equal less_than =
  { tree = Empty_tree;
    equal = equal;
    less_than = less_than;
  };; 

let rec search_tree_member element search_tree =
  let equal = search_tree.equal in
  let less_than = search_tree.less_than
  in
  let rec member tree =
    match tree with
      Empty_tree -> false
    | Node (label, left, right) ->
	if equal element label
	then true
	else
	  if less_than element label
	  then member left
	  else member right
  in
  member search_tree.tree;;

let rec search_tree_insert element search_tree =
  let equal = search_tree.equal in
  let less_than = search_tree.less_than
  in
  let rec insert tree =
    match tree with
      Empty_tree ->
	Node (element, Empty_tree, Empty_tree)
    | Node (label, left, right) ->
	if equal element label
	then tree
	else
	  if less_than element label
	  then Node (label, (insert left), right)
	  else Node (label, left, (insert right))
  in
  { tree = insert search_tree.tree;
    equal = equal;
    less_than = less_than;
  } ;;
	      
let make_account initial_balance =
  let balance_cell = ref initial_balance 
  in
  function amount ->
    begin
      balance_cell := !balance_cell - amount;
      !balance_cell;
    end;;

let a1 = make_account 90;;

a1 50;;

a1 20;;


type mutable_point =
    { mutable x: int;
      mutable y: int
    };;

let translate p dx dy =
  begin
    p.x <- p.x + dx;
    p.y <- p.y + dy;
  end;;
 
let mypoint = { x = 3; y = 4 };;
 
translate mypoint 1 2;;
 
mypoint;;

exception Empty_list;;
 
let car l =
  match l with
    [] -> raise Empty_list
  | hd :: tl -> hd;;
 
car [1; 2];;

(* #car [];;
   Uncaught exception: Empty_list. *)

let maybe_car l =
  try
    Some (car l)
  with Empty_list ->
    None;;