Programmation fonctionnelle en OCaml

Historique

Evolution des langages de programmation :
1945 : Assembleur
1954-58 : Fortran (J. Backus) IBM : Formula Translator
1958-60: LISP Mac Carthy (MIT)
60’: Algol : Tentative de language impérative complet propre
60’ : Cobol : info de gestion
64 : Basic : académique, numéros de lignes, goto, interprété
70 : Pascal : académique
73 : C : Ritchie, pour l’écriture de Unix
70’: Prolog, Colmérauer)
75’ :Scheme : Lisp amélioré
73 :ML : R. Milner : Théorème prouveur
1980’ : Ada : Aéronautique (langage propre)
1987 : Caml, Weiss
84 : Java(Sun) Goslig

1) Introduction à OCaml

1.1) Programmation fonctionnelle : Caractéristiques

Fondée sur la notion mathématique de fonction : Relation entre 1 domaine source et d’arrivée.
Ex : Tri : Suite de valeurs -> Suite de valeurs
s |-> tri(s)
Contrainte : Une unique valeur doit être associée à chaque entrée.
Conséquence : Une fonction ne dépend que de ses arguments : Par exemple, une opération qui dépend d’une variable globale ne peut être une fonction (pas d’effets de bords).
Ex : N’est pas une fonction (écrit en C)
Int i=0 ;
int f(int j){
i=i+j;
return I;
}
Principe de la programmation fonctionnelle : Représenter les programmes par des fonctions au sens mathématique.
Avantage :
a) Simplifier la programmation :
- Localisation des effets de bord(pas d’effet de bord) une fonction peut être testée/réutilisée
- Identification fonction/Résultat (Dans l’exemple précédent f(1)-f(1) !=0)
- Indépendance à la séquence de calcul. Les différents appels peuvent avoir lieu dans un ordre quelconque : f(1)+f(2)= f(2)+f(1) (pas dans l’exemple précédent)
b) Modèles logiques et mathématiques
c) Fonctions = valeurs
Ex : Tri : fonction de comparaison x liste -> liste triée en C (effets de bords)
d) Contraintes de la programmation fonctionnelle
- Fonctions ne peuvent transformer l’environnement extérieur
- Les fonctions ne peuvent êtres influencées par l’environnement extérieur
->Les boucles doivent être des fonctions récursives. Gestion implicite de la mémoire : Garbage Collector.

1.2) OCaml : Caractéristiques

OCaml autorise :
- Programmation fonctionnelle
- Programmation objet
- Programmation générique
Caractéristiques : Typage fort, inférence de types

1.3) Notions de base

1.3.1) Environnement interactif



>ocaml

#

#17+2;;

- : int = 19

#

Entiers et flottants :
types prédéfinis : float, int, char, string, boolean

Opérateurs :
+,-,*,/, mod (entiers)
+.,-.,*.,/.,** (flottants)
Les opérations entres types différents sont interdites
Conversions : int_of_foat et float_of_int

Caractères et chaînes :
Caractère : entre quotes : ‘a’
Chaînes : entres guillemets : ‘’a’’

Conversions :
int_of_char
int_of_string
float_of_string

Concaténation : ^

Booléens : true et false

Opérateurs : &&, ||, not, &, |
Comparaisons : (Opérateurs valables pour tous les types)
= égalité structurelle
== égalité physique
<>
!= négation de ==
<= >=
a ->(a ->bool)

Unité : (comparable au void du C)
Une seule valeur : unit notée ()

Produit cartésien, n-uplets :
Des valeurs de différents types peuvent être regroupés en n-uplets.

1.3.2) Lire les types

Lorsqu’une valeur est affectée, OCaml en donne le type .
Les fonctions sont des valeurs



#sin ;;

- : float -> float = <fun >

a) sin est définie.
b) Sin est une fonction de float vers float
c) <fun> indique que sin est une fonction dont le corps n’est pas affiché.