CSI 3125, Scheme, page 1 Programmation fonctionnelle Plan: Lisp Un Resumé du Scheme Une session...

CSI 3125, Scheme, page 1

Programmation fonctionnellePlan:LispUn Resumé du SchemeUne session Scheme

Scheme:Structures de données simplesStructures de données composéesÉvaluation de fonctionsConstruction de listes et accès aux élémentsExpressions fonctionnelles et définition de fonctionscontrôleFonctions de haut niveau


Lisp

• La programmation fonctionnelle a commencé vers la fin des années 1950 (Veuillez relire la section 2.4). Plusieurs dialectes, Lisp 1.5 (1960), Scheme (1975), Common Lisp (1985)…[LISP = LISt Processor]

• [Il y a aussi d’autre langages fonctionnels: Hope, ML, Miranda, Haskell.]

• Plusieurs langages fonctionnels (dont Lisp) ont comme fondation mathématique le -calcul (lambda-calcul), un système qui permet aux fonctions d’être les valeurs d’une expression.


Lisp (2)

• Mécanismes de control fondamentaux:

– Application de fonctions

– Composition de fonctions

– Instructions conditionnelles

– récursivité

• Les structures de données sont simples:

– listes,

– atomes (symboles et nombres).


• Les programmes et données sont exprimés à l’aide de la même syntaxe:– L’application de fonctions et les instructions

conditionnelles sont écrites comme des listes, en parenthèse, avec le nom de l’instruction comme préfixe.

– Le programme et les données sont distinguées selon le contexte.

• Cette uniformité des données et du programme permettent une grande flexibilité et expressivité: – Les programmes peuvent être manipulés comme des

données.• Un interpréteur de LISP d’ une page en LISP a été à la base

de la première implémentation en bootstrapping d’un langage de programmation (une technique très puissante)

Lisp (3)


5 fonctions primitives:

• cons — construit une liste,

• car — la tête d’une liste,

• cdr — la queue d’une liste,

• eq — Égalité d’atomes (Booléenne),

• atom — Vérifie si une atome (Booléenne);

• Deux autres opérations essentielles:

– L’évaluation d’expressions,

– Appliquer une fonction aux paramètres (déjà évalués)

Lisp (4)


• Lisp est utilisé de façon interactive (comme Prolog):– Aucun programme principal,– L’interpréteur évalue les expressions et retourne leur

valeur (les expressions peuvent invoquer des fonctions très compliquées),

– Un programme Lisp est une collection de fonctions qui peuvent être invoquées directement ou indirectement par l’interpréteur.

– Toute expression est évaluée: Il faut dire explicitement à Lisp de ne pas évaluer quelque chose (avec quote)

• Un atome est traité littéralement: il n’est que lui même et n’a d’autre valeur que son nom.

Lisp (5)


Lisp 1.5 à plusieurs points faibles:

• Syntaxe peu commode (mais élégante et uniforme).

• Règles à porté dynamique [Que nous verrons plus tard]

• Traitement inconsistant des fonctions en tant que paramètres (due à la porté dynamique).

Lisp (6)


Un Resumé du Scheme

• Scheme est un sous-ensemble de Lisp.

• Il fait la distinction entre nombres et symboles

• La porté est lexicale (plutôt que dynamique)

• Corrige le problème du traitement des paramètres(grâce à la porté lexicale):

– Les fonctions sont des objets de première classe, c’est à dire qu’elles peuvent être créées, assignées à des variables, passées comme paramètres, retournées comme valeurs.

• Les structures de données, en Scheme sont simples, uniformes et versatiles. Comme pour Lisp 1.5, on les appelles S-expressions.


Le system Scheme pour ce cours

Veuillez vous connecter (via ssh) a site1, et taper scm au prompt.

% scmSCM version 5d3, Copyright (C) 1990-1999 Free Software Foundation.SCM comes with ABSOLUTELY NO WARRANTY; for details type `(terms)'.This is free software, and you are welcome to redistribute itunder certain conditions; type `(terms)' for details.;loading /usr/local/lib/slib/require;done loading /usr/local/lib/slib/require.scm;loading /usr/local/lib/scm/Transcen;done loading /usr/local/lib/scm/Transcen.scm;Evaluation took 50 mSec (0 in gc) 15992 cells work, 4000 env, 17604 bytes other>

