common-lisp
Les booléens et les booléens généralisés

Vrai et faux

Le symbole spécial T représente la valeur true dans Common Lisp, tandis que le symbole spécial NIL représente false :

CL-USER> (= 3 3)
T
CL-USER> (= 3 4)
NIL

Ils sont appelés «variables constantes» (sic!) Dans la norme, car ce sont des variables dont la valeur ne peut pas être modifiée. Par conséquent, vous ne pouvez pas utiliser leurs noms pour des variables normales, comme dans l'exemple suivant, incorrect, par exemple:

CL-USER> (defun my-fun(t)
           (+ t 1))
While compiling MY-FUN :
Can't bind or assign to constant T.

En fait, on peut les considérer simplement comme des constantes ou comme des symboles auto-évalués. T et NIL sont aussi des spécialités dans d'autres sens. Par exemple, T est également un type (le sur-type de tout autre type), tandis que NIL est également la liste vide:

CL-USER> (eql NIL '())
T
CL-USER> (cons 'a (cons 'b nil))
(A B)

Booléens Généralisés

En fait, toute valeur différente de NIL est considérée comme une vraie valeur dans Common Lisp. Par exemple:

CL-USER> (let ((a (+ 2 2)))
           (if a
               a
               "Oh my! 2 + 2 is equal to NIL!"))
4

Ce fait peut être combiné avec les opérateurs booléens pour rendre les programmes plus concis. Par exemple, l'exemple ci-dessus équivaut à:

CL-USER> (or (+ 2 2) "Oh my! 2 + 2 is equal to NIL!")
4

La macro OR évalue ses arguments dans l'ordre de gauche à droite et s'arrête dès qu'elle trouve une valeur non NIL, en la renvoyant. Si tous sont NIL , la valeur renvoyée est NIL :

CL-USER> (or (= 1 2) (= 3 4) (= 5 6))
NIL

De manière analogue, la macro AND évalue ses arguments de gauche à droite et retourne la valeur du dernier, si tous sont évalués en non-NIL, sinon arrête l'évaluation dès qu'elle trouve NIL , en la renvoyant:

CL-USER> (let ((a 2)
               (b 3))
           (and (/= b 0) (/ a b)))
2/3
CL-USER> (let ((a 2)
               (b 0))
           (and (/= b 0) (/ a b)))
NIL

Pour ces raisons, AND et OR peuvent être considérés comme plus similaires aux structures de contrôle d'autres langages, plutôt qu'aux opérateurs booléens.