Cours ParadigmesProg

Paradigmes de Programmation
Prog. Fonctionelle & Logique
cheikh2.ba@ugb.edu.sn
Description
● Présenter les concepts fondamentaux des
langages
● Familiariser l'étudiant avec différents paradigmes
de programmation
● Étude des paradigmes de programmation
fonctionnel et logique (dans une moindre mesure)
● Illustration et mise en évidence des techniques de
programmation propres à ces paradigmes
UGB / L3 INFO Cours Paradigmes de Programmation 2

Plan Général
I. Programmation & Langages
Un peu d’histoire
La machine de Turing
Pseudo-Code
Transformation du code source
Paradigmes de programmation
II. Programmation Fonctionnelle & LISP
III. Programmation Logique & PROLOG
Programmation & Langages
➢ Un peu d’histoire ….
1936, Alan MathisonTuring (Machine de Turing) : 1er calculateur universel
programmable (modèle abstrait). Invention des concept de programmation.
1948, Konrad Zuse considère son langage Plankalkül comme étant le 1er
langage de haut niveau
Des centaines (voire des milliers) de langages : généraux et très spécialisés

➢ Évolution des langages informatiques
1ère génération: Langage

machine ou code machine
● Langage natif d’un processeur
● Instructions et données à traiter codées en binaire
● Seul langage qu’un ordinateur peut traiter directement
● Chaque processeur possède son propre langage
machine.
Représentation hexadécimale d’un programme pour ajouter les

valeurs de 2 cases mémoires et stocker le résultat dans une 3ème case.

2ème génération: Langage

assembleur
● Code plus lisible et compréhensible par un plus grand
nombre.
● Il existe un langage assembleur par type de processeur
● Reste utilisé dans le cadre d’optimisation, mais a été
supplanté en popularité par les langages plus accessibles
Programme précédent écrit en assembleur

3ème génération: Langages de

haut niveau
● Syntaxe proche des langues parlées
(anglais le plus souvent)
● Ne dépendent plus du processeur, mais
d’un compilateur spécifique du processeur.
● La plupart des langages actuels sont de
3ème génération : Ada, Algol, Basic, Lisp,
Cobol, Eiffel, Fortran, C, C++, Java, Perl,
Python, Pascal, Ruby, ...
Pour ces 3 premières générations, l’informatique reste un domaine de spécialiste

4ème génération : Langages descriptifs
● Syntaxe proche des langues naturelles

● L’utilisateur ne se préoccupe pas des moyens
pour accéder ou données, il ne se préoccuppe
que de la donnée elle même.
● Permet d’écrire des programmes avec peu de
code (s’exécutent plus lentement et sont plus
gourmands en ressources).
● L’informatique n’est plus un domaine de
…...
spécialiste.
● Très fortement liés à un domaine (Bases de
données, Maths, Statistiques, ...)
5ème génération
● Destinés à résoudre des problèmes à l’aide de contraintes, et non d’algorithmes écrits.
● Reposent beaucoup sur la logique, et particulièrement utilisés en Intelligence Artificielle
● Un exemple en Prolog (langage parmi les plus connus)
Père (tom, X). ?????

Plan Général
Un peu d’histoire
Pseudo-Code
● Machine théorique (abstrait) du fonctionnement des
appareils mécaniques de calcul (tel un ordinateur).
● Modèle toujours largement utilisé en informatique
théorique (complexité algorithmique, calculabilité).
● Composition :
(1) Un ruban infini divisé en cases consécutives. Chaque case
contient un symbole d’un alphabet fini. L’alphabet contient un
symbole spécial appelé « blanc » et un ou plusieurs autres
symboles. Le ruban est supposé être de longueur infinie vers la
gauche ou vers la droite. Les cases du ruban contiennent par
défaut le symbole « blanc ».
(2) Une tête de lecture/écriture qui peut lire et écrire les symboles
sur le ruban, et se déplacer vers la gauche ou vers la droite.
(3) Un registre d’état qui mémorise l’état courant de la machine.
Le nombre d’états est toujours fini, et il existe un état initial.
(4) Une table d’actions qui indique quel symbole écrire, comment
déplacer la tête (← ou →), et quel est le nouvel état, en fonction
du symbole lu et de l’état courant de la machine. Si aucune
action n’existe pour une combinaison, la machine s’arrête.
● Définition formelle :
Si la machine est dans l’état q1 et qu’elle lit le symbole x,

