Vous êtes sur la page 1sur 26

CaML

Pierre Bourreau

Introduction

Le λ-calcul
simplement typé
En (très) bref

Programmation Fonctionnelle... Syntaxe


Typage simple

effective!!! CaML
Un langage interprété
Types
Opérations
Structure d’un programme
Types Complexes
Pierre Bourreau
Conclusion

1 IUT Bordeaux 1 - Licence Pro

February 24, 2010


CaML
Outline
Pierre Bourreau

Introduction
Introduction
Le λ-calcul
simplement typé

Le λ-calcul simplement typé En (très) bref


Syntaxe

En (très) bref Typage simple

CaML
Syntaxe Un langage interprété
Types
Typage simple Opérations
Structure d’un programme
Types Complexes

CaML Conclusion

Un langage interprété
Types
Opérations
Structure d’un programme
Types Complexes

Conclusion
CaML
Sommaire
Pierre Bourreau

Introduction

Le λ-calcul
Introduction simplement typé
En (très) bref
Syntaxe
Typage simple
Le λ-calcul simplement typé
En (très) bref CaML
Un langage interprété
Syntaxe Types
Typage simple Opérations
Structure d’un programme
Types Complexes

CaML Conclusion
Un langage interprété
Types
Opérations
Structure d’un programme
Types Complexes

Conclusion
CaML
Langages Fonctionnels vs Langages Impératifs
Pierre Bourreau

Impératif Introduction

int factorielle (int n) Le λ-calcul


