Université M’Hamed BOUGARA - Boumerdes

Faculté des sciences – Département d’Informatique

Programmation Fonctionnelle Avancée

MASTER 1: ILTI -TI- SIR

Réalisé par : LOUNAS Razika
Contenu du module
 Rappels sur les notions de base
 Les listes: récursivité et algorithmes
 Les types Union
 Les arbres
 Les aspects impératifs du Ocaml (bref passage)
 les exceptions
 Les modules
 Les E/S
2
Plan du cours 1: Rappels sur les notions de base

 Introduction
 Types de bases
 Fonctions et récursivité
 Filtrage par motifs
 N-uplets
 Types polymorphes

3
 Introduction
 Programmation fonctionnelle
C’est un style (un paradigme) de programmation ou la notion de base est la fonction au
sens mathématique du terme.

 Langages
Haskell: programmation fonctionnelle pure (absence totale d’effets de bords)

Ocaml: Programmation fonctionnelle impure: présence de traits impératifs dans

le langage.
4
 Expressions de base (1)
 Unit: type vide, (comme le void du C)

Int: le type des entiers signés (décimal, octal, Float: les nombres à virgule flottante (écriture
binaire, hexadécimal) décimale, avec l’exposant en base 10)

#5 ;;
# 5.5;;
- : int = 5
- : float = 5.5
# 12345 + 1;;
# 5.0;;
- : int = 12346
- : float = 5.
# 10 mod 3;;
# 5.;;
- : int = 1
- : float = 5.
# 1 - - 2;;
# 31.415926e-1;;
- : int = 3
- : float = 3.1415926
# 0x7fffffff;;
: int = -1
5
Expressions de base (2)
 Opérations arithmétiques
Type int: + - * / mod
Type float: +. -. *. /.

Le type bool: valeurs de vérité (true, false)

Opérateurs booléens: = > < >= <=

Le type char: les cractères ‘a’ , ‘?’…

String: chaine de caract-res « bonjour tout le monde »

6
 Déclaration de variables et de fonctions
 Le mot clé let permet d’introduire des variables et des fonctions.
 Variables:
let nom_var = val;; (déclaration globale)
let nom_val = val in exp;; (déclaration locale)

 fonctions
let nom_fct suite_d_arguments = corps_fct;;
Ou bien: fun arg1 arg2….arg3 -> corps_fct;;

7
Déclaration de variables et de fonctions
# let x =5 ;;

# let x = 1 in let y = 2 in x+y;;

# let incr i = i+1;;

# let incr = fun i -> i+1;;

# let som = fun x y -> x+y;;

# let som x y = x+y;;

#let sumi =

let sum2 j =

i+j in sum 2 ;;
8
 Fonctions récursives
 Une fonction récursive est une fonction qui fait appel à sa propre définition.
 Utilisé pour exprimer des traitement répétitifs
 Exemple
#let rec power i x =
if (i=0) then 1.0 else
x*.(power (i-1) x);;

- Val power:int->float->float =<fun>

 Pour bien écrire les fonctions récursives:
 cas de base (un ou plusieurs) pour sortir des appels récursifs
 Un ou plusieurs appels récursifs pour faire le traitement
 Faire attention au fait qu’au moins un des arguments doit diminuer (directement ou
indirectement) à chaque appel jusqu’à atteindre le cas de base et sortir de la
récursivité
9
 Ne pas oublier le mot clé rec
 Fonctions d’ordre supérieur
 Une fonction peut prendre d’autres fonctions comme arguments.
 Une fonction peut être retournée comme résultat.
 Exemple
#let dx = 1e-10;;

Val dx:float = 1e-10

#let deriv f = (fun x->f(x+.dx)-.f(x))/.x);;

Val deriv: (float->float)->float -> float

 On considère une fonction arbitraire f sur les réels

 Puis on écrit une fonction qui fait la dérivé de f en un point x en appliquant
la loi mathématique.
10
 Filtrage par motif
 Permet de définir des expressions par analyse de cas:

Match exp with

| pattern1 -> exp1
| pattern2 -> exp2
|…
| pattern m -> expm

Si un des motifs (patterns) correspond , l’expression

correspondante est évaluée
11
 Les N-uplets
 Un N-uplet est introduit avec la notation habituelle du produit cartésiens en mathématiques:
# (1,2,3);; type: (int*int*int)

#let v=(1,true, « bonjour »);; type: int*bool*string

 Le type est formé à partir de l’opérateur * et des types des différents éléments.
 Un N-uplet peut être d’arité quelconque (nombre d’éléments)
 Les éléments d’un N-uplet peuvent être de types différents.

 Quand l’arité est 2 (une paire, un couple) nous

# let x = (1, ‘r’);;
avons les opérations suivantes:
fst x retourne 1
fst: retourne le 1er élément du couple snd x retourne ‘r’
snd: retourne le 2éme élément du couple.
12
 Types polymorphes
 Il arrive qu’une expression ou une fonction soit valable pour plusieurs types.
Exemple:
# let f x =x;; type: ‘a->’a

#let f x y = x > y;; type: ‘a->’a->bool

# let f g x y = g(x) = y;; type: (‘a->’b) -> ‘b -> bool

 Le système génère alors des types dits: polymorphes ou génériques. Ils sont
notés: ‘a, ‘b, ‘c….

 Dans le deuxième exemple, la fonction peut s’appliquer à différents types (int, float…) mais la
comparaison oblige que les deux arguments soient du même type polymorphe. Dans le troisième
exemple, rien n’indique que les types de x et y doivent être le même type polymorphe.
13
Système de typage Ocaml
 Ocaml est un langage fortement typé: une expression possède UN
type, contrairement au langage C par exmeple ou une valeur peut être
remplacée par une valeur d’un autre type (exemple un int par un
double).
 Grâce au typage, le langage est dit sûre. La définition formelle de la

sureté se base sur la sémantique du langage . Sa signification est que

l’exécution d’un programme valide dans son typage ne va jamais
échouer à cause d’une opération invalide.
 Exemples de compagnies utilisant le Ocaml:

https://ocaml.org/learn/companies.html

14
 N’hésitez pas à poser ou envoyer vos questions

 RDV au cours suivant

15