alors elle écrit y à la place de x, va dans l’état q2,
puis déplace sa tête de lecture vers la gauche.

● Exemple : doubler le nombre de ‘1’, en intercalant un ‘0’ entre les deux séries.
Par exemple, « 111 » devient « 1110111 ».
● Alphabet {0, 1}, ‘0’ étant le symbole « blanc ». On suppose que le ruban contient une série de ‘1’,
et que la tête de lecture/écriture se trouve initialement au dessus du ‘1’ le plus à gauche.
● Ensemble des états : Q = {e1, e2, e3, e4, e5}. L’état initial est e1.

TM (« 11 ») = « 11011 »

● Machine de Turing Universelle :
une machine de Turing pouvant
simuler n’importe quelle machine de
Turing sur n’importe quelle entrée.
● Une MTU prend en entrée la

description de la machine à simuler
et l’entrée de cette dernière.
● Les problèmes résolubles par une Exercices Machine de Turing :

MTU sont exactement les problèmes
résolubles par un algorithme ou par (1) Définir une machine de Turing permettant de
construire la suite infinie 101010101 … La machine
une méthode concrète de calcul contient un ruban vide infini (initialement).
(thèse de Church-Turing)
● Les travaux de Alonzo Church ont (2) Définir une machine qui multiplie par 2 son entrée
beaucoup influencé les langages de binaire écrite sur le ruban, en sachant que multiplier
programmation fonctionnelles. par 2 un nombre binaire consiste à ajouter un ‘0’ à la
fin du nombre.
Plan Général
Un peu d’histoire
Pseudo-Code
Pseudo-code
● Également appelé Langage de Description d’Algorithmes, est une façon de
décrire un algorithme, sans référence à un langage de programmation.
● Permet de développer une démarche structurée, en « oubliant »
temporairement la syntaxe rigide d’un langage de programmation.
● Pas de convention universelle, mais il y a des bonnes pratiques (nom, entrées,
sorties, pre/post conditions, indentation, ...).

Plan Général
Un peu d’histoire
Pseudo-Code
● Le code source n’est presque jamais utilisable tel quel, parce que
généralement écrit dans un « langage de haut niveau ».
● Il existe deux stratégies de traduction, ces deux étant parfois disponibles au
sein du même langage (semi-compilé ou semi-interprété).
(1) L’interprétation ou la compilation à la volée : les instructions sont traduites (compilées) au
fur et à mesure qu’elles se présentent. Un principal avantage est une certaine portabilité.
(2) La compilation : l’ensemble des instructions est traduit en langage machine, constituant ainsi
un second programme (un second fichier) distinct du 1er. Ensuite, ce second programme est
exécuté. Un avantage est la rapidité à l’exécution par rapport aux langages interprétés.

Plan Général
Un peu d’histoire
Pseudo-Code
Paradigmes

Paradigmes
● Un paradigme de programmation est une façon d’approcher la programmation.
● C’est une façon de programmer, un modèle qui oriente notre manière de penser pour
formuler et résoudre un problème (À noter que d’autres axes de classification existent)
● Il s'oppose à la méthodologie, qui est une manière d'organiser la solution des
problèmes spécifiques du génie logiciel.
● Certains langages sont conçus pour supporter un paradigme en particulier, alors que
d'autres supportent des paradigmes multiples.

Paradigmes
● Programmation Impérative : décrit les opération en séquences d’instructions exécutées.

