Func' programming - un blog homéopathique

- vous prendrez bien une petite cuillère de LISP ?
Chose promise, chose due : pour s’exercer à la manipulation des listes, je vous avais promis une courte introduction à LISP (Common LISP, le dialecte le plus utilisé de LISP, pour être précis). Une courte introduction suffira car la syntaxe de LISP est d’une simplicité désarmante, accessible, selon la légende, à un enfant de quatre ans. Je la simplifierai encore un peu ; donc si vous avez plus de trois ans, ce billet est pour vous.

J’espère que vous avez trouvé sans peine un EDI pour LISP. Ouvrez-le, et rendez-vous dans la REPL (Read Eval Print Loop : boucle de lecture, d’évaluation et d’affichage) pour tester vos nouvelles connaissances.

Une syntaxe pour les enfants
Les programmes de LISP sont composées d’expressions, qui sont soit des atomes (nombres, caractères, symboles, etc.) soit des listes. Les listes sont composées à leur tour d’expressions, placées entre une parenthèse initiale et une parenthèse finale.
Exemples :
atomes : 1 1.5 #\a a ; ; respectivement : un entier, un nombre à virgule flottante, un caractère et un symbole
listes : () (1 2 3) (1 1.5 #\a a) ; ; les listes peuvent être vides, être homogènes ou hétérogènes

Les règles d’évaluation sont tout aussi simples : l’évaluation d’un atome renvoie cet atome, sauf lorsqu’il s’agit d’un symbole ; alors, c’est la valeur attribuée au symbole qui est renvoyée :

CL-USER> 1
1
CL-USER> 1.5
1.5
CL-USER> #\a
#\a
CL-USER> (setf a 10) ;; setf affecte une valeur au symbole
10
CL-USER> a
10

Pour qu’une liste soit évaluée, son premier élément doit être une fonction ; les éléments suivants sont les arguments de la fonction :

CL-USER> (cons 1 ()) ; ; cons est le constructeur de liste. () est l’ensemble vide, le pointeur null
(1)
CL-USER> (cons 1 (cons 2 ()))
(1 2)
CL-USER> (cons 1 (cons 2 (cons 3 ())))
(1 2 3)

Apostrophe ta liste !
Si vous ne souhaitez pas que la REPL évalue la valeur que vous lui donnez, il faut la précéder d’une apostrophe. C’est le cas, par exemple, lorsque votre liste est une structure de donnée, pas une expression à évaluer :

CL-USER> '(1 2 3)
(1 2 3)
CL-USER> '(cons 1 (cons 2 ()))
(CONS 1 (CONS 2 NIL)) ; ; cons n’est pas évalué comme fonction !
CL-USER> (1 2 3) ; ; oups !
Car of (1 2 3) is not a function name or lambda-expression.
[Condition of type CCL::SIMPLE-PROGRAM-ERROR]

Bizarre, mais correct
Voilà, vous connaissez tout de la syntaxe de LISP ! Maintenant il suffit de s’habituer. La plupart des opérateurs dans les autres langages sont – ou se comportent comme – des fonctions dans LISP. Ainsi :

CL-USER> (+ 1 2)
3
CL-USER> (* 3 3)
9
CL-USER> (< 4 5) ; ; T est l’équivalent de true en C
T
CL-USER> (> 3 6) ; ; Nil est à la fois le booléen false et l’ensemble vide : Nil <=> ()
NIL

Souvent fonction varie
Certaines fonctions peuvent prendre un nombre variable d’arguments :

CL-USER> (+ 1 2 3 4 5)
15
CL-USER> (< 1 3 5 7 9) ; ; peut s’utiliser pour voir si les arguments sont ordonnés
T

Et « if » -qui n’est pas vraiment une fonction- prend 2 ou 3 arguments :

CL-USER> (if (< 3 2) 'what? 'ok!) ; ; (if condition then else)
OK!
CL-USER> (if (< 3 2) 'what?) ; ; s’il n’y a que deux arguments, le troisième (else) est Nil par défaut
NIL

Une première fonction
Pour reprendre l’exemple du calcul de la longueur d’une liste, voilà comment cela pourrait être rédigé en LISP :

NB : defun définit une fonction. Ses arguments sont : 1) le nom de la fonction 2) la liste des arguments 3) le corps de la fonction.
Rappel : cdr renvoie la suite de la liste
CL-USER> (defun longueur (lst)

(if (null lst) ;; null renvoie T si son argument est Nil / ()

0
(+ 1 (longueur (cdr lst)))))

LONGUEUR
CL-USER> (longueur '(1 2 3))
3
CL-USER> (longueur ())
0

Dans le prochain billet, nous approfondirons un peu LISP et les listes, et introduirons les fonctions lambda. Avec ce bagage, dans le billet d'après, nous jouerons un peu au poker...

Exercices:
- définir une fonction pour calculer la somme d'une liste ( "car" pour accéder au premier argument )
- définir une fonction pour retirer un élément d'une liste
- réfléchissez au nombre de règles nécessaires pour décrire la syntaxe de votre langage favori (le C++ par exemple );