Avec un peu d’expérience d’OCaml, vous constaterez qu’OCaml est un langage dans lequel les programmes écrits sont beaucoup plus concis qu’en Java ou C#, grâce à de puissantes primitives d’abstraction, grâce à l’extensibilité du langage, grâce à l’inférence de types et, tout simplement, grâce à une syntaxe plus concise. Cette concision est souvent un avantage, même si elle rend le code plus dense et donc parfois plus difficile à lire.

Pourquoi apprendre OCaml ?

Cette réponse a plusieurs questions.

Pour les mathématicien, physiciens, statisticiens ou autres utilisateurs de programmes scientifiques, OCaml permet de développer des programmes rapides et fiables, d’une part parce que le code source du programme ressemblera à la description mathématique du problème et sera donc plus simple à vérifier et d’autre part parce que les analyses permises par OCaml éviteront de nombreuses erreurs. De plus, la programmation fonctionnelle de haut niveau simplifie la constitution des bibliothèques génériques et aisément réutilisables.

Les programmeurs Java, C#, C, C++ ou autres utilisateurs de langages ou librairies système ou orientés-objets découvriront avec OCaml une autre manière de voir le monde et d’écrire des programmes dépendant moins du mode d’exécution de la machine et plus des résultats voulus, de modifier le langage de programmation pour l’adapter au problème au fur et à mesure de la progression du projet, ou encore d’autres techniques de factorisation et de réutilisation de code. Même si vous ne deviez pas utiliser OCaml dans votre carrière, les concepts vous permettront d’analyser un grand nombre de problème sous des angles que vous n’aviez pas prévus jusqu’à présent.

Les programmeurs Python, Ruby, JavaScript découvriront un langage confortable, dans lesquels ils retrouveront un grand nombre d’idées connues, sous une forme plus rigoureuse et plus adaptée au développement de grands projets critiques.

Avant d’enseigner

Avant d’entrer dans l’enseignement, commençons par une mise en bouche.

Note: Tout ce qui suit utilise la syntaxe révisée de OCaml, qui est l’une des manières possibles d’écrire du OCaml, et qui est incluse dans OCaml sous la forme de la librairie camlp4r.

Bonjour, le monde

L’extrait suivant est un programme complet d’une ligne, qui a pour effet d’afficher le texte “Bonjour, le monde” :
print_endline (”Bonjour, le monde.”);

On pourrait d’ailleurs simplifier légèrement le programme en supprimant les parenthèses, qui ne sont ici pas nécessaires, de manière à obtenir l’extrait suivant :

print_endline "Bonjour, le monde.";

Dans ce qui précède, print_endline est une fonction, dont l’effet est d’afficher du texte et de passer à la ligne, et qui n’a pas de résultat. En Java, ce serait l’équivalent de

public class Main
{
public static final void main(String args[])
{
System.out.println(”Bonjour, le monde”);
}
}


Pi

Pour définir la valeur de pi, il suffit d’écrire

value pi = 3.1415926;

Cette ligne donne le nom pi à la valeur 3.1415926. Cette valeur ne changera plus au cours de l’exécution du programme. En Java, ce serait l’équivalent d’une déclaration

public static final float PI = 3.1415926;


Identité

Les fonctions sont des valeurs comme les autres. Ainsi, pour définir la fonction identité, qui à tout x associe x lui-même, on peut écrire

value id = function x -> x;

ou encore

value id = fun x -> x;

ou encore

value id(x) = x;


ou encore

value id x = x;

Ces quatre définitions sont équivalentes. Les deux premières précisent explicitement que id est une fonction, tandis que les deux dernières peuvent se lire “pour tout x, id(x) vaut x” — dans la dernière version, nous avons tout simplement supprimé les parenthèses qui étaient inutiles. Nous verrons plus tard que cette fonction va faire l’objet d’un certain nombre de vérifications à chaque fois qu’elle est appliquée.

On utilise alors id de la manière suivante

value y = id 5;
value z = id “Il fait beau”;
En Java, pour obtenir la même fonctionnalité, le plus simple est d’abandonner toute vérification et d’écrire une classe contenant la méthode suivante :

public class Fonctions
{
public static Object id(Object x)
{
return x;
}
}


On utilise alors id de la manière suivante

int y = (Integer)Fonctions.id(5);
String z = (String)Fonctions.id(”Il fait beau”);
Si l’on cherche à conserver une vérification de types, il devient nécessaire de définir une classe plus complexe :

public class Id<T>
{
public T appliquer(T x)
{
return x;
}
}

On utilise alors id de la manière suivante

int y = new Id<Integer>().appliquer(5);
String z = new Id<String>(). appliquer(”Il fait beau”);
Profitons de cet exemple pour remarquer que, en OCaml, le mot-clé return n’existe pas et n’est pas nécessaire. En effet, le corps d’une fonction est une expression et toute expression est évaluée. En d’autres termes, le résultat d’une fonction est donné par la dernière expression de cette fonction.

Delta

La fonction delta de Dirac est définie mathématiquement de l’ensemble des réels vers l’ensemble des réels par

• delta(0) = 1
• pour tout autre x, delta(x) = 0

value delta = fun
[ 0.0 -> 1.0
| _ -> 0.0 ];