Donc on décrit le « comment ? »
● Procédurale : se fonde sur le concept d’appel procédural (routine, sous-routine, fct).
● Orientée Objet : consiste en la définition et l’interaction de briques logicielles (objets).
● Etc …
● Programmation Déclarative: programmation dans laquelle on décrit le « quoi ? », c’est à

dire le problème, sans se soucier du « comment ? ».
● Fonctionnelle : considère le calcul en tant qu’évaluation de fonctions mathématiques.
● Logique : décrit des applications à l’aide d’un ensemble de faits et de règles logiques.
● Requêtage : destinées à interroger ou manipuler une base de données.
● Etc ...
Plan Général
Un peu d’histoire
Pseudo-Code
Plan Prog. Fonct. & LISP
(1) Historique et généralités.
(2) Syntaxe et évaluation.
(3) Fonctions
(4) Structures de contrôle & formes syntaxiques
(5) Structures de données et bibliothèques
(6) Programmation en LISP
I/O, manipulation de listes, récursions, fonctions (locales,
d’arité variable ..), fonctions d’ordre supérieur, macros, ...
(7)
LISP – CLISP (Common Lisp)
Historique CLISP
Langage conçu par John McCarthy entre 1956 et 1959
pour des applications liées à l’IA (avec Fortan l’un des
plus vieux langages encore utilisés).
« List Processing » - « traitement de listes ».
Issu de la théorie du Lamda-Calcul de Church.
Dans les années 70, dialectes Interlisp et Maclisp.
Aussi : Standard Lisp, Le Lisp, etc …
Travail pour uniformiser les dialectes : Common Lisp
Normalisé par ANSI (organisme de normalisation) en
1994.
C’est une spécification de LISP, donc plusieurs
implémentations dont SBCL (Steel Bank CL), CLISP, etc.
LISP – CL (Common Lisp)
Pourquoi CL ?
Langage très riche : fonctionnel, symbolique, orienté
objet (CLOS), impératif (langage multi-paradigmes)
Syntaxe et sémantique simples et uniformes
Langage programmable (macros, reader macros)
Représentation de programmes sous la forme de
données (pas de distinction entre données et prog.)
Programmation par objets plus puissante qu’avec
d’autres langages
Normalisé par ANSI

Logiciels/Entreprises utilisant CL

Programmation fonctionnelle
CL est un langage multi-paradigmes, mais ses ancêtres
étaient purement fonctionnels.
Programmation fonctionnelle :
Entité de base = fonction
Pas d’effet de bord (pas de variables)
Structure de contrôle = si-alors-sinon + récursivité
Pour obtenir rapidement des programmes corrects, il
faut utiliser le fonctionnel le plus possible.
Programmes plus faciles à tester et bottom-up
Les paramètres sont souvent des fonctions.
Inconvénients : efficacité.

CL – Syntaxe – « S-expression »
Comme tout langage de la famille Lisp, CL utilise des S-expressions
pour dénoter à la fois le code et certaines structures de données
Un premier aperçu de S-expressions & de leurs évaluations ▼↓

CL – Syntaxe
Commentaires : « ; » et « #| … |# » sur plusieurs lignes
Casse : non sensible. Usage du minuscule. CL traduit tout en majuscule.
Atome
Symbole : Objet nommé, rôle des id. habituels, mais en plus général.
Exemples : x, azerty, 3.14pi, a!, moy_notes, nil, t, ...
Constante : "123", () ~ nil, 3.1415, 4, 6/7, "X,Y", #\A, #\Backspace, ...
Liste : séquence d’expressions entre parenthèses. (), (A B C), (+ 3 4),
(A, B, C), (A "123" (a b c) "123" D), … séparées par des espaces.
S-expression :
Liste vide ()
Liste non vide (une suite de S-expressions).
(A (B (C D) E) F) : combien d’éléments dans cette liste ?
CL – Évaluation (1/3)
Lisp est un langage interactif (boucle REPL : Read-Eval-Print LOOP)
Lisp est basé sur l’évaluation des expressions
Atome :
Constante (Objet auto-évaluant): l’évaluation retourne la constante.
1231 →1231 ; 6/8 →3/4 ; "hello" →"hello" ; 2 + 3 →3 ??? (REPL !)
+ 2 3 → ?? ?
Symbole : considéré comme une variable, donc retourne la valeur
nil →NIL ; t →T ; x →23 (« x » précédemment défini et instancié à 23)

