(* ==============================================
   Cours 2 - Syntaxe OCaml : les fonctions anonymes
   ============================================== *)

(* -------------------------------------------------
   1. Syntaxe de base :  fun <params> -> <corps>
   ------------------------------------------------- *)

(* Carré d'un entier *)
let carre = fun x -> x * x

(* Test de parité *)
let pair = fun x -> x mod 2 = 0

(* Liste contenant un seul élément *)
let singleton = fun x -> [x]

(* Addition de deux entiers (fonction à plusieurs paramètres) *)
let addition = fun x y -> x + y

(* -------------------------------------------------
   2. Utilisation avec List.map et List.filter
   ------------------------------------------------- *)

let () =
  (* Élever chaque élément au carré *)
  let carres = List.map (fun x -> x * x) [1; 2; 3; 4; 5] in
  Printf.printf "map (x -> x*x) [1..5] = [%s]\n"
    (String.concat "; " (List.map string_of_int carres))

let () =
  (* Garder les nombres pairs *)
  let pairs = List.filter (fun x -> x mod 2 = 0) [1; 2; 3; 4; 5; 6] in
  Printf.printf "filter pair [1..6]    = [%s]\n"
    (String.concat "; " (List.map string_of_int pairs))

let () =
  (* Doubler chaque élément *)
  let doubles = List.map (fun x -> 2 * x) [1; 2; 3; 4] in
  Printf.printf "map (x -> 2*x) [1..4] = [%s]\n"
    (String.concat "; " (List.map string_of_int doubles))

(* -------------------------------------------------
   3. Fonctions qui retournent des fonctions
   ------------------------------------------------- *)

(* add : int -> int -> int   (une fonction qui prend x et retourne (fun y -> x + y)) *)
let add = fun x -> fun y -> x + y

(* compose : ('a -> 'b) -> ('c -> 'a) -> 'c -> 'b *)
let compose = fun f -> fun g -> fun x -> f (g x)

(* applique_deux_fois : ('a -> 'a) -> 'a -> 'a *)
let applique_deux_fois = fun f -> fun x -> f (f x)

let () =
  (* add 3 5 = 8 *)
  Printf.printf "add 3 5 = %d\n" (add 3 5)

let () =
  (* compose : (x -> x*x) puis (x -> x+1) appliqué à 3 = (3+1)^2 = 16 *)
  let f = compose (fun x -> x * x) (fun x -> x + 1) in
  Printf.printf "compose (x->x*x) (x->x+1) 3 = %d\n" (f 3)

let () =
  (* applique_deux_fois (x -> x*x) 3 = ((3^2)^2) = 81 *)
  Printf.printf "applique_deux_fois (x->x*x) 3 = %d\n"
    (applique_deux_fois (fun x -> x * x) 3)

(* -------------------------------------------------
   4. Retour sur add : sugar syntaxique
   ------------------------------------------------- *)

(* Les deux écritures sont strictement équivalentes : *)
let add1 = fun x -> fun y -> x + y
let add2 x y = x + y

let () =
  Printf.printf "add1 3 5 = %d, add2 3 5 = %d\n" (add1 3 5) (add2 3 5)

(* -------------------------------------------------
   5. Pattern matching dans une fonction anonyme
   ------------------------------------------------- *)

(* Tête d'une liste (None si vide) *)
let tete = fun lst ->
  match lst with
  | [] -> None
  | x :: _ -> Some x

(* Longueur d'une liste avec fun *)
let longueur = fun lst ->
  let rec aux n = function
    | [] -> n
    | _ :: xs -> aux (n + 1) xs
  in
  aux 0 lst

let () =
  Printf.printf "tete [1;2;3] = %s\n"
    (match tete [1; 2; 3] with Some n -> string_of_int n | None -> "None");
  Printf.printf "longueur [10;20;30] = %d\n" (longueur [10; 20; 30])