Discussion:OCaml

message: Bonjour,
En allant jeter un œil sur http://caml.inria.fr/index.fr.html, j'ai trouvé une incohérence par rapport à ce qui est indiqué dans le texte de l'article. Dans l'article, OCaml apparaît comme une évolution de Caml et de Caml light. Dans le site, Caml apparaît comme un langage à part entière. OCaml (ou Objective Caml) n'est que la principale implémentation et Caml light une implémentation légère et portable du noyau du langage Caml.
Qu'en est-il réellement ? Est-ce que quelqu'un aurait une réponse ?
--Kerflyn 24 juillet 2005 à 16:29 (CEST)
replies: text: Pas tout à fait: caml light est une version antérieure d'OCaml.  Caml light et OCaml diffèrent quelque peu.  Voir http://www.pps.jussieu.fr/~cousinea/Caml/caml_history.html et http://caml.inria.fr/caml-light/index.en.html  --ChriS 30 janvier 2006 à 23:45 (CET)
thread_title:  Versions de Caml 

message: A priori, ce qui est désigné par "Noeud" dans les exemples sont des Feuilles ! Sparkles 26 juin 2006 à 23:07 (CEST)
thread_title:  Arbre 

message: Il ne présente pas le langage Ocaml mais seulement une petite (microscopique) partie du compilateur. C'est tellement flagrant qu'il est question de l'implémentation dès le troisième paragraphe.
Les exemples ne couvrent presque rien du langage et sont inutilement compliqués par rapport à ce qu'il sont censés présenter. Les concepts intéressants du langage ne sont pas expliqués et il n'y a pas de lien vers les articles Wikipedia qui les présentent où les autres langages qui les exploitent. Les limites du langage ne sont pas données, les extensions proposées sont vieillotes, les soi-disant points forts des performances du compilateur sont complètement dépassés. Les problématiques à la mode ne sont pas abordées. Les problèmes de mauvaise construction de ce langage qui l'obligent à utiliser un pré-processeur ne sont pas traités explicitement (la complexité des exemples le fait implicitement). La lourdeur d'interfaçage d'Ocaml avec les autres langages à objets n'est pas traitée. De manière générale, les nombreux défauts ne sont pas traités. Quand un langage à la qualité d'Ocaml, on peut se permettre de lister ses problèmes (chose qui n'est pas faisable dans d'autres langages : Java, Perl, C++). Cela permetrait aux personnes tombant par hasard sur la page d'Ocaml d'avoir une idée précise du déploiement industriel d'Ocaml et des éléments à ajouter en priorité.
:Oui, l'article n'est pas de bonne qualité. Pourquoi utiliser 30 lignes juste pour dire que le typage est fort et qu'un entier et un flottant sont incompatibles ? Pourquoi montrer tant de messages d'erreur du compilateur (y'a au moins 5 fois le message "type incompatibles" ? Toute la partie 2 ressemble plus à un tutorial pour débutants qu'à une présentation du langage. Ce n'est pas intéressant. Sans compter le style familier qui manque de sérieux : « Caml est "assez grand " », « (hé oui, on a bien dit des entiers!) », etc. Je pense que toute la section 2 (Notions de base en Caml) devrait être supprimée. Il faut des informations pertinentes à la place, qui mettent en valeur les spécificités du langage (typage structurel, préprocesseur, arguments nommés, pattern matching, orienté objet, modules paramétriques, functors...). 17 février 2007 à 19:45 (CET)
thread_title:  Tout l'article 

message: Je viens de modifier considérablement l'article OCaml. J'espère que cette réécriture, motivée par un état jugé non satisfaisant par l'ensemble des contributeurs (bandeau "ébauche" toujours en place), améliore la structure de l'article, et lui donne un aspect plus encyclopédique.
J'ai repris le maximum possible du contenu de la version précédente, traduit quelques parties de la versions anglaise actuelle, et enfin écrit quelques parties.
Il y a cependant une partie du contenu de l'article français que je n'ai pas réutilisé, dans la partie "Présentation du langage" (autrement dit, les bouts de code expliqués). Celle-ci était très longue (ce qui déséquilibrait l'article du fait de la petite taille des autres parties, pourtant plus pertinentes à mon avis).
Je fais ici une liste du contenu que j'ai supprimé, assorti pour chaque passage d'une (tentative de) justification : si vous jugez contestable la supression d'un de ces points en particulier, n'hésitez pas à en discuter ici, ou même à la ré-ajouter vous-même.
Toutefois, il existe des cas dans lesquels le polymorphisme n'est pas recherché. On introduit alors une contrainte quant au type de la variable. Ainsi, dans notre exemple, nous pourrions écrire
let id = function (x : int) -> x ;;
Sous ces conditions, la fonction identité n'est plus polymorphe. Elle ne s'applique qu'aux entiers et possède le type suivant :         
int -> int = <fun>
En fait, la syntaxe que nous venons de présenter est inutilement lourde. Nous pouvions en effet nous contenter de ceci :
let id (x : int) = x ;;
Cette notation se révèle la plus commode lorsque les fonctions acceptent plusieurs arguments, comme c'est le cas ici : 
let somme = function x -> function y -> x + y ;;
let somme x y = x + y ;;
Ces considérations m'ont semblé accessoires : les contraintes explicites de typage sont très rares en OCaml (puisqu'on leur préfère une restriction du typage dans l'interface du module), et la discussion de nature syntaxique ne me paraît pas avoir sa place dans un article généraliste (qui n'a pas vocation de constituer un tutorial pour le langage OCaml).
Les différents types élémentaires de Caml sont les booléens (type bool), les entiers (type int), les réels (type float) et les chaînes de caractères (string), comme dans la plupart des langages de programmation. Un autre type, le type unit, symbolisé par un couple de parenthèses "()", joue à peu près le même rôle que void en C. Pour classer plusieurs valeurs, on dispose également de listes (type list), de tableaux (type array sous OCaml et vect sous Caml-Light) et de n-uplets.
Il est à noter que les différents types présentés ci-dessus peuvent être combinés. Ainsi, on peut par exemple créer des listes d'entiers, dont le type est donc int list, ou des tableaux de chaînes de caractères, dont le type est alors string array sous OCaml et string vect sous Caml-Light.
J'ai retiré ce paragraphe parce qu'il n'apporte pas grand chose (l'énoncé des types built-in est il indispensable dans une encyclopédie ? Pourquoi alors ne pas parler du type option par exemple ?), et surtout que sa formulation me semble maladroite voire fausse : il est plus que douteux d'affirmer que "list" est un type, et que "int list" est donc la combinaison de deux types, "int" et "list".
La fonction somme que nous venons de définir va nous permettre d'introduire une autre notion propre aux langages fonctionnels et tout particulièrement à Caml, la curryfication. La curryfication consiste à voir une fonction à n arguments comme la composition d'une fonction à n - 1 arguments avec une fonction à un argument. Ainsi, pour définir la fonction succ qui détermine le successeur d'un entier, nous pouvons nous contenter de la définition suivante :
let succ = somme 1 ;;
Caml comprend cette écriture comme la définition d'une fonction restreinte à un argument à partir d'une fonction plus générale à deux arguments. Il apparaît alors de façon très nette qu'il n'y a pas de différence syntaxique nette entre les valeurs et les fonctions en Caml.
Dans l'état actuel, ce paragraphe n'est ni compréhensible pour un débutant, ni utile pour un connaisseur. Je pense qu'un lien vers l'article "Curryfication" serait tout aussi utile.
Les fonctions mutuellement récursives sont très utilisées pour définir des fonctions simples comme "pair" et "impair" :
let rec pair = function
   | 0 -> true
   | n -> impair (n - 1)