Expression composée (liste non vide) : interprétation de la liste comme
une expression en notation préfixée (polonaise), totalement parenthésée.
(op e1 e2 …. en)
Le 1er élément est considéré comme une fonction, une macro ou un opérateur
spécial (if, let, ...). Erreur dans la cas contraire.
Les autres sous-expressions sont les arguments.

Expression « quotée »
Protège les symboles de l’évaluation (utiliser un symbole pour lui même)
(quote expr) ou ‘expr

Fonctions (1/3)
Contrairement aux langages « habituels », tout est fonction : pas de différence entre
opérateurs, mots-clés, procédures et fonctions.
Plusieurs catégories de fonctions :
Les « vraies » fonctions : l’essentiel des fonctions, prédéfinies ou définies
Globales : introduites par « defun »
Locales : introduites par « labels »
Anonymes ou λ-fonctions (lambda fonctions)
Les formes syntaxiques : ou formes spéciales, destinées à réaliser ce qui ne

peut l’être avec les « vraies » fonctions.
Prédéfinies et principes d’évaluation propres à chacune.
If, quote, defun, let, cond, labels, flet, etc.
Les macros : puissant mécanisme pour étendre la syntaxe standard de LISP.

Fonctions (2/3)
Fonction globale :
Forme syntaxique « defun » (qui n’évalue aucun de ses arguments)
( defun <nom> <liste-param> <corps-fonction>)
<corps-fonction> est le corps de la fonction
<liste-param> est la liste des paramètres, constitués de, dans l’ordre
De paramètres obligatoires. De type positionnel.
Suivis éventuellement de paramètres optionnels, préfixés par &optional. De type positionnel.
Ou bien de paramètres passés par mots-clés, préfixés par &key. De type non positionnel.
Et finalement d’un paramètre lié à la liste des arguments restants, préfixé par &rest.
λ-fonctions :
Fonctions anonymes. Héritage du λ-calcul.

Au delà du style, apporte plus de concisions dans certaines situations (comme les map)
( (lambda (x) (* x x)) (+ 2 3) ) ; ⇒ 25

Fonctions (3/3)
Passages de paramètres: (defun test-param (x y z) (list x y z))
(x y &optional z k l ...)
Comme pour &optional, on peut avoir des valeurs par défaut pour &key
On peut utiliser ensemble &optional puis &rest
Il est en revanche dangereux de combiner &key avec les deux autres.

Struct. de contr. & Formes syntax. (1/4)
« quote » ou « ‘ »: Évite l’évaluation d’une expression (devient une donnée)
« if » : « if <condition> <alors> <sinon> », renvoie <alors> XOR <sinon>
« cond » : une alternative à if, pour éviter des imbrications multiples de if.
«case» : permet de comparer une valeur à des constantes successives.

(keyi) peut être une liste de valeurs
«defun»
Etc ...
La récursion: structure de contrôle la plus communément utilisée en Lisp.
L’itération:
« Loop » est le built-in et le plus courant. Mais il y en a plusieurs. À tester ….

Variables: Deux types de variables, lexicales (locales) et dynamiques (globales)
Cette correspondance avec les autres langages (locale, globale) est approximative.
let, prog, defparameter, defvar, setq, setf
Lisp est typé dynamiquement (code pas annoté pour indiquer le type d’une variable).
Variables lexicales (locales): let, let*, prog et prog*

« let » parallèle et « let » séquentiel (let*)
Même logique pour prog.