value delta x = match x with
[ 0.0 -> 1.0
| _ - > 0.0];

value delta x = if x=0.0 then 1.0 else 0.0;

value rec factorielle = fun
[ n when n>=1 -> n * (factorielle (n - 1) )
| _ -> 1 ];

Cet extrait se lit exactement comme la définition par récurrence.

Dans ce qui précède, rec signifie que la fonction est définie par récursivité, mécanisme qui correspond à la définition mathématique par récurrence ou par induction : les cas non-triviaux sont déterminés à partir des cas précédents, ou encore la fonction s’appelle elle-même. En OCaml, la récursivité est la forme de boucle la plus fréquente.

On pourrait aussi écrire le code suivant, toujours récursif :

value rec factorielle n = if n >= 1 then n * ( factorielle (n - 1) ) else 1;

En Java, on recommande d’écrire :


public static int factorielle(int n)
{
int result = 1;
for(int i = 1; i < n; ++i)
result *= i;
return result;
}


Il est aussi possible d’écrire une version récursive en Java, même si, à cause des limites de ce langage, ce genre de pratiques est généralement évité :


public static int factorielle(int n)
{
if(n<=0)
return 1;
else
return n * factorielle (n-1);
}


Comme on peut le constater, les versions OCaml sont plus concises et plus proches de la définition mathématique que la version Java recommandée. Même si cela n’est pas fondamental pour un exemple aussi simple, on peut déjà constater qu’il y a un peu moins d’occasions de commettre des erreurs simples en suivant la structure OCaml que la structure Java recommandée. Cette tendance ne fait que s’amplifier pour des exemples plus complexes.

Définition directe

Sans entrer dans les détails pour le moment, on peut définir le produit de tous les éléments d’une liste comme


value produit = List.fold_left ( * ) 1;


Cette ligne se lit “le produit de a1, a2, …, an est 1*a1*…*an”. Le terme 1 est nécessaire pour que cette définition du produit généralisé fonctionne même dans le cas où n=0.

Le produit des entiers de 1 à n s’écrit alors

value factorielle n = produit [ 1 .. n ];

Note: Cette notation [ 1 .. n ] est définie dans une extension de OCaml.

Manipulation de fichiers


open MoreStream;
open MoreFiles;


value rec add_line_number i stream = match stream with parser
[ [: `line; rest :] -> [: `((string_of_int i)^": "^line); add_line_number (i+1) rest :]
| [: :] -> [: :] ];


with_input “/tmp/in.txt” (function input ->
with_output “/tmp/out.txt”(function output ->
output_lines (add_line_number 1 (input_lines input)) output
)
);


La première partie de l’extrait définit un filtre sur les flux (streams) nommé add_line_number. Ce filtre est conçu pour traiter flux de lignes, et son rôle est d’ajouter au début de chaque ligne le numéro de cette ligne. Les symboles [:, :] et ` sont utilisés pour examiner le contenu d’un flux ou construire de nouveaux flux. Ainsi, [: :] désigne le flux vide et [: `line; rest :] désigne n’importe quel flux (d’entrée) non vide, dans lequel on choisit d’appeler line le premier élément et rest la suite. De même, [: `((string_of_int i)^": "^line); ... désigne le flux (de sortie) dans lequel le premier élément s'obtient en convertissant l'entier i en chaîne de caractère, chaîne à laquelle on concatène le symbole ": " suivi de line (qui représente toujours le premier élément du flux d'entrée). Enfin, ... ; add_line_number (i+1) rest :] désigne la suite du flux de sortie, qui s’obtient en continuant la boucle add_line_number, dans laquelle le nombre i est remplacé par i+1 et dans laquelle on s’intéresse à flux rest (qui représente toujours la suite du flux d’entrée).

La boucle add_line_number se lit donc

• tant que le flux d’entrée n’est pas épuisé, prendre le prochain élément (appelons-le line) et utilisons-le pour construire le prochain élément du flux de sortie — cet élément aura pour valeur la représentation du nombre i (le numbre de lignes rencontrées depuis le début de la boucle), suivi de deux points, suivi de line
• une fois le flux d’entrée épuisé, le flux de sortie est terminé.

import java.io.*;
//…LineNumberReader reader = new LineNumberReader(new FileReader(”/tmp/in.txt”));
try
{
try
{
PrintWriter writer = new PrintWriter(new FileWriter(”/tmp/out.txt”));
reader.setLineNumber(1);
for(String line = reader.readLine(); line != null; line = reader.readLine())
writer.print(reader.getLineNumber+”: “+line)
} finally {
writer.close();
}
} finally {
reader.close();
}
//…

Programme des hostilités

Si ces quelques échantillons vous ont intéressé, les prochains billets vous enseigneront comment écrire un programme par vous-même et surtout comment tirer avantage des spécificités d’OCaml.

1. Bases d’OCaml : ligne de commande, syntaxe, types de base, valeurs, fonctions, inférence de types, polymorphisme paramétrique.
2. Structures de données : listes, tableaux, enregistrements, types sommes, types polymorphes, filtrage par motifs.
3. Compilation : environnements, compilation, compilation native, modules, ocamlbuild.
4. …