and impair = function
   | 0 -> false
   | n -> pair (n - 1) ;;
L'écriture que nous avons proposée ci-dessous consiste à raisonner de la façon suivante : savoir si n est pair revient à savoir si (n - 1) est impair. Cet autre problème revient à savoir si (n - 2) est pair, et ainsi de suite. On peut aussi utiliser de telles fonctions pour des tris comme le tri par insertion :
  
let rec trier = function
   | [] -> []
   | t :: q -> inserer t (trier q)
and inserer e = function
   | [] -> [e]
   | t :: q -> if t > e then e :: t :: q else t :: (insere e q) ;;
Les exemples sont assez mauvais : la première fonction se code beaucoup plus simplement sans récursivités mutuelles, et la deuxième ne l'utilise pas, puisque "insérer" n'appelle pas "trier".
Ce célèbre programme d'introduction s'écrit tout simplement :
#let hello_world () = 
   print_string "Hello world !" ;;
On peut ainsi se rendre compte, comme nous l'écrivions précédemment, que hello_world est une fonction, même si son écriture donne à penser qu'il s'agit d'une procédure. En effet, la fonction renvoyée retourne une valeur de type unit et attend un seul argument également de type unit.
La position de ce programme est paradoxale (pourquoi mettre à la fin ce qui est normalement le premier exemple de code qu'on voit ? pourquoi construire une fonction au lieu d'afficher simplement "Hello World !" ?), et je ne pense pas qu'il soit de grand intérêt pour le lecteur.
Bluestorm 3 décembre 2007 à 00:57 (CET)
thread_title:  Refonte de l'article 

message: Tout ce paragraphe est composé d'affirmations vagues ("on") et non sourcées, donc en l'état non acceptable. Comme j'ai un biais favorable à Ocaml, j'attendrai deux semaines que quelqu'un se manifeste avant de la supprimer simplement. Il est possible aussi que je fasse quelques recherches sur le sujet et que j'en fasse une section acceptable, mais cela me semble plus improbable pour l'instant. Léna (d) 21 septembre 2009 à 16:33 (CEST)
thread_title:  Critiques