Variables: Deux types de variables, lexicales (locales) et dynamiques (globales)
Cette correspondance avec les autres langages (locale, globale) est approximative.
let, prog, defparameter, defvar, setq, setf
Lisp est typé dynamiquement (code pas annoté pour indiquer le type d’une variable).
Variables dynamiques (globales): defparameter et defvar. Modif : setq, setf

« defparameter » exige une valeur initiale, contrairement à defvar
« setf » peut être vue comme une « surfonction » de « setq »

Struct. de Donneés & Bibliothèque (1/3)
Typage dynamique et prédicats :
LISP est typé dynamiquement, donc vérification en runtime.
Mais LISP fournit pour chaque type un prédicat :
Fonction à valeur booléenne, à un paramètre, pour vérifier son type.
À part quelques contre-exemples (atom, null), le nom du prédicat est formé par le nom du type
suffixé par « p » : integerp, stringp, numberp, floatp, ...
Si le nom du type contient déjà un « - », le suffixe est « -p » : standard-char-p, ...

Les Listes
LISP se traduit par « LISt Processing ». Inventé pour manipuler des listes (de symboles)
Moqueries : « Lots of Irritating and Silly Parentheses », « Lots of Insipid and Stupid
Parentheses », « Langage Informatique Stupidement Parenthésé » , « Langage Insipide Saturé
de Parenthèses ».
Conçu à la base pour manipuler ses propres programmes

3 primitives : deux d’analyse (car, cdr) et une de synthèse (cons)
car : retourne le premier élément d’une liste. ~ first.
cdr : retourne le reste d’une liste. ~ rest.
cons : construit une liste à partir d’un élément et d’une liste.
« c*r » : cadr = (car (cdr -)). caddr = (car (cdr (cdr -))), etc ...
Prédicats :
atom retourne vrai (T) si son argument est un atome.
consp retourne vrai (T) son argument est une liste non vide.
listp retourne vrai (T) si son argument est une liste.
null retourne vrai (T) si son argument est la liste vide.
Tests d’égalité
Nombreuses fonctions d’égalité :
« eq » : égalité physique de représentation (comparaison de la représentation physique en bits).
« = » : égalité numérique. Peu importe le type.
« eql » : égalité physique, de numériques ou de caractères (sensibilité au type et à la casse)
« equal » : égalité logique d’objets généraux (comme les listes, chaînes, ...)
Une égalité par grand type de données. « string-equal » pour les chaînes par exemple.

Programmation en LISP (1/X)
Un exemple de chargement de fichier
Fonction « load » ⇒⇒⇒
I/O – Entrée/Sortie
Plusieurs primitives avec des fonctionnalités très
riches : read*, prin*, pprint, write*, format, ...

Récursion simple
Chaque activation ne conduit qu’à un seul appel récursif.
Il peut y avoir plusieurs appels récursifs, mais un seul est activé
à chaque fois.
Récursion double
Fonction récursive dont une activation
peut conduire à deux appels récursifs.
Les récursions sur les arbres binaires
sont en général doubles.

Programmation en LISP (3/X) Simulation de la
pile d’exécution
Récursions terminale et enveloppée
La descente des deux fonctions est similaire (chaque appel prend le reste – cdr). Les remontées
sont par contre différentes : length ajoute 1 à chaque étage, alors que member remonte toujours
la même valeur. member pourrait donc retourner sa valeur directement !
length est obligée de consommer de la pile, ce qui n’est pas forcément le cas pour member ….
Cela dépend des implémentations (politiques d’optimisation).
Explication : l’appel récursif de length est enveloppé par un appel de la fonction « + ». On parle
de récursion enveloppée (length) et de récursion terminale (member).
Par exemple, « fact », récursion enveloppée : « (fact 100000) » risque de casser la pile même si la fonction
a une complexité linéaire et Lisp a une arithmétique en précision infinie.
Terminalisation d’une récursion enveloppée : possible dans certaines situations.

