Re: Ha ouais, quand même...

Surtout que l'on parle du langage, ça n'empêche pas de faire une arithmétique loufoque dans une bibliothèque.

Dès qu'on a des fonctions polymorphes dans le langage, on peut faire une implémentation loufoque de l'arithmétique (mai l'arithmétique en question n'est pas loufoque). L'idée consiste à identifier un entier avec le principe de définition par récurrence (n x f = f (f ...(f x)), l'entier n applique n fois la fonction f à x) :

module N = struct
 type t = {n : 'a. 'a -> ('a -> 'a) -> 'a}
 let zero = {n = fun z _ -> z}
 let succ m = {n = fun z s -> m.n (s z) s}
 let fold {n} = n
 let rec nat = function 0 -> zero | n -> succ (nat (pred n))
 let int n = fold n 0 (fun x -> x + 1)
 let even n = fold n true not
 let odd n = fold n false not
 let add n m = fold m n succ (* n + m = n + 1 + ... + 1 *)
 let mul n m = fold m zero (add n) (* n * m = 0 + n + ... + n *)
 let exp n m = fold m (succ zero) (mul n) (* n ** m = 1 * n * ... * n *)
 let (+), ( * ), ( ** ) = add, mul, exp
end

à l'usage :

N.(even (nat 5));;
- : bool = false
N.(even (nat 4));;
- : bool = true
N.(int (nat 2 ** nat 8 + nat 5 * nat 2));;
- : int = 266
(* la suite de fibonnaci *)
let fibo n = fst N.(fold n (zero, nat 1) (fun (x, y) -> (y, x + y)));;
val fibo : N.t -> N.t = <fun>
N.(int (fibo (nat 10)));;
- : int = 55

:-)

Sapere aude ! Aie le courage de te servir de ton propre entendement. Voilà la devise des Lumières.