Common lisp-Fehler: "sollte lambda-Ausdruck"

Ich gerade angefangen zu lernen, Common Lisp vor ein paar Tagen, und ich bin versucht, zu erstellen eine Funktion, die fügt eine Zahl in einen Baum. Ich erhalte eine Fehlermeldung,

*** - SYSTEM::%ERWEITERN Sie-FORM: (CONS NIL LST) sollte ein lambda-Ausdruck

Vom googeln um, wie es scheint, das passiert, wenn man zu viele Sätze von Klammern, aber nach einem Blick auf diese für eine Stunde oder so und ändern die Dinge um, ich kann nicht herausfinden, wo ich sein könnte, dies zu tun.

Dies ist der code, wo es passiert:

(defun insert (lst probe)
    (cond ((null lst) (cons probe lst))
        ((equal (length lst) 1)
            (if (<= probe (first lst))
                (cons probe lst)
                (append lst (list probe))))
        ((equal (length lst) 2)
            ((cons nil lst) (append lst nil) (insertat nil lst 3)
                (cond ((<= probe (second lst)) (insert (first lst) probe))
                     ((> probe (fourth lst)) (insert (fifth lst) probe))
                     (t (insert (third lst) probe)))))))

Ich bin mir ziemlich sicher, dass es die nach dem ((equal (length lst) 2), wo die Idee ist, legen Sie eine leere Liste in der vorhandenen Liste, dann fügen Sie eine leere Liste an das Ende, dann legen Sie eine leere Liste in der Mitte.

InformationsquelleAutor Zachary Wright | 2010-04-04

5

Richtig!!!! Das problem ist in der Zeile rechts nach, dass, wo es heißt
```
((cons nil lst) (append lst nil) (insertat nil lst 3) ...
```
Das Problem ist die zwei öffnende Klammern. Klammern ändern können, Sinn in speziellen Kontexten (wie die cond form, die Sie verwenden), aber in diesem Zusammenhang, die Klammern bedeuten, die normale Funktion der Anwendung, genau wie Sie wahrscheinlich gewöhnt sind. Das bedeutet, dass das erste, was nach der Klammer muss eine Funktion sein. Aus der Perspektive der äußeren Klammern, die erste Sache ist (cons nil lst), so muß das sein eine Funktion (die es nicht).

Hinweis, dass man nicht einfach entfernen Sie die Klammern, weil die cons Funktion gibt eine neue Liste zurück, wie Sie wollen, aber ändert nicht die alte Liste. Sie wollen wahrscheinlich etwas wie das:
```
(setq lst (cons nil lst))
(setq lst (append lst nil))
(setq lst (insertat nil lst 3))
...
```
- Ich glaube, Sie sind richtig - ich habe vergessen, dass die Nachteile nicht wirklich ändern in der Liste.
InformationsquelleAutor Noah Lavine

Wenn Sie Gedankenstrich die Funktion korrekt, dann kann man sehen, dass es eine extra Klammer vor CONS NIL LST.

(defun insert (lst probe)
  (cond ((null lst) (cons probe lst))
        ((equal (length lst) 1)
         (if (<= probe (first lst))
             (cons probe lst)
           (append lst (list probe))))
        ((equal (length lst) 2)
         ((cons nil lst) (append lst nil) (insertat nil lst 3)
          (cond ((<= probe (second lst)) (insert (first lst) probe))
                ((> probe (fourth lst)) (insert (fifth lst) probe))
                (t (insert (third lst) probe)))))))

In den meisten Lisp-Entwicklungsumgebungen können Sie Gedankenstrich Ausdrücken. In LispWorks, wählen Sie den gesamten Ausdruck und tun Sie m-x Indent-Region.

InformationsquelleAutor Rainer Joswig

2

Beheben Sie den Fehler sofort, können Sie einfach fügen Sie eine PROGN es vor (CONS NIL ...).
PROGN funktioniert durch Auswertung jeder form in es und die Rückgabe der Wert der letzten form in der es als seinen Wert.

Jedoch, dass Ihr Programm noch nicht tun, was Sie denke, es werde es tun (denke ich so). Sie wissen, in Common Lisp verwenden Sie die erste cons-Objekt zu repräsentieren das ganze nicht-leeren Liste, und Sie können nicht einfach ersetzen, den Kopf wider. Der bessere Weg ist, um die Rückkehr der neuen Liste als Wert der Funktion.
```
(defun insert (lst probe)
  (ecase (length lst)
    (0 (list probe))
    (1 (let ((c (first lst)))
         (if (<= probe c)
             (list probe c)
             (list c probe))))
    (2 (cond
         ((<= probe (first lst)) 
          (list probe (first lst) nil (second lst) nil))
         ((> probe (second lst))
          (list nil (first lst) nil (second lst) probe))
         (t
          (list nil (first lst) probe (second lst) nil))))))
```
Vielleicht möchten Sie (setf lst (insert lst [some-number])) wenn Sie diese Funktion verwenden.

InformationsquelleAutor Charles Lew

Du hast Recht; bei der Zeile mit "Fehler hier", es ist ein syntax-Fehler:

(defun insert (lst probe)
  (cond ((null lst) (cons probe lst))
        ((equal (length lst) 1)
         (if (<= probe (first lst))
             (cons probe lst)
             (append lst (list probe))))
        ((equal (length lst) 2)
         (#|Error is here|# (cons nil lst) (append lst nil) (insertat nil lst 3)
          (cond ((<= probe (second lst)) (insert (first lst) probe))
                ((> probe (fourth lst)) (insert (fifth lst) probe))
                (t (insert (third lst) probe)))))))

Compiler/interpreter, die form liest sich wie eine Funktion aufrufen, um die "Funktion" (cons nil list) was nicht funktioniert. Der compiler meckert hier über die Verwendung einer zusammengesetzten form in der "Betreiber" - position, die nicht ein lambda (die einzige Art von zusammengesetzten form angenommen, die position).

((cons nil lst)                         #| <-- Form in operator position |#
 (append lst nil)                       #| <-- First argument form |#
 (insertat nil lst 3)                   #| <-- Second argument form |#
 (cond ((<= probe (second lst)) (insert (first lst) probe)) #| Third argument |#
       ((> probe (fourth lst)) (insert (fifth lst) probe))
       (t (insert (third lst) probe))))

Ich würde helfen, mit re-Formulierung den Ausdruck, aber ich bin nicht sicher, was du erreichen willst hier.

InformationsquelleAutor Dirk

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.