Le principe est d’ajouter un paramètre supplémentaire (accumulateur) auquel on applique l’enveloppe.
« (fact n <param-init>) » …. et <param-init> fera remonter le résultat. (Cf TD).
Fonctions locales …. labels
Le schéma de terminalisation pose un problème d’interface fonctionnelle (API).
Être obligé d'appeler (length ‘(1 2 3) 0) sous prétexte qu’elle a été écrite en
récursion terminale n’est pas raisonnable.
Écrire une fonction globale lengtht et définir length par
n’est pas beaucoup mieux puisque lengtht reste toujours accessible dans l’API.
La bonne solution est de définir une fonction locale : forme syntaxique labels.
Le 1er paramètre est une liste de définitions de fonctions (qui peuvent être récursives
et s'appelers entre elle) : d’où la double « ( » …
Le reste constitue le corps. tion ?
λ-fonc
Fonctions d’arité variable (1/2)
Comment définir la fonction « somme » pouvant prendre en entrée un nombre quelconque
de paramètres ? Elle renvoie 0 en cas d’appel dans paramètre.
Proposez une solution.
La solution suivante est-elle correcte ? La Signature ?
Exécutez-là ou simuler son exécution : « (somme) ; (somme 1) ; (somme 1 2 3) »
Quel est le problème ?

Fonctions d’arité variable (2/2)
Une solution : « apply » (à voir dans partie « fonctions d’ordre supérieur »)
Cette fonction a le double rôle de permettre d’appliquer une fonction que l’on ne connaît
pas ou d’appliquer une fonction à des arguments que l’on ne « connaît » pas.
Une autre solution : utiliser une fonction locale : « labels »

Fonctions d’ordre supérieur – Valeurs fonctionnelles.
Une valeur fonctionnelle s’obtient à partir d’un nom de fonction ou d’une λ-fonction en leur
appliquant la forme syntaxique: « function ».
Ex : (function car) ou (function (lambda (x) x)).
Le résultat est une valeur de type « function » qui vérifie le prédicat « functionp »
« function » s’abrévie en « #’ » (comme le couple « quote, ‘ »)

Fonctions prédéfinies d’ordre supérieur (1/X).
Une fonction d’ordre supérieure est une fonction qui prend une fonction en
paramètre.
Lisp prédéfinit un ensemble de fonctions divisées en 3 groupes :
(1) Appliquer une fonction à des arguments : « apply », « funcall »
(2) Fonctions de mapping (« map », « mapcar », «maplist», « mapc », ...) et

de séquence (« reduce », « some », « every », etc.)
(3) Argument de fonction optionnel (« &optional », « &key »). ???

(1) Appliquer une fonction à des arguments : « apply », « funcall »
Différence avec « apply » : « funcal » : arguments individuels seulement.

Tous les appels suivants sont équivalents !

(2-1) Fonctions de mapping (map, mapcar, maplist, mapc, mapcan, mapcon)
Permettent d’appliquer une fonction aux éléments successifs d’une ou plusieurs listes …
autant de listes que la fonction argument a de paramètres.
Les différences sont sur ce qu’elles retournent et sur le choix des éléments de la liste.

(2-2) Fonctions de séquence (reduce & some, every, ...)

(3) Argument de fonction optionnel : (« &optional », « &key »).
En plus des précédentes fonctions, plusieurs fonctions de la bibliothèque standard ont
des arguments fonctionnels dont la valeur doit être fonctionnelle.
Par exemple, pour « member », il est possible de préciser
Avec le mot-clé « :test », la fonction d’égalité à utiliser (par défaut eq ou eql ?)
Avec le mot-clé « :key », la fonction à appliquer à la valeur à appliquer.


Cours ParadigmesProg

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Cours ParadigmesProg

Transféré par

Droits d'auteur :

Formats disponibles

Paradigmes de Programmation

Prog. Fonctionelle & Logique

UGB / L3 INFO Cours Paradigmes de Programmation 2

Des centaines (voire des milliers) de langages : généraux et très spécialisés

1ère génération: Langage

Représentation hexadécimale d’un programme pour ajouter les

UGB / L3 INFO Cours Paradigmes de Programmation 5

2ème génération: Langage

Programme précédent écrit en assembleur

UGB / L3 INFO Cours Paradigmes de Programmation 6

3ème génération: Langages de

Pour ces 3 premières générations, l’informatique reste un domaine de spécialiste

4ème génération : Langages descriptifs

● Syntaxe proche des langues naturelles

UGB / L3 INFO Cours Paradigmes de Programmation 10

Si la machine est dans l’état q1 et qu’elle lit le symbole x,

UGB / L3 INFO Cours Paradigmes de Programmation 14

UGB / L3 INFO Cours Paradigmes de Programmation 15

UGB / L3 INFO Cours Paradigmes de Programmation 16

● Une MTU prend en entrée la

● Les problèmes résolubles par une Exercices Machine de Turing :

UGB / L3 INFO Cours Paradigmes de Programmation 19

UGB / L3 INFO Cours Paradigmes de Programmation 21

UGB / L3 INFO Cours Paradigmes de Programmation 23

UGB / L3 INFO Cours Paradigmes de Programmation 24

● Programmation Impérative : décrit les opération en séquences d’instructions exécutées.

● Programmation Déclarative: programmation dans laquelle on décrit le « quoi ? », c’est à

UGB / L3 INFO Cours Paradigmes de Programmation 29

UGB / L3 INFO Cours Paradigmes de Programmation 30

UGB / L3 INFO Cours Paradigmes de Programmation 31

Un premier aperçu de S-expressions & de leurs évaluations ▼↓

UGB / L3 INFO Cours Paradigmes de Programmation 32

Lisp est basé sur l’évaluation des expressions

UGB / L3 INFO Cours Paradigmes de Programmation 34

UGB / L3 INFO Cours Paradigmes de Programmation 35

UGB / L3 INFO Cours Paradigmes de Programmation 36

Anonymes ou λ-fonctions (lambda fonctions)

Les formes syntaxiques : ou formes spéciales, destinées à réaliser ce qui ne

Les macros : puissant mécanisme pour étendre la syntaxe standard de LISP.

UGB / L3 INFO Cours Paradigmes de Programmation 37

Fonctions anonymes. Héritage du λ-calcul.

UGB / L3 INFO Cours Paradigmes de Programmation 38

UGB / L3 INFO Cours Paradigmes de Programmation 39

«case» : permet de comparer une valeur à des constantes successives.

UGB / L3 INFO Cours Paradigmes de Programmation 41

Variables lexicales (locales): let, let*, prog et prog*

UGB / L3 INFO Cours Paradigmes de Programmation 42

Variables dynamiques (globales): defparameter et defvar. Modif : setq, setf

UGB / L3 INFO Cours Paradigmes de Programmation 43

UGB / L3 INFO Cours Paradigmes de Programmation 44

Conçu à la base pour manipuler ses propres programmes

UGB / L3 INFO Cours Paradigmes de Programmation 46

UGB / L3 INFO Cours Paradigmes de Programmation 47

UGB / L3 INFO Cours Paradigmes de Programmation 48

Terminalisation d’une récursion enveloppée : possible dans certaines situations.

UGB / L3 INFO Cours Paradigmes de Programmation 51

Une autre solution : utiliser une fonction locale : « labels »

UGB / L3 INFO Cours Paradigmes de Programmation 52

UGB / L3 INFO Cours Paradigmes de Programmation 53

Lisp prédéfinit un ensemble de fonctions divisées en 3 groupes :

(1) Appliquer une fonction à des arguments : « apply », « funcall »

(2) Fonctions de mapping (« map », « mapcar », «maplist», « mapc », ...) et

(3) Argument de fonction optionnel (« &optional », « &key »). ???

UGB / L3 INFO Cours Paradigmes de Programmation 54

Variables lexicales (locales): let, let, prog et prog