A ce moment la, vous êtes en dialogue avec la boucle interactive supérieure. Vous pouvez, par example, taper (terms) ou (exit) ou (quit) ou vous pouvez continuer…


Une session Scheme% scm > ( cons 'alpha '( beta ) )(alpha beta) > ( symbol? 'alpha )#t > ( symbol? '( alpha ) )#f


> ( null? 'alpha )#f > ( null? () )#t

> ( number? 'alpha )#f

> ( number? 23 )#t

> ( symbol? alpha )ERROR: unbound variable: alpha; in expression: (... alpha); in top level environment.

Une session Scheme(2)


> ( define alpha 5 )

#<unspecified>

> ( number? alpha )

#t

> ( symbol? alpha )

#f

> ( cdr ( cons 'x '( y z ) ) )

(y z)

> ( cons 'x ( cdr '( y z ) ) )

(x z)

> ( + 1 2 )

3

Une session Scheme (3)


> ( define ( addOne x ) ( + x 1 ) )#<unspecified>> ( addOne ( addOne 15 ) )17

> ( define ( myAnd x y ) ( if x y #f ) )#<unspecified>> ( myAnd ( symbol? '(a) ) ( eq? 'a 'a ) )#f> ( and ( symbol? '(a) ) ( eq? 'a 'a ) )#f



> ( define ( myOr x y ) ( if x #t y ) )#<unspecified>> ( myOr ( symbol? '(a) ) ( eq? 'a 'a ) )#t> ( or ( symbol? '(a) ) ( eq? 'a 'a ) )#t

> ( eq? 'a 'a )#t> ( eq? 'a 'b )#f> ( eq? '( a ) '( a ) )#f



>( define ( numberList? x ) ( if ( not ( list? x ) ) #f ( if ( null? x ) #t ( if ( not ( number? ( car x ) ) ) #f ( numberList? ( cdr x )) ) ) ) )#<unspecified>> ( numberList? ' ( 1 2 3 4 ) )#t



>( define ( numberList? x ) ( cond ( ( not ( list? x ) ) #f ) ( ( null? x ) #t ) ( ( not ( number? ( car x ) ) ) #f ) ( else ( numberList? ( cdr x ) ) )) )> ( numberList? ' ( 1 2 3 4 ) )#t> ( numberList? ' ( 1 2 3 bad 4 ) )#f



>( define ( eqExpr? x y ) ( cond ( ( symbol? x ) ( eq? x y ) ) ( ( number? x ) ( eq? x y ) ) ; x must be a list now: ( ( null? x ) ( null? y ) ) ; x must be a non-empty list now: ( ( null? y ) #f ) ( ( eqExpr? ( car x ) ( car y ) ) ( eqExpr? ( cdr x ) ( cdr y ) ) ) ( else #f )) )

> ( eqExpr? '( a b ( c d ) ) '( a b ( c d ) ) )#t> ( eqExpr? '( a b ( c d ) ) '( a b ( c d e) ) )#f



> ( define ( member? K L ) ( cond ( (null? L ) #f ) ( ( eqExpr? K ( car L ) ) #t ) ( else ( member? K ( cdr L ) ) )) )#<unspecified>

> ( member? 'aa '( bb cc aa ee rr tt ) )#t > ( member? 'aa '( bb cc (aa) ee rr tt ) )#f



> ( define ( append L1 L2 ) ; built-in! (if ( null? L1 ) L2 ( cons ( car L1 ) ( append ( cdr L1 ) L2 ) ) ) )WARNING: redefining built-in append#<unspecified> > ( append '( ab bc cd ) '( de ef fg gh ) )(ab bc cd de ef fg gh) > ( exit );EXIT



Structures de données simples

• Nombres: entiers ou floats.

• Une variable est un nom lié à une donnée, par exemple:

(define pi 3.14159)

• Une variable a un type implicite, dépendant de sa valeur. Elle peut prendre une valeur d’un autre type:

(set! pi 3.141592)

(set! pi 'alpha)

(set! pi (cons pi '(rho)))

• Un symbole est un nom n’ayant d’autre valeur que lui même.


Structures de données composées

Le format générale d’une liste:

(E1 E2 ...... En) où Ei est une S-expression.

Dépendamment du contexte, une liste peut être traité littéralement (comme une donnée):

((William Shakespeare) (The Tempest))

ou comme une application de fonction avec les paramètres passés par valeur:

(append x y)


Une liste (E1 E2 ...... En) est produite par cons:

(cons E1 (cons E2 ... (cons En ()) ... ))

produit:

(E1 . (E2 ... (En . ( )) ... ))

On a aussi les paires ‘pointées’, peu utilisées en pratique:

cons( ) produit: ( . )

Structures de données composées (2)


Évaluation de fonctions

• Avec: une liste (E0 E1 ... En)

• Étape 1

Évalue E0 pour obtenir V0,

Évalue E1 pour obtenir V1,

......,

Évalue En pour obtenir Vn.

V0 doit être une fonction,

V1, ..., Vn sont des données.

• Étape 2

Applique V0 à V1, ..., Vn

C’est à dire, calcule V0(V1, ..., Vn).


• L’évaluation est bloquée par quote:

(quote pi) ou de façon équivalente: 'pi

• Si pi est défini ainsi:

(define pi 3.141592)

• Exemples:

(* 2.0 pi) retourne 6.283184

(* 2.0 'pi) paramètre invalide

('* 2.0 'pi) fonction invalide

(write 'pi) affiche le symbole pi

(write pi) affiche 3.141592

Quote


Construction de listes et accès aux éléments

• Les listes sont définies récursivement:

Une liste vide: (),

Une liste non-vide: (cons )

où is a list.

• La tête et la queue d’une liste:

(car (cons )) retourne

(cdr (cons )) retourne

(car ()) et (cdr ()): paramètre invalide


Une convention de notation pour accéder aux autres éléments de la liste:

(caar x) (car (car x))(cdadr x) (cdr (car (cdr x))))

Par exemple, l’évaluation suivante se fait en 4 étapes:(caadar '((p ((q r) s) u) (v)))(caadr '(p ((q r) s) u))(caar '(((q r) s) u))(car '((q r) s))'(q r)

Le deuxième élément d’une liste x — si il existe:(cadr x)

Le troisième, quatrième, ... : (caddr x), (cadddr x), ...

Accès aux éléments


• car, cdr, cons sont les fonctions primitives qui permettent l’accès aux listes. Trois autres sont des prédicats: des fonctions qui retournent #t ou #f.

• (symbol? x)

#t ssi x est un symbole symboles,

• (number? x)

– ssi x est un nombre,

• (eq? x y)

– ssi x et y sont des symboles et sont égaux.

Fonctions primitives


Autre fonctions(elle peuvent être définie à partir des primitives):

(equal? x y) vrai ssi x et y sont des objets identiques (pas nécessairement atomique)

(null? x) si x est () – la liste vide.

(append x y) concatène les listes x et y.

Autre fonctions


Une définition lie l’expression d’une fonction à un nom:

(define (square x) (* x x))

ou, de façon équivalente:

(define square

(lambda (x) (* x x)))

Le nom d’une fonction peut être évaluée:

> square

#<CLOSURE (x) #@lambda (* x x)>

Les fonctions n’ont pas nécessairement de nom!

> ((lambda (x) (* x x x)) 3)

27

Définir des fonctions


Les structures de contrôle en Scheme, comme en Lisp, sont simple. Il n’existe pas de boucles. Il y a l’application de fonctions, l’expression conditionnelle, et la séquence (une concession aux programmeurs habitués aux langages impératifs):

> (begin (print 'okay) (print '(great)))okay(great);Evaluation took [...](great)

La valeur retournée par (begin ...) est la valeur du dernier terme.

Contrôle


Instructions conditionnelles

(cond (C1 E1)

(C2 E2) ......

(Cn En)

(else En+1))

• La dernière partie, (else En+1), est optionnelle.

• (Ci Ei) représente une paire condition-expression. Les pairs sont évaluées de gauche à droite. On arrête quand on trouve un Ci qui est vrai (qui retourne #t ). On retourne le Ei correspondant.

• else est évalué comme #t.


Cas spécial: if

(cond (C1 E1) (else E2))

Peut être abrégé:

(if C1 E1 E2)


D’autre exemples de fonctions

(define (same_neighbours? l)

(cond

((null? l) #f)

((null? (cdr l)) #f)

((equal? (car l)(cadr l)) #t)

(else

(same_neighbours? (cdr l)))

) )


Pile en Scheme

(define (empty? stack)

(null? stack)

)

(define (pop stack)

(if (empty? stack)

stack

(cdr stack)

) )

(define (push el stack)

(cons el stack)

)

(define (top stack)

(if (empty? stack)

()

(car stack)

) )


Minimum d’une liste(define (minL Lst)

(if (null? Lst)

Lst

(minL-aux (car Lst)(cdr Lst))

) )

(define (minL-aux Elt Lst)

(cond

((null? Lst) Elt)

((> Elt (car Lst))

(minL-aux (car Lst)(cdr Lst)))

(else (minL-aux Elt (cdr Lst)))

) )


(define (minL-aux Elt Lst) (if (null? Lst) Elt (let ((carl (car Lst)) (cdrl (cdr Lst))) (if (> Elt carl) (minl-aux carl cdrl) (minl-aux Elt cdrl)) ) ) )

Minimum d’une liste, une variante a porte locale


>(define (quadruple x) (let ((double (lambda (x) (+ x x)))) (double (double x))) )#<unspecified>> (quadruple 8)32> (double 8)

unbound variable: double; in expression: (... double 8); in top level environment.

Un autre exemple de portée locale


> (define (quadruple x) (define (double x) (+ x x)) (double (double x)))#<unspecified>> (quadruple 8)32> (double 8)

unbound variable: double; in expression: (... double 8); in top level environment.

Un autre exemple de portée locale (2)


Fonctions de haut-niveau

Certaine fonctions prennent des fonctions comme paramètres.> (define (combine Fun1 Fun2 X) (Fun1 (Fun2 X)) )> (combine (lambda (x) (+ 1 x)) (lambda (x) (* 2 x)) 6)> (combine (lambda (x) (* 2 x)) (lambda (x) (+ 1 x)) 6)Équivalent à:> ((lambda (x) (+ 1 x)) ((lambda (x) (* 2 x)) 6))> ((lambda (x) (* 2 x)) ((lambda (x) (+ 1 x)) 6))


(define (map F Lst) (if (null? Lst) Lst (cons (F (car Lst)) (map F (cdr Lst)))) )

Fonctions de haut-niveau (2)

Un exemple classique: map, l’opération qui applique une fonction aux éléments d’une liste:

(E1 E2 ...... En) ((f E1) (f E2) ...... (f En))

Par exemple (map (lambda(x) (+ x 1)) '(1 2 3))

retourne: (2 3 4)


Une version de map qui applique la fonction à chaque éléments sans retourner la liste résultante:


(define (do-for-all F L)

(if (null? L)

L

(let ((dummy (F (car L))))

(do-for-all F (cdr L))

) ) )

Par exemple:

(do-for-all write '(1 2 3))


Voici un petit exercice:

(define (f) (lambda (x) (+ 1 x)))

Quelle est la valeur de cette fonction?



Réducteurs

Soit F une opération binaire, c’est à dire, à deux paramètres. Soit F0 une constante. On veut exprimer la

transformation suivante:

(E1 E2 ...... En)

(F E1 (F E2 (F ...... (F En F0) ...... )))

Qui s’exprime plus facilement avec une notation infixe:

(E1 E2 ...... En) E1 F E2 F ...... F En F F0


Example:

(E1 E2 ...... En) E1 + E2 + ...... + En + 0

(E1 E2 ...... En) E1 * E2 * ...... * En * 1

Reducteurs (2)

(define (reduce F F0 L)

(if (null? L)

F0

(F (car L)

(reduce F F0 (cdr L)))

) )


> (reduce + 0 '(1 2 3 4))

> (reduce * 1 '(1 2 3 4))

> (reduce (lambda (x y) (+ x y 1)) 8 '(1 2 3))

> (reduce cons () '(1 2 3 4))

> (reduce append () '((1) (2) (3)))

Reducers (3)


Noms pre-determines

Manipulation de listecarcdrconsappendlistlengthcaar, cadr, cdar, cddr, ..., caaaar, ..., cddddr

Pour définir definelambda


Logiquenot and or #t #f

Contrôleifcondelseletbegin

Arithmétique et comparaison + < - > * <= / >= max = min

Noms pré-determinés (2)


Prédicatssymbol? number? integer? real? list? null? eq? equal? procedure?

fonctions I/O write display printreadDiversloadmapquoteset!

Noms pré-déterminés (3)

CSI 3125, Scheme, page 1 Programmation fonctionnelle Plan: Lisp Un Resumé du Scheme Une session...

Documents

Transcript of CSI 3125, Scheme, page 1 Programmation fonctionnelle Plan: Lisp Un Resumé du Scheme Une session...