[ Clisp ] Cons

Bonjour, voici un programme qui fonctionne parfaitement :
Code:

1 2 (set 'pocket'($ $ $ $ $ $ $ $ $ $)) (loop (cond ((not pocket) (return pocket))) (pop pocket))
Je suis cence reecrire ce meme code mais avec la fonction cons. J'ai donc fait ceci :
Code:

1 2 3 4 5 6 7 8 9 10 (set 'pocket'($ $ $ $ $ $ $ $ $ $)) (eval (cons (quote loop) (cons (quote cond) (cons (cons 'not (cons pocket nil))(cons (cons'return (cons pocket nil)) nil)) nil) (cons 'pop (cons pocket nil)) nil))
Ce code contient une erreur qui est

Code:

*** - EVAL: too many arguments given to CONS:

sauf que je n'arrive pas vraiment a resoudre cette erreur.
Si quelqu'un aurait l’amabilité de m'aider ? :D:calim2:
Je préviens, je débute entièrement en Clisp :$

Bonjour,
Tu as 2 erreurs, ton premier et deuxième cons ont plus de deux argument. La fonction cons ajoute le premier élément passé en argument en tête de liste du deuxième argument, visiblement tu l'as compris. Pour qu'un atome soit une liste il faut le "conser" avec nil, ça aussi c'est bon.
Visiblement il semble que t'as difficulté vient que tu n'as pas généralisé ce raisonnement aux listes, pour qu'une liste devienne une "sous-liste" avec un niveau de parenthèse supplémentaire, il suffit également de la "conser" avec nil.
Ta fonction devrait se définir comme ceci, à vérifier car je n'utilise pas Clisp mais un dialecte dérivé de Xlisp.
Code:

1 2 3 4 5 6 7 (cons 'loop (cons (cons 'cond (cons (cons (cons 'not (cons 'pocket nil)) (cons (cons 'return (cons 'pocket nil)) nil)) nil) ) (cons (cons 'pop (cons 'pocket nil)) nil) ) )
A+

cons ne prend que deux arguments. Or dans ton programme, tu lui en donnes 3:

1. (quote cond)
2. (cons (cons 'not (cons pocket nil))(cons (cons'return (cons pocket nil)) nil))
3. Nil

D'où l'erreur.

Tout d'abord merci de la réponse:zoubi:
Donc si j'ai bien compris fallait modifier mon code pour que les cons n'est que deux arguments donc voila ce que ça donne :
Code:

1 2 3 4 5 6 7 (eval (cons (quote loop) (cons (quote cond) (cons (cons 'not (cons pocket nil))(cons (cons'return (cons pocket nil)) nil))) (cons 'pop (cons pocket nil))))
Donc la tout me semble correcte mise a part que le tout premier cons contient 3 arguments si je ne me trompe pas :
1 - (quote loop)
2 - (cons(quote cond)(cons (cons 'not (cons pocket nil))(cons (cons'return (cons pocket nil)) nil)))
3 - (cons 'pop (cons pocket nil))

et donc j'ai toujours la même erreur. Et la je vois pas comment résoudre celle ci... :-/

J'ai tenter au lieu d'avoir un cons avec les 1,2 et 3 sortir le 3 et l'intégrer au cons plus haut tel que :
Code:

1 2 3 4 5 6 (eval (cons (quote loop) (cons (quote cond) (cons (cons 'not (cons bassine nil))(cons (cons'return (cons bassine nil))(cons 'pop (cons bassine nil)))))))
Mais j'obtiens cette erreur :
Code:

1 2 3 4 *** - LOOP: illegal syntax near COND in (LOOP COND (NOT ($ $ $ $ $ $ $ $ $ $)) (RETURN ($ $ $ $ $ $ $ $ $ $)) POP ($ $ $ $ $ $ $ $ $ $))

Un premier point: cons n'ouvre une parenthèse que lorsqu'il est au début de l'expression; à l'intérieur de l'expression, il faut deux cons pour ouvrir une parenthèse:
(cons 'a (cons 'b nil)) = '(a b)
(cons 'a (cons (cons 'b nil) nil)) = '(a (b))

Par ailleurs, il faut mettre à profit les outils qui rendent la syntaxe plus claire:
1) (quote loop) == 'loop ;; comme son nom l'indique :-)
2) utilise les niveaux d'indentation, cela fera ressortir le nombre d'arguments de tes fonctions!
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 (cons 'loop (cons (cons 'cond (cons (cons (cons 'not (cons pocket nil)) (cons (cons 'return (cons pocket nil)) nil)) nil)) (cons (cons 'pop pocket) nil)))

Bonjour,

Dans l'exemple qui vient d'être donné, il faut se méfier de la notation (cons 'pop pocket) dont le résultat est dépendant de pocket..

pocket est une liste -> on obtient une liste (a b)
pocket est un atome -> on obtient une paire pointée (a . b).

Je pense préférable la notation (cons 'pop (cons pocket nil)).
Si on se réfère à l'explication précédente de stendhal666 (cons 'a (cons 'b nil)) = '(a b), l'idéal étant même de quoter le symbole pocket pour ne pas coder l'expression en "dur", et éviter une erreur de syntaxe à l'évaluation si le premier élément définie dans Pocket n'est pas une fonction.

A+