(* Exercice 1 *)
(* à tester vous-même *)
let _ = 3 + 4;;
- : int = 7
Let _ = 3. +. 4.;;
- : float = 7.
let _ = fun x -> x * x;;
- : int -> int = <fun>
let _ = fun x -> (x, x * x);;
- : int -> int * int = <fun>
let _ = fun x y -> 2 * x + 3 * y;;
- : int -> int -> int = <fun>
let _ = let f x y = 2 * x + 3 * y;;
val f : int -> int -> int = <fun>
let _ = f 2;;
- : int -> int = <fun>
let _ = f 2 3;;
- : int = 13

(* Exercice 2 *)
(* 9 *)    
let rec pgcd x y =
  if x = y then x
  else if x > y then pgcd (x - y) y
  else pgcd x (y - x)

(* 10 *)
let _ = pgcd;;
- : int -> int -> int = <fun>
  
(* Exercice 3 *)
(* 11 *)    
let rec sequence_from_i pred i n =
  if n = 0 then []
  else if pred i
  then
    i::(sequence_from_i pred (i + 1) (n - 1))
  else sequence_from_i pred (i + 1) n

let rec sequence_from_i pred i n =
  if n = 0 then Nil
  else if pred i
  then
    C(i, (sequence_from_i pred (i + 1) (n - 1)))
  else sequence_from_i pred (i + 1) n
		       
(* 12 *)
let _ = sequence_from_i;;
- : (int -> bool) -> int -> int -> int list = <fun>
  
(* 13 *)
let sequence pred n = sequence_from_i pred 0 n

(* 14 *)
let _ = sequence;;
- : (int -> bool) -> int -> int list = <fun>

(* Exercice 4 *)
(* 15 *)
let _ = i_evens;;
- : int -> bool = <fun>

(* 16 *)
let _ = i_member 3 i_empty;;
- : bool = false
let _ = i_member 2 i_evens;;
- : bool = true

(* 17 *)
let i_integers = fun i -> true

(* 18 *)
let multiple_of n = fun i -> i mod n = 0

(* 19 *)
let i_complement set = fun i -> not (i_member i set)

(* 20 *)
let i_intersection set1 set2 = fun i -> i_member i set1 && i_member i set2

(* 21 *)                                      
let i_sequence set n = sequence (fun i -> i_member i set) n

(* dans cette implémentation
let i_sequence set n = sequence set n
fonctionne aussi; mais ne sera plus valable si on change l'implémentation
*)