Re: Pourquoi ?

Tu es un peu dur, même si tu n'as pas complètement tort : on trouve des personnes qui présentent ainsi le langage à des non initiés, ce qui les fait fuir inéluctablement.

Pour les messages d'erreurs, je viens de faire dans mon toplevel :

# let f x = 1 + x;;
val f : int -> int = <fun>
# f "1";;
Error: This expression has type string but an expression was expected of type
 int

et le "1" est souligné pour indiquer qu'elle est l'expression qui n'a pas de le bon type.

Pour ce qui est de l'apprentissage, je conseille le livre de Sylvain Cochon et Jean-Christophe Filliâtre Apprendre à programmer en OCaml. Ils sont enseignants-chercheurs, et enseigne la programmation OCaml au niveau licence, donc sans tous les gros mots. ;-)

Le livre présente progressivement les concepts du langage et débute d'ailleurs par des traits purement impératifs comme les boucle for, les tableaux, les boucles while pour n'aborder qu'ensuite les spécificités du paradigme fonctionnel.

Les deux auteurs ont d'ailleurs une approche intéressante du paradigme fonctionnel qui consiste essentiellement dans la persistance des données. Ils ont, par exemple, publié ensemble un article A Persistent Union-Find Data Structure où ils exposent leur implémentation de l'algorithme union-find en utilisant des traits impératifs du langage, bien que la structure obtenue soit persistante. Là où un langage fonctionnelle pure, comme Haskell, aurait recours à des monades. Et dans leur livre il y a tout un chapitre, par exemple, où ils reprennent le concept de tableaux persistants, dont le code suit, en l'expliquant pas à pas :

type 'a t = 'a data ref
and 'a data =
 | Arr of 'a array 
 | Diff of int * 'a * 'a t
let init n f = ref (Arr (Array.init n f))
let rec reroot pa = match !pa with
 | Arr a -> 
 a
 | Diff (i, v, pa') -> 
 let a = reroot pa' in
 let old = a.(i) in
 a.(i) <- v;
 pa := Arr a;
 pa' := Diff (i, old, pa);
 a
let length pa = Array.length (reroot pa)
let get pa i = (reroot pa).(i)
let iteri f pa = Array.iteri f (reroot pa)
let set pa i v = 
 let a = reroot pa in
 let old = a.(i) in
 a.(i) <- v;
 let res = ref (Arr a) in
 pa := Diff (i, old, res);
 res

Les opérations set et get sont en temps constant tant que l'on n'utilise pas le côté persistant, mais on paye un léger prix lorsque l'on veut l'utiliser (il faut défaire les patch de la version courante pour revenir à la version que l'on souhaite manipuler, c'est le rôle de la fonction reroot).

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