Chapitre IV Programmation fonctionnelle : Langage Lisp EPSI / Montpellier - Cycle CSII 2A Intelligence Artificielle

Chapitre IV

Programmation fonctionnelle : Langage Lisp

EPSI / Montpellier - Cycle CSII 2A

Intelligence Artificielle

• Introduction– Types de programmation

• Programmation procudérale (impérative) : on donne à l ’ordinateur toutes les étapes pour résoudre le problème• Aspect séquentiel des programmes• Notions d ’affectation, de condition et de répétition

• Programmation déclarative : on décrit le rapport entre les données et les résultats• Programmation logique : PROLOG• Programmation fonctionnelle : LISP


• Historique du langage Lisp (LISt Processing)– 1958 : Création de Lisp par John Mac Carthy

• Travaux de Alonzo Church sur le lambda-calcul• Travaux de John Mac Carthy sur les fonctions récursives

– 1970-1980 : Prolifération des dialectes Lisp– 1984 : Normalisation ANSI X3J13 de Lisp par Guy L. Steele

• Définition du dialecte Common Lisp

– 1989 : Publication officielle de la norme X3J13• La norme Common Lisp est arrêté en Octobre 1989


• Caractéristique de Lisp– Un langage généralement interprété– Un langage de haut niveau– Un langage extensible– L’objet de base est la fonction

• Un programme = un ensemble de définitions et d ’appels de fonctions

– L ’opération de base est l ’évaluation d ’une expression • Application d ’une fonction à une liste d ’arguments

– Structure de données• Les données et les programmes sont représentés par des listes


Programmation fonctionnelle : Langage Lisp• Caractéristiques de Lisp

– Lisp manipule des données symboliques• Donnée symbolique = s-expression

– Lisp offre une approche objet de programmation• Classes et fonctions génériques

– Lisp est un langage interactif• Boucle à trois temps(REPL:Read-Eval-Print Loop)

read eval print

Lecture d ’une expression symbolique (une s-expression)

Évaluation de l ’expression

Écriture du résultat (une s-expression)

Programmation fonctionnelle : Langage Lisp• Caractéristiques de Lisp

– Lisp est dédié au traitement symbolique :• Modélisation du raisonnement• Traitement du langage naturel

– Lisp a une très grande puissance d ’expression• Idéal pour le prototypage des modèles en I.A

– Pas de distinction entre donnée et programme• Code = donnée• Du code qui écrit du code• Le code est particulièrement concis

Programmation fonctionnelle : Langage Lisp• Apprendre à programmer en Lisp

– Maîtriser la syntaxe des s-expression– Comprendre les règles d ’évaluation– Connaître les fonctions prédéfinies– Acquérir la méthodologie et l’esprit « programmation fonctionnelle »

• Les dialectes de Lisp

– Le_Lisp – Mac Lisp– Frantz Lisp– Koyoto Common Lisp– Scheme– etc.


• Le dialecte Scheme– Dialecte inventé en 1975 par Steele & Sussmann au MIT– Une reconstruction minimale de Lisp conçue à des fins pédagogiques– Scheme a été normalisé par l'IEEE puis par l'ISO en 1992– En1997, GNU distributeur d‘Emacs choisit Scheme comme langage d'extension dans les applications [projet GUILE]– Plusieurs implémentations de Scheme sont disponibles :

– DrScheme (Université de Rice à Houston, Texas, USA) : tourne sous Unix, Windows, et Macintosh – Chez Scheme (Cadence Research Systems, USA) – Scheme->C (Digital Equipment Corporation, Palo Alto, Californie, USA)– Bigloo (Inria, France)


Programmation fonctionnelle : Langage Lisp• Premiers exemples

– Calculer des expressions> (* 24 5)

> (/ 120 6)

– Afficher un message> (define (Afficher-Bonjour) Définition d ’une fonction

(display "Bonjour à tous")

(newline)

(newline)

)

> (Afficher-Bonjour) Appel d ’une fonction