simplement typé
{ En (très) bref
Syntaxe
res = 0; Typage simple

for (int i=1; i<=n; i++) CaML


Un langage interprété

res=res*i; Types
Opérations
return res; Structure d’un programme
Types Complexes

Conclusion
Fonctionnel
let rec factorielle n = function
0 -> 1
| n -> n * factorielle (n-1);;
CaML
Langages Fonctionnels vs Langages Impératifs
Pierre Bourreau

Impératif Introduction

Le λ-calcul
I langage riche (nombreux mots clés . . . ) simplement typé
En (très) bref

I typage à la main Syntaxe


Typage simple

I allocation mémoire (old shool -> C, C++) CaML


Un langage interprété

I programmes de tailles conséquentes Types


Opérations
Structure d’un programme
Types Complexes

Fonctionnel Conclusion

I langage pauvre
I typage automatique
I pas d’allocation mémoire (garbage collector )
I programmes petits
CaML
Objective CaML
Pierre Bourreau

Présentation Introduction

Le λ-calcul
I (Objective) Categorial Abstract Machine Language simplement typé
(87) En (très) bref
Syntaxe
Typage simple
I Héritier de ML CaML
I Langage fonctionnel Un langage interprété
Types
Opérations
I Garbage collector Structure d’un programme
Types Complexes

I Typage fort et inféré Conclusion

I Extension pour commandes impératives + objet


I Utilisé en entreprise: Airbus, Microsoft, Intel, . . .
CaML
Sommaire
Pierre Bourreau

Introduction

Le λ-calcul
Introduction simplement typé
En (très) bref
Syntaxe
Typage simple
Le λ-calcul simplement typé
En (très) bref CaML
Un langage interprété
Syntaxe Types
Typage simple Opérations
Structure d’un programme
Types Complexes

CaML Conclusion
Un langage interprété
Types
Opérations
Structure d’un programme
Types Complexes

Conclusion
CaML
De la théorie à la pratique
Pierre Bourreau

Introduction

Le λ-calcul
simplement typé
En (très) bref
Syntaxe

I 1930’s Alonzo Church Typage simple

CaML
I Théorie de la calculabilité (le λ-calcul est un modèle Un langage interprété

de la calculabilité) Types
Opérations
Structure d’un programme
I 1958 Lisp Types Complexes

Conclusion
I 1970’s Scheme
I 1980’s ML
I 1987 CaML - 1996 OCaML
CaML
Définition Pierre Bourreau
Soit V un ensemble énumérable de variables. On définit
Introduction
l’ensemble Λ des termes construits sur V:
Le λ-calcul
I si x ∈ V, alors x ∈ Λ simplement typé
En (très) bref
Syntaxe
I si M ∈ Λ et x ∈ V, alors λx.M ∈ Λ Typage simple

I si M, N ∈ Λ, alors MN ∈ Λ CaML
Un langage interprété
Types
Opérations

Exemples Structure d’un programme


Types Complexes

Conclusion
I x, x1 , y , z ∈ V
I λx.x
I yx
I λx.yx
CaML
Interprétation
Pierre Bourreau

Introduction

Le λ-calcul
simplement typé
En (très) bref
I comprendre les variables comme des fonctions Syntaxe
Typage simple

I écrire yx1 . . . xn signifie que y est une fonction n-aire CaML


Un langage interprété
I le terme λx1 . . . xn .xi , est une fonction n-aire qui Types
Opérations
renvoie son i-ème argument. Structure d’un programme
Types Complexes

I λx1 . . . xn .M est une fonction à n arguments Conclusion

I c’est aussi une fontion à n − 1 arguments, n − 2


arguments, etc . . .

Exemples
I λx.factorielle x est une fonction à un argument
CaML
Idée
Pierre Bourreau

Introduction

Le λ-calcul
simplement typé
En (très) bref
I associer un type à chaque variable Syntaxe
Typage simple

I une variable ne peut avoir qu’un seul type (est-ce le CaML


Un langage interprété
cas pour tous les langages impératifs?) Types
Opérations
Structure d’un programme

Exemple Types Complexes

Conclusion

I x
I λx.fx
I λx.f (λy .xy )
CaML
Idée
Pierre Bourreau

Introduction

Le λ-calcul
simplement typé
En (très) bref
I associer un type à chaque variable Syntaxe
Typage simple

I une variable ne peut avoir qu’un seul type (est-ce le CaML


Un langage interprété
cas pour tous les langages impératifs?) Types
Opérations
Structure d’un programme

Exemple Types Complexes

Conclusion

I x :a
I λx a .f a→b x a : a → b
I λx.f (λy .xy )????
CaML
Idée
Pierre Bourreau

Introduction

Le λ-calcul
simplement typé
En (très) bref
I associer un type à chaque variable Syntaxe
Typage simple

I une variable ne peut avoir qu’un seul type (est-ce le CaML


Un langage interprété
cas pour tous les langages impératifs?) Types
Opérations
Structure d’un programme

Exemple Types Complexes

Conclusion

I x :a
I λx a .f a→b x a : a → b
I λx a→b .f (a→b)→c (λy a .x a→b y a ) : a → c
CaML
Remarques
Pierre Bourreau

Introduction

Le λ-calcul
simplement typé
En (très) bref
Syntaxe

I Vous faîtes de l’inférence de type. Typage simple

CaML
I On pourrait n’utiliser qu’un type a. Un langage interprété
Types

I Mais ne donne pas le type le plus général. Opérations


Structure d’un programme
Types Complexes
I On ne veut donner aucune contrainte sur les types à Conclusion
utiliser.
I En CaML, le système de typage est fort: certaines
opérations ont un type contraint (+, -., . . . )
CaML
Sommaire
Pierre Bourreau

Introduction

Le λ-calcul
Introduction simplement typé
En (très) bref
Syntaxe
Typage simple
Le λ-calcul simplement typé
En (très) bref CaML
Un langage interprété
Syntaxe Types
Typage simple Opérations
Structure d’un programme
Types Complexes

CaML Conclusion
Un langage interprété
Types
Opérations
Structure d’un programme
Types Complexes

Conclusion
CaML
Bienvenus dans un monde fonctionnel
Pierre Bourreau

Introduction

Le λ-calcul
simplement typé
En (très) bref
Syntaxe
Typage simple

I repose sur le λ-calcul simplement typé: CaML


Un langage interprété
I système d’inférence de type statique Types
Opérations

I permet de vérifier qu’une fonction est bien construite Structure d’un programme
Types Complexes

dès compilation - interprétation Conclusion

I permet aussi de définir des fonctions d’ordre


supérieur
CaML
Utilisation
Pierre Bourreau

Introduction

Le λ-calcul
simplement typé
En (très) bref
Syntaxe
Typage simple

I depuis la console, lancer ocaml CaML


Un langage interprété

I l’interprète se lance; écrire une expression CaML Types


Opérations

I # let x = 2 + 6 ;; Structure d’un programme


Types Complexes

I l’interprète analyse l’expression; si correcte, infère Conclusion


son type:
I val x : int = 7
CaML
A la base
Pierre Bourreau

Introduction

Le λ-calcul
simplement typé
Types En (très) bref
Syntaxe
Typage simple
I int: entier signé (4, 3445, -234) CaML
Un langage interprété
I float: nombre à virgule flottante double- (≈ type Types
Opérations
double du C) (4., 34.45, -.234) Structure d’un programme
Types Complexes
I bool: booléen (true, false) Conclusion
I char: caractère sur 8 bits (’a’, ’v’)
I string: chaîne de caractères (“a”, “3445”,
“hello”)
I unit valeur unique notée ()
CaML
A la base
Pierre Bourreau

Introduction

Le λ-calcul
simplement typé
Opérations En (très) bref
Syntaxe
Typage simple

I sur les entiers: +, -, *, /, mod CaML


Un langage interprété
I sur les flottants: +., -., *., /., sqrt, e Types
Opérations
I conversion: int_of_float, float_of_int Structure d’un programme
Types Complexes
I 4.
Conclusion
I sur le booléens: &&, ||, not
I sur les chaînes: concaténation ˆ
I une opération spéciale: if val_bool then val1
else val2;;
CaML
Définitions de variables
Pierre Bourreau

Introduction

Le λ-calcul
simplement typé
En (très) bref
Globales Syntaxe
Typage simple

I let x = 4;; CaML


Un langage interprété

I let y = float_of_int(x) +. 6.;; Types


Opérations
Structure d’un programme
Types Complexes

Locales Conclusion

I let z=3 in z+4;;


I - : int = 7
I z n’est plus accessible par la suite.
CaML
Définitions de fonctions
Pierre Bourreau

Introduction

Le λ-calcul
simplement typé
Non-récursives En (très) bref
Syntaxe
Typage simple

let func arg1 ...arg2 = corps;; CaML


Un langage interprété
Types
Opérations
Structure d’un programme
I let norme x y = Types Complexes

sqrt (x*.x+.y*.y);; Conclusion

I norme 4. 6.;;
I let somme a b =
a + b;;
I somme 1 8;;
CaML
Définitions de fonctions
Pierre Bourreau

Introduction

Le λ-calcul
simplement typé
Récursives En (très) bref
Syntaxe
Typage simple

let rec func arg1 ...arg2 = corps;; CaML


Un langage interprété
Types
Opérations
I let rec fact n = Structure d’un programme
Types Complexes
if n<=1 then 1 else n * fact(n-1);; Conclusion
I fact 4;;
I let rec mult a b =
if b=0 then 0
else somme a (mult a (b-1));;
I mult 2 3;;
CaML
Types Complexes
Pierre Bourreau

Introduction

Le λ-calcul
simplement typé
En (très) bref

Les listes Syntaxe


Typage simple

CaML
I Prédéfinies (héritage de Lisp) Un langage interprété
Types
I # [1;4;7;3];; Opérations
Structure d’un programme

I Tous les éléments doivent être de même type. Types Complexes

Conclusion
I Opérations:
I insertion d’un élément en tête: elt::liste;;
I récupérer élément de tête: List.hd liste;;
I récupérer la queue d’une liste: List.tl liste;;
CaML
Fonctions sur ces types
Pierre Bourreau

Introduction

Le λ-calcul
Pattern Matching simplement typé
En (très) bref
Syntaxe
I le type est défini par induction Typage simple

I Listes -> cas de base: [] CaML


Un langage interprété
I Listes -> pas d’induction: a::l Types
Opérations
I l’opérateur match: Structure d’un programme
Types Complexes
I match var with Conclusion
| cas1 -> action1
...
| casN -> actionN;;
I # let rec taille l = match l with
| [] -> 0
| a::k -> taille k +1;;
CaML
Sommaire
Pierre Bourreau

Introduction

Le λ-calcul
Introduction simplement typé
En (très) bref
Syntaxe
Typage simple
Le λ-calcul simplement typé
En (très) bref CaML
Un langage interprété
Syntaxe Types
Typage simple Opérations
Structure d’un programme
Types Complexes

CaML Conclusion
Un langage interprété
Types
Opérations
Structure d’un programme
Types Complexes

Conclusion
CaML

Pierre Bourreau

Introduction

Le λ-calcul
simplement typé
En (très) bref

I langage très puissant. Syntaxe


Typage simple

I programme très concis CaML


Un langage interprété
Types
I langages fonctionnels < langages impératifs? Opérations
Structure d’un programme
I s’appuie sur une théorie bien fondée, et qui évolue Types Complexes

(système F, types intersections, . . . ) Conclusion

I Important: les langages changent, la théorie reste...