let rec quicksort = function
 [] -> []
 | [x] -> [x]
 | xs -> let small = List.filter (fun y -> y < List.hd xs ) xs
 and large = List.filter (fun y -> y >= List.hd xs ) xs
 in quicksort small @ quicksort large;;

quicksort([8;4;6;5;6;7])

let rec quicksort' = function
 [] -> []
 | x::xs -> let small = List.filter (fun y -> y <= x ) xs
 and large = List.filter (fun y -> y >= x ) xs
 in quicksort' small @ (x :: quicksort' large);;

quicksort([6;2;1;1])

let f1 x = x 1 1;;

let f2 x y z = x ( y ^ z );;


Let f1 x = x 1 1;;
f1 jest powiedzmy typu a->b, (gdzie a to typ x)
x jest typu int->int->c
Ponieważ ciało f1 składa się tylko z wywołania x, ich efekt jest taki sam czyli b=c
Stąd f1: (int - int - c) - c, a ocaml zamieni nasze c na oznaczenie 'a.
Na polski: f1 to funkcjonał, który przyjmuje pewną funkcję int-int-c i wywołuje ją dla dwóch jedyne



 Let f2 x y z = x (y^z);;
Niech f2: a-b-c-d, natomiast x y z to kolejno a b c.
b=c=string, co wiemy z operacji ^ .
x: string - e
d=e, bo f2 to tylko wywołanie x (jak poprzednio)
Czyli f2: (string-d)-string -string - d = <fun>
Gdzie d będzie nazwane przez ocaml jako 'a