Les symboles lisp.

:~$  rlwrap sbcl --noinform
*
Etat du symbole  *  au demarrage de sbcl :
==========================

(symbol-value '*)   =>   NIL
(symbol-name '*)  =>  "*"
(symbol-function '*)  =>   #<FUNCTION *>

symbol-value des symboles  *  **   ***  au démarrage de sbcl et après les trois actions suivantes :
============================================================

(+ 4 5)  =>   9
(print 'toto)  =>  TOTO
(print "lulu")  =>  "lulu"

on a :

symbol-value de  *   contient   "lulu"
symbol-value de  **   conient   TOTO
symbol-value de  ***   contient   9

car:
le résultat de la dernière action est mis dans la symbol-value du symbole  *
mais ce qui était dans (symbol-value '*) auparavant est mis dans (symbol-value '**)
et finalement ce qui était dans (symbol-value '**) est mis dans (symbol-value '***)
le processus se répète tant que la cession de sbcl est active (symbol-value '***)
étant remplacée par (symbol-value '**), (symbol-value '***) est perdu. (On ne va pas au delà de  ***)

Etat du symbole  + au demarrage de sbcl :
==========================

(symbol-value '+)   =>   NIL
(symbol-name '+)  =>  "+"
(symbol-function '+)  =>   #<FUNCTION +>

Après ces trois actions on a :

symbol-value de  +  contient   (symbol-function '+)
symbol-value de  ++  conient   (symbol-name '+)
symbol-value de  +++   contient   (symbol-value '+)

car:
La dernière action (pas le résultat) est mise dans la symbol-value du symbole +
et ce qui était dans (symbol-value '+) auparavant est mis dans (symbol-value '++)
et cela se pousuit  comme pour le symbole  *

Définissons le symbole mult : 
=================

(defparameter mult t)

Les trois écritures suivantes sont équivalentes:


(setf mult (symbol-function '*))
(setf mult (function *))
(setf mult #'*)

Etat du symbole mult en mémoire:
=====================



Si je fais : (mult 5 6)
j'obtiens: *** - EVAL: undefined function MULT
car eval essaye d'évaluer la list (mult 5 6) et il cherche dans la case function mais  *  est dans la case value d'où
l'erreur car dans la case function il n'y a rien.

Définissons la fonction mult par :   (defun mult (x y) (funcall mult x y))



Maintenant si je fais: (mult 5 6)  => 30 car dans la case function du symbole mult il y a la function
(x y) ---> (funcall mult x y)
funcall appelle la function  *  qui est dans la case symbol-value de mult.

Autre exemple :

(defvar foo 456)
(defun foo (x) (if (atom x) x (car x)))

Etat du symbole foo en mémoire:
=====================

Résultats de:
(symbol-name 'foo)
(symbol-value 'foo)
(symbol-function 'foo)
(symbol-plist 'foo)
(symbol-package 'foo)