😉

i i i i i i i
I I I I I I I
I \ `+' / I
\ `-+-' /
`-__|__-'
|
------+------

"Function Description Example
+ Add (+ 2 3 4)
- Subtract (- 7 3)
* Multiply (* 12 3)
/ Divide (/ 144 12)"
Il y a de bonnes références dans les exemples, mais ça pourrait être mieux...

Par exemple:
+ Add (+ 3 4)
- Subtract (- 7 3)
* Multiply (* 12 6)
/ Divide (/ 144 12)

"(list (* 1 2) (* 3 4))"
Ça continue dans les références. Quoi que, vu que ce n'est qu'une de ses implémentations (libre) qui a pour logo une menorah et que c'est une autre implémentation non-libre qui est conseillée par la personne qui a fait le tutoriel que je suis, si ça se trouve, c'est moi qui voit des références là où il n'y en a que par hasard (ou alors un truc m'échappe).
Par contre, ce principe de mélanger programmation et donnée, à priori, je trouve que ça enlève de la clarté, faudra voir à l'usage.

À voir avec un éditeur de code ou n'importe quoi avec une police de caractère monospace et qui répète des espaces qui se suivent.

D'ailleurs, je pense que je l'ai déjà demandé, mais si Skeno pouvait ajouter un formatage genre [code]...[/code], ça serait bien.

Au cas où, j'ai refais une demande: (petit retour vers le futur au passage).

(list '(+ 3 4) '(=) (+ 3 4))
qui est un raccourci pour:
(list (quote (+ 3 4)) (quote (=)) (+ 3 4))
🤨
(eval '(+ 3 4))
ou
(eval (quote (+ 3 4)))
😲
Édition:
(quote (Cette procédure n'a jamais bien fonctionné!))
donne:
(CETTE PROCÉDURE N 'A JAMAIS BIEN FONCTIONNÉ!)
🤪

Mais 🤢: (defun (...) (...)) pour définir une fonction, (defparameter *...* ...) pour définir une variable globale (que par convention on entoure d'astérisques), (let* ... ...) pour définir une variable locale (l'astérisque c'est expliqué plus tard dans le tutoriel, aucune idée d'à quoi ça sert) et pire que tout: (setf ... ...) pour changer la valeur d'une variable, il n'y a vraiment que les vieux boomer comme Richard Matthiew Stallman pour trouver ça "élégant".
Édition: il y a une procedure nth, par exemple: (nth 11 (list 0 1 2 3 4 5 6 7 8 9 10 11 12)), normal, il y a une procédure first par exemple: (first (list 0 1 2 3 4 5 6 7 8 9)), je veux bien, mais tout ça, ça marche:
- (second (list 0 1 2 3 4 5 6 7 8 9)),
- (third (list 0 1 2 3 4 5 6 7 8 9)),
- (fourth (list 0 1 2 3 4 5 6 7 8 9)),
- (fifth (list 0 1 2 3 4 5 6 7 8 9)),
- (sixth (list 0 1 2 3 4 5 6 7 8 9)),
- (seventh (list 0 1 2 3 4 5 6 7 8 9)),
- (eighth (list 0 1 2 3 4 5 6 7 8 9)),
- (ninth (list 0 1 2 3 4 5 6 7 8 9)),
- (tenth (list 0 1 2 3 4 5 6 7 8 9)),
par contre, (eleventh (list 0 1 2 3 4 5 6 7 8 9)), ah non, on se limite à de first à tenth. Mais pourquoi prendre la peine de faire autant de procédures inutiles vu qu'il y a nth?
🤪
Autre édition: comme il n'y a rien de vraiment natif pour les booléens, NIL (qui est d'ailleurs l'équivalant d'une liste vide), c'est l'équivalant de false et tout le reste, c'est l'équivalant de true, donc, quand il faut répondre true, la réponse, c'est T.
😰
Précision: si on vérifie si NIL est une liste:
(listp NIL)
donne:
T
😥 (enfin, ça suit une logique, c'est déjà ça).
Et encore une:
(eq "..." "...") retourne NIL, il faut utiliser (string= "..." "..."), parce que eq, c'est pour les citations (qui, comme indiqué dans l'édition du précédant commentaire retourne UNE VALEUR DIFFÉRENTE DE CE QU 'ON LUI DONNE).
Re🤪!
Sans l'utilité potentiel avec Guix, je crois que je laisserais tomber l'apprentissage de ce langage.