– Appliquer une fonction en inversant l ’ordre des arguments> (define (fonction-inverse fonction arguments)

(apply fonction (reverse arguments))

)

> (fonction-inverse - '(25 40))

Programmation fonctionnelle : Langage Lisp• Premiers exemples

– Utiliser les fonctions anonymes (fonctions lambdas)

> (define somcar (lambda(x y) (+ (* x x) (* y y))))

> ((map (lambda (n) (* n n)) '(1 2 3 4 5))


• Syntaxe de Lisp

– Syntaxe des s-expressions s-expression

• atomes• constantes :numériques (nombres) et symboliques (chaîne de caractères)• variables (identificateurs)

• listes• liste vide ()• listes non vides (une suite de s-expressions)


• Syntaxe de Lisp– Syntaxe des s-expressions

atome• nombres :exemples

• entier : 123 589• flottant : 5.6 123.48• rationnel : 1/3 2/8

• Chaîne de caractères :exemples• Caractère : #\a #\I #\5 #\\• Chaîne de caractères : "EPSI" " " " x " "Cours de \"LISP\""• Booléens : #t : vrai #f:faux



atome• Variables (identificateurs) :

• une chaîne de caractères qui n ’est pas une constante et qui ne contient pas de séparateurs : ( ; ) ‘ espace• pas de distinction majuscule/minuscule• pas besoin de déclarer une variable• toute variable doit être définie à l ’aide de la fonction define • à toute variable est attribuée une valeur initiale : syntaxe : (define variable expr)

exemples :

(define a 10) (define F 15) (define G (* 4 F))

(define-values (x y) (values 3 4))



atome• Variables (identificateurs) :

• Exemples

des varibales ne sont pas des variablesy 485forte_fievre "votre nom ?" *regles* (x)<h>_os un deux trois



liste• structure formée de plusieurs s-expressions (atomes et/ou listes)• la liste vide se note ()• Exemples

(Mieux vaut tard que jamais) (4 fois 5 eqale 20)

(((ceci est) (une liste)) ( de deux elements))


• Syntaxe de Lisp– Exemples de s-expressions

• #\A atome de type caractère constante• 100 atome de type entier• 7/8 atome de type rationnel constante• #t atome TRUE constante• #f atome FALSE constante• NULL atome NULL constante• "lisp" atome de type chaîne

de caractères constante• epsi atome de type variable variable

(symbole)• () liste vide• (()) liste à 1 élément• (* 5 6) liste à 3 éléments• (janvier fevrier (mars avril) juin (septembre octobre))

liste à 5 éléments• (define (carre x) (* x x))

liste à 3 éléments


• Evaluation des expressions– Evaluation d’un atome (constantes, variables)

Constante• valeur d’une constante = la constante elle même

Variable valeur d’une variable = la valeur courante de la variable qui doit être définie

Exemples

> 573 573> « quel est votre nom ? »« quel est votre nom ? » > (define annee-courante 2002)> annee-courante2002> mois> erreur : reference to undefined identifier: mois


• Evaluation des expressions– Evaluation d’une liste (expr0 expr1 … exprn)

Evaluation en 2 étapes• étape 1 : évaluation de expr1 … exprn puis de expr0. Si vi est est le résultat de l ’évaluation de expri Alors v0 doit être une fonction• étape 2 : application de v0 aux arguments v1 … vn

une erreur survient si v0 n ’est pas une fonction n n ’est pas le nbre d ’arguments requis par cette fonction



Exemples

> (7 9 13) erreur: 7 n ’est pas une fonction> (remainder 13 2)1> (zero? (remainder 20 5))#t>(define x 5)> (define y 10)> (define operateur /)> (operateur y x)2



Exemple : évaluation de la liste(+ 3 (sqrt 2) (* 2 3 4))

1. 1.1 Evaluation de 3

3 => 31.2 Evaluation de (sqrt 2)

1.2.1 Evaluation de 2 2 => 21.2.2

1.3 Evaluation de (* 2 3 4)1.3.1 Evaluation de 2 2 => 21.3.2 Evaluation de 3 3 => 31.3.3 Evaluation de 4 4 => 4 1.3.4 2x3x4 => 24

2. 3 + 1.414 + 24 => 28.414

2 => 1.414


• Evaluation des expressions– Evaluation d’une expression quoté

Expression quoté• (quote expr)• 'expr

quote : un moyen de suspendre l ’évaluation d ’une expression Evaluation de (quote expr) = expr Evaluation de ’expr = expr


• Evaluation des expressions– Evaluation d’une expression quoté

Exemples

> bonjour erreur : reference to undefined identifier: bonjour

> 'bonjourbonjour > ( 1 2 3 4)erreur : 1 n ’est pas une fonction

> '(1 2 3 4)(1 2 3 4)> (+ 5 7)12

> '(+ 5 7)(+ 5 7)

> ''(+ 5 7)‘ (+ 5 7)

> (quote (a b c))(a b c)

> '(a b c)(a b c)


• Evaluation des expressions– Evaluation d’une forme spéciale

Forme spéciale : une expression dont le premier élément est un mot-clef réservé L ’évaluation d ’une forme spéciale ne commence pas nécessairement par l ’évaluation de ces arguments Exemple

L ’évaluation de l ’expression (define nbre 812)provoquerait une erreur (nbre n ’est pas défini) si define n ’était un mot clef-réservé (une fonction spéciale)


• Manipulation des listes– Représentation interne des listes

les listes sont implémentées en mémoire à l ’aide de doublets de pointeurs :

CAR : Content of Adress Register CDR : Content of Decrement Register Les doublets de pointeurs sont allouées dynamiquement avec une fonction spéciale appelée cons

..CAR CDR

queue

tête

(car.cdr)

Paire pointée


• Manipulation des listes

– Représentation interne des listes (a) <=> (a.()) (2 1) <=> (2.(1.())) (3 2 1) <=> (3.(2.(1.()))) (a b c) <=> (a.(b.(c.())))


• Manipulation des listes– Fonctions de consultation

Fonction car Syntaxe : (car liste)

l ’argument évalué de car doit être une liste Evaluation : renvoie le premier élément d ’une liste Exemples

> (car (+ 7 11))car: expects argument of type <pair>; given 18> (car '(+ 7 11))+> (car '(()))()> (car '(paul . pierre))paul> (car '(paul pierre))> (car '((paul pierre) michel maurice))(paul pierre)



Fonction cdr Syntaxe : (cdr liste)

l ’argument évalué de cdr doit être une liste Evaluation : renvoie une liste privée de son premier élément Exemples

> (cdr (+ 7 11))cdr: expects argument of type <pair>; given 18> (cdr '(1 2 3 4))(2 3 4)> (cdr '(+ 1 2))(1 2)> (cdr '(a (b c)))((b c))> (car (cdr '(a (b c))))(b c)



Composition de car et de cdr Les fonctions car et cdr sont très souvent utilisées en Lisp Il existe des fonctions pour certaines compositions de car et de cdr (cdr(car(cdr '(a (b c) d)))) <=> (cdadr '(a (b c) d)) Exemples

> (cdadr '(a (b c) d))(c)> (caadr '(a (b c) d))b> (cdddr '(a (b c) d)) ()> (cadar '(a (b c) d)) erreur


• Manipulation des listes– Fonctions de construction

Fonction cons Syntaxe : (cons expr1 expr2) Evaluation :

si valeur de expr1 = a et valeur de expr2 = balors valeur de (cons expr1 expr2) = (a . b)

Exemples

> (cons 'a ' (b c d))(a b c d)> (cons 'a ’b)(a . b)>(cons 'a ())(a)> (cons '(a b) '(c d))((a b) c d)> (cons 'a (cons 'b '(c d)))(a b c d)



Fonction list Syntaxe : (list expr1 expr2 … exprn) Evaluation :

renvoie une liste dont les éléments sont les valeurs de expr1 expr2 ... Exprn(list ’a ’b ’c) <=> (cons ’a (cons ’b (cons ’c ())))

Exemples

> (list 'a ’b ’c)(a b c)>(list (+1 3) ’paul (car ’ (a b)) (symbol? ’paul))(4 paul a #t)> (list (list ’ ()))((()))



Fonction append Syntaxe : (append liste1 liste2 … listen)

Les arguments sauf le dernier qui n ’est pas une liste génère une erreur Evaluation :

concatène une série de listes

Exemples

> (append ’(a b) (’c ’d))(a b c d)>(append ’a ’(2 3))erreur : append: expects argument of type <proper list>; given a> (append ’(x y) ’z)(x y . z)


• Manipulation des listes– Fonctions de traitement

Fonction length Syntaxe : (length liste) Evaluation :

Renvoie la longueur d’une liste

Exemples

> (length ’(a b c))3 >(length ’())0> (length ’(a (b) (c d e)))3


• Manipulation des listes– Fonctions de traitement

Fonction reverse Syntaxe : (reverse liste) Evaluation :

Renvoie l’inverse d’une liste

Exemples

> (reverse ’(a b c))(c b a) > (reverse ’(a (b) (c d e)))((c d e) (b) a)


• Variables et fonctions– Définition de variables

Forme spéciale define Syntaxe : (define nom-variable expression) Evaluation :

Crée une variable globale nommée nom-variable et lui associe la valeur de expression

Exemples

> (define x (+ 2 3))> x5> (define base-de-regles ())


• Variables et fonctions– Affectations

Primitive set! Syntaxe : (set! nom-variable expression) Evaluation :

Affecte à la variable nommée nom-variable la valeur de expression

Exemples

> (define a (+ 2 3))> (+ a 5)10> (set! a (+ a 2)> a7> (set! a ’(b c))> a(b c)


• Variables et fonctions– Affectations

Primitive let Syntaxe :

(let ((var1 expr1) (var2 expr2) ...) e1 e2 … en)

Evaluation : Affecte à la variable locale nommée var1 la valeur de expr1 et à la variable var2 la valeur de expr2 …, puis évalue e1 e2 .. en et renvoie la valeur de en

Exemples

> (let ((a 12) (b 5)) (* a b))60


• Variables et fonctions– Définition de fonctions

Forme spéciale define Syntaxe :

(define (nom arg1 arg2 … argn) expr1 expr2 … exprn)avec :nom : nom de la fonction arg1, arg2, … argn : arguments formels expr1, expr2, … exprn : corps de la fonction

Evaluation : Crée une fonction nommée nom, ayant pour arguments arg1, arg2, … argn, et pour corps les expressions expr1, expr2, … exprn

Exemple

> (define (carre x) (* x x))


• Variables et fonctions– Appel de fonctions

Syntaxe : (nom arg1 arg2 … argn)avec :nom : nom de la fonctionarg1, arg2, … argn : arguments effectifs

Exemples

> (carre (+ 2 3))25> (define (trois) 3)> (trois)3


• Variables et fonctions– Fonctions anonymes

Forme spéciale lambda Syntaxe :

(lambda (p1 p2 … pn) expr1 expr2 … exprn) Intérêt :

Définir des fonctions locales temporaires qui sont souvent utilisées avec les fonctions d’application (fonctions qui prennent une fonction en argument et qui appliquent cette fonction à d ’autres arguments)

Exemples

> (define carre (lambda (x) (* x x)))

>((lambda (x y) (+ (* x x) (* y y))) 4 5)41


• Variables et fonctions– Fonctions d’application

Primitive apply Syntaxe :

(apply expr1 expr2) avec expr1 : une fonction F à n arguments et expr2 une liste ayant n éléments : (a1 a2 … an)

Evaluation : Renvoie la valeur retournée par la fonction F quand on l ’appelle avec les arguments a1 a2 … an

Exemples

> (apply carre ’(5))25


• Variables et fonctions– Fonctions d’application

Primitive map Syntaxe :

(map expr0 expr1 expr2 … exprn) avec expr0 : une fonction F à n arguments et expr1 … exprn des listes ayant n éléments : (v11 v12 … v1n), (v21 v22 … v2n) … (vn1 vn2 … vnn)

Evaluation : Renvoie la liste :( F(v11 v21 … vn1) F(v12 v22 … vn2) … F(v1n v2n … vnn) )

Exemples

> (map carre ’( 1 2 3 4 5))(1 4 9 16 25) > (map * ’(2 4 8) ’(100 50 25))(200 200 200)


• Prédicats et structures de contrôle– Notion de prédicat

• une fonction qui retourne la valeur « vrai » : #t ou « faux » : #f• une fonction qui est utilisée dans les structures de contrôle

– Prédicats de type– (null? expr) la valeur de expr est la liste vide ?– (symbol? expr) la valeur de expr est un identificateur ?– (number? expr) la valeur de expr est un nombre ?– (string? expr) la valeur de expr est une chaîne de caractères ?– (list? expr) la valeur de expr est une liste ?– ...


• Prédicats et structures de contrôle– Prédicats numériques

– (zero? expr) la valeur de expr est nulle ?– (even? expr) la valeur de expr est paire ?– (odd? expr) la valeur de expr est impaire ?– (= expr1 expr2)la valeur de expr1 est égale à celle de expr2 ?– (< expr1 expr2)la valeur de expr1 est inférieure à celle de expr2 ?– (<= expr1 expr2) la valeur de expr1 est inférieure ou égale à celle de expr2 ?

– ...


• Prédicats et structures de contrôle– Prédicats d’égalité

– = pour les nombres– char=? pour les caractères– string=? pour les chaînes de caractères– equal? pour les atomes et les listes– …

Exemples

> (equal? ’(a b c) ’(a b c))#t> (equal? ’a ’a)#t> (equal? ’(a b) ’ ((a) (b)))#f> (equal? ’(a b) ’(a b c))#f


• Prédicats et structures de contrôle– Structures de contrôle

Structure if Syntaxe : (if predicat expr1 expr2) Evaluation :

Renvoie la valeur de expr1 si predicat est vrai ou la valeur de expr2 sinon Exemple

> (define x -5)> (if (>= x 0) x (- x))5



Structure cond Syntaxe :

(cond (predicat1 expr11 expr12 … expr1n) (predicat2 expr21 expr22 … expr2n) … (predicatn exprn1 expn2 … exprnn) (else expr1 expr2 … exprn))

Evaluation : - Les prédicats sont évalués un à un jusqu ’à obtention d’une valeur « vrai »- Les expressions correspondants sont alors évaluées et la valeur de la dernière expression est renvoyée- Si tous les prédicats renvoient « faux », la liste d ’actions correspondants à else est exécutée

Exemple



Structure cond Exemple

> (define (examiner a) (cond ((< a 100) (display "trop petit")) ((> a 1000) (display "trop grand")) ((= a 0) (display "nulle")) (else (display "rien à dire")))) > (examiner 5)

trop petit> (examiner 200)rien à dire


• Prédicats et structures de contrôle– Opérateurs logiques

Opérateur and Syntaxe : (and pr1 pr2 … prn) Evaluation :

- Les prédicats sont évaluées de gauche à droite- On s ’arrête dès qu ’une évaluation produit un #f- Renvoie la valeur #f ou la valeur #t



Opérateur or Syntaxe : (or pr1 pr2 … prn) Evaluation :

- Les prédicats sont évaluées de gauche à droite- On s ’arrête dès qu ’une évaluation produit la valeur #t- Renvoie la valeur #f ou la valeur #t



Opérateur not Syntaxe : (not expression) Evaluation :

Renvoie #t si la valeur de expression = #f et vice-versa


• Les entrées/sorties– Primitives de lecture

Primitive read Syntaxe : (read [port]) Action :

Lit des données depuis le port d’entrée port Exemple

> (define (euro-franc)(let ((mf (begin (display "entrez le montant en euro : ")(read))))(display "voici l'équivalent eu franc : ")(print (* 6.55957 mf)))

)



Primitive read-char Syntaxe : (read-char [port]) Action :

Lit le caractère suivant depuis le port d’entrée port Exemple

> ((define (voyelle?)(let ((lettre (begin (display "entrez une lettre : ") (read-char)

) ))(cond ((char=? lettre #\a) (display "voyelle"))

((char=? lettre #\e) (display "voyelle")) ;... (else (display "consonne"))

))

)



Primitive read-line Syntaxe : (read-line [port]) Action :

Lit la ligne suivante suivante depuis le port d’entrée port Exemple

>(define (concat)(let ((ph1 (begin (display "entrez une première phrase : ") (read-line)

) )

(ph2 (begin (display "entrez une deuxième phrase : ") (read-line) ) ) ) (display "résulat de la concaténation de ces eux phrases : ") (display (string-append ph1 " " ph2)))

)


• Les entrées/sorties– Primitives d’écriture

Primitives write, print Syntaxe :

(write expression [port]) (print expression [port])

Action : Renvoient la valeur de expression sur le port de sortie port

Exemple

> (write "bonjour")"bonjour" > (print "bonjour")"bonjour"> (write (/ 12 3))4



Primitive display Syntaxe : (display expression [port]) Action :

Renvoie la valeur de expression sur le port de sortie port Exemple

> (display "bonjour")bonjour> (display (+ 5 8))13



Primitive newline Syntaxe : (newline [port]) Action :

Aller à la ligne dans le port de sortie port Exemple

> (define port (open-output-file "texte.wri"))> (newline port)> (close-output-port port)


• Les fichiers– Ouverture en lecture

Primitive open-input-file Syntaxe : (open-input-file "nom-fichier") Action :

Renvoie le port d’entrée créé par l’ouverture du fichier "nom-de-fichier" Exemple

> (define port (open-input-file "texte.wri"))


• Les fichiers– Ouverture en écriture

Primitive open-output-file Syntaxe : (open-output-file "nom-fichier" [arg]) Action :

Renvoie le port de sortie créé par l’ouverture du fichier "nom-de-fichier" arg peut prendre les valeurs :’error, ’replace, ’truncate, ’append

Exemple

> (define port (open-output-file "texte.wri" ’replace))


• Les fichiers– Fermeture en lecture

Primitive close-input-port Syntaxe : (close-input-port port) Action :

Ferme le port d’entrée port Exemple

> (define port (open-input-file "texte.wri"))> (close-input-port port)


• Les fichiers– Fermeture en écriture

Primitive close-output-port Syntaxe : (close-output-port port) Action :

Ferme le port de sortie port Exemple

> (define port (open-output-file "texte.wri"))> (close-output-port port)


• Les fichiers– Fin de fichier

Prédicat eof-object? Syntaxe : (eof-object? expresssion) Action :

Renvoie la valeur #t si expression est une fin de fichier Exemple

> (do ((ligne (read-line port) (read-line port)))

((eof-object? ligne)) (display ligne) (newline)

)


• Les fichiers– Ecriture dans un

fichier séquentiel

Exemple

> ((define (ecriture-fichier) (let ((port (open-output-file "toto.wri"

’replace))) (begin (display "Ecriture dans un fichier") (display "MATIERE : " port) (display "Intelligence Artificielle" port) (newline port) (display "PUBLIC : " port) (display "CS " port) (display (+ 1 1) port) (display "A" port) (newline port) (display "ANNEE : " port) (display "2001-2002" port) (newline port) (display "ETABLISSEMENT : " port) (display "EPSI" port) (newline port) (close-output-port port)

) )

)


• Les fichiers– Lecture d’un

fichier séquentiel

Exemple

> (define lecture-fichier (lambda(nom-fichier) (let ((port (open-input-file nom-fichier))) (begin (do ((ligne (read-line port) (read-line port))) ((eof-object? ligne)) (display ligne) (newline)

) (close-input-port port)

) ))

)

Documents

Chapitre IV Programmation fonctionnelle : Langage Lisp EPSI / Montpellier - Cycle CSII 2A Intelligence Artificielle