(* - On the couples *)

let first_element_couple = function (a,b) -> a;;
let second_element_couple = function (a,b) -> b;;

(* - On the functions *)

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

(* - On the lists *)

let rec generate_list = function 
    n when n < 0 -> []
  | n -> (generate_list (n-1))@[n];;

generate_list 5;;
generate_list (-1);;

let rec foldr = function f -> function z -> function
    [] -> z
  | a::l -> f a (foldr f z l);;

let rec foldl = function f -> function z -> function
    [] -> z
  | a::b -> foldl f (f a z) b;;

let cons = function a -> function l -> a::l;;

let map = function f -> function l -> foldr (compose cons f) [] l;;
map (function x -> 2 * x) [1;2;3];;

let invert = function l -> foldl cons [] l;;
invert [1;2;3];;

let length = function l -> foldr (function a -> function i -> 1 + i) 0 l;;
length [1;2;3;4];;

let append = function l1 -> function l2 -> foldr cons l2 l1;;
append [1;2;3;4] [5;6;7];;

let max_list = function
    [] -> failwith "An empty list has no max!"
  | a::l -> foldl max a l;;

let min_list = function
    [] -> failwith "An empty list has no min!"
  | a::l -> foldl min a l;;

let li = [1;4;8;2];;
max_list li;;
min_list li;;

let max_list_with_index = function l ->
  let iter = function 
      [] -> failwith "An empty list has no max!"
    | a::l -> foldl
	(function b -> function
	     (c1,c2,c3) when b > c1 -> (b,[c3],c3+1)
	   | (c1,c2,c3) when b = c1 -> (b,c3::c2, c3+1)
	   | (c1,c2,c3)             -> (c1,c2, c3+1)
	)
	  (a,[0],1) l
  in let (a,b,c) = iter l in (a,b);;

let min_list_with_index = function l ->
  let iter = function 
      [] -> failwith "An empty list has no min!"
    | a::l -> foldl
	(function b -> function
	     (c1,c2,c3) when b < c1 -> (b,[c3],c3+1)
	   | (c1,c2,c3) when b = c1 -> (b,c3::c2, c3+1)
	   | (c1,c2,c3)             -> (c1,c2, c3+1)
	)
	  (a,[0],1) l
  in let (a,b,c) = iter l in (a,b);;

let li = [1;8;4;8;2];;
max_list_with_index li;;
min_list_with_index li;;

let draw_randomly_an_element = function
    [] -> failwith "Cannot draw an element from an empty list !"
  | a::l -> foldl (function b -> function 
		       c when ((Random.float 1.0) < 0.5) -> b 
		     | c -> c) a l;;

let li = [1;8;2;3];;
draw_randomly_an_element li;;

let draw_randomly_a_position = function l -> Random.int (length l);;

let rec consume_with_rest = function p -> function l -> match (l,p) with
    (_, 0) -> ([],l)
  | ([], _) -> failwith "Not enough elements"
  | (a::r,_) -> let (l1,l2) = consume_with_rest (p-1) r in (a::l1,l2);;

consume_with_rest 2 [1;2;3;4;5;6];;

let consume = function p -> function l -> first_element_couple (consume_with_rest p l);;

consume 2 [1;2;3;4;5];;

let rec consume_spaced_with_rest = function n -> function p -> function l -> 
  match n with 
      0 -> ([],l)
    | 1 -> let (l1, rest) = consume_with_rest 1 l in (l1,rest)
    | _ -> let (l1,rest) = consume_with_rest 1 l in 
      let (l2,l3) = consume_with_rest (p-1) rest in 
      let (l4,l5) = consume_spaced_with_rest (n-1) p l3 in
	(l1@l4, l2@l5);;

consume_spaced_with_rest 2 5 [1;2;3;4;5;6] ;;

let consume_spaced = function n -> function p -> function l ->
  first_element_couple (consume_spaced_with_rest n p l);;

consume_spaced 2 5 [1;2;3;4;5;6] ;;

let rec arange_list = function p -> function l ->
  match l with 
      [] -> []
    | _ -> let (l1,rest) = consume_with_rest p l in l1::arange_list p rest;;

arange_list 3 [1;2;3;4;5;6];;

let rec arange_list_spaced = function n -> function p -> function l ->
  match l with 
      [] -> []
    | _ -> let (l1, rest) = consume_spaced_with_rest n p l in l1::(arange_list_spaced n (p-1) rest);;

arange_list_spaced 2 3 [1;2;3;4;5;6];;

let rec replace = function a -> function b -> function i -> function l ->
  match (i,l) with
    (_,[]) -> failwith "Element non trouvé"
  | (0,c::rest) when c=a -> b::rest
  | (_,c::rest) when c=a -> a::(replace a b (i-1) rest)
  | (_,c::rest) -> c::(replace a b i rest);;

replace "a" "e" 0 ["a";"b";"a"; "c"];;