Variable Bezüge in lisp

Einen anderen Neuling (Common) LISP Frage:

Grundsätzlich in den meisten Programmiersprachen gibt es ein Mittel, Funktionen zu erhalten, Referenzen auf Variablen, anstatt nur Werte, das heißt, die übergabe per Referenz statt als Wert übergeben werden. Sagen wir mal, der Einfachheit halber, ich will schreiben Sie eine LISP-Funktion, erhält eine variable und erhöht den Wert der Variablen um eins:

(defun increase-by-one (var)
  (setf var (+ var 1)))

Sich jetzt natürlich das problem ist, dass diese Funktion erhöht nur den Wert der Kopie der Variablen auf dem stack, nicht die eigentlichen original-variable. Ich habe auch versucht, um den Effekt zu erzielen durch die Verwendung von Makros, ohne viel Erfolg, obwohl ich das Gefühl, dass die Verwendung von Makros ist der richtige Weg zu gehen.

Ich traf diese Wand die ganze Zeit in LISP, und ich bin sicher, es muss ein Weg, um es oder gibt es vielleicht einen völlig anderen Ansatz, um dieses problem in LISP habe ich nicht daran gedacht? Wie sind Dinge wie diese sind in LISP?

BEARBEITEN: Mehrere Leute vorgeschlagen hat, mit incf. Ich habe nur dieses Beispiel zu demonstrieren, das problem in einer einfachen Art und Weise, war ich nicht eigentlich auf der Suche nach reimplementing incf. Aber danke für die Vorschläge sowieso.

Sie sagen "die meisten Programmier-Sprachen", sondern es gibt Sprachen mit einer solchen Funktion anderes als C++ und Perl?
Pascal ist ein anderes

InformationsquelleAutor Tamas Czinege | 2009-08-08

common-lisp lisp

23

Mit lexikalischen Umfang man nicht haben Zugriff auf Variablen, die nicht im aktuellen Bereich. Sie kann auch nicht passieren lexikalische Variablen um Funktionen direkt zu. Lisp wertet Variablen und übergibt die gebundenen Werte zu dieser Variablen. Es geht nichts über erstklassige Referenzen auf Variablen.

Denke funktionsfähig!
```
(let ((a 1))
  (values (lambda (new-value)
            (setf a new-value)) 
          (lambda () a)))
```
oben gibt es zwei Funktionen. Man kann Lesen der variable, ein weiteres schreiben der variable.

Nennen wir die erste Funktion writer und die zweite reader.
```
(defun increase-by-one (writer reader)
   (funcall writer (1+ (funcall reader))))
```
So, zu tun, was Sie wollen, der code muss a) in den Geltungsbereich oder b) haben Sie Zugang zu Funktionen, die in den Anwendungsbereich.

Auch die variable global werden könnte,.
```
(defvar *counter* 1)

(defun increase-by-one (symbol)
  (set symbol (1+ (symbol-value symbol))))
  ; note the use of SET to set a symbol value

(increase-by-one '*counter*)
```
Dies funktioniert für Globale Variablen, die durch ein symbol repräsentiert. Es funktioniert nicht für lexikalische Variablen - diese sind nicht durch ein symbol repräsentiert.

Gibt es auch ein makro INCF erhöht, dass ein 'Ort' (z.B. eine variable).
```
(incf a)
```
Aber a ist die variable im aktuellen scope.
```
(defun foo (a)
  (incf a))  ; increases the local variable a
```
Die Grenze ist hier zu sehen:
```
(defun foo (var)
  (add-one-some-how var))

(let ((a 1))
   (foo something-referencing-a))
```
Gibt es keine Möglichkeit zu passieren, einen direkten Verweis von a zu FOO.

Ist der einzige Weg, um eine Funktion. Wir haben auch umschreiben FOO, so dass es ruft die Funktion zur Verfügung gestellt.
```
(defun foo (f)
  (funcall f 1))   ; calls the function with 1

(let ((a 1))
   (foo (lambda (n)
          (setf a (+ a n)))))
   ;; passes a function to foo that can set a
```
- Super Erklärung, es hat mir sehr geholfen. Danke!
InformationsquelleAutor Rainer Joswig
9

Während Common Lisp unterstützt einen funktionalen Programmierung Stil, ist nicht der Allgemeine Fokus (Schema, während die nicht rein funktional sind, ist viel näher). Common Lisp unterstützt eine vollständig Imperativ Stil Programmierung sehr gut.

Wenn Sie feststellen, Sie brauchen, um code zu schreiben wie, dass die übliche Lösung ist ein makro:
```
(defmacro increase-by-one (var)
  `(setf ,var (+ ,var 1)))
```
Dies ermöglicht Ihnen, code zu schreiben, wie:
```
(increase-by-one foo)
```
wird noch erweitert werden:
```
(setf foo (+ foo 1))
```
bevor es kompiliert wird.
- Eine bessere Lösung ist die Verwendung INCF, vor allem, weil Ihre INSCREASE-BY-ONE ist buggy und wertet VAR zweimal.
- Das ist ein guter Punkt, mein Beispiel wäre eine bessere Veranschaulichung, wenn es verwendet setq statt setf. Die setf makro hat eine ganze Welt dahinter zu unterstützen verallgemeinerte Ort-Variablen, so dass die oben genannten increase-by-one makro ist ungeeignet für die Verwendung mit setf.
- Oliveira: Ja, das ist, warum ich war verwirrt, indem Sie ein makro-Ansatz. Obwohl ich kann nicht sehen, wie die Bewertung eine variable zweimal ein problem sein könnte. Ich meine, es ist nicht ein Ausdruck, es ist nur eine variable sowieso. Oder vermisse ich etwas?
- unterstützt Operationen wie (setf (car foo) bar) oder sogar (setf (fifth list) 42). Bei der Verwendung mit dem oben genannten makro Beispiel (fifth list) wäre zweimal beurteilt: Siehe hier für mehr Infos: supelec.fr/docs/cltl/clm/node80.html
InformationsquelleAutor Greg Hewgill

Natürlich in Lisp können Sie Ihren eigenen Weg machen-variable verweisen, wenn Sie wollen. Der einfachste Ansatz ist wie folgt:

(defstruct reference getter setter)

(defmacro ref (place)
  (let ((new-value (gensym)))
    `(make-reference :getter (lambda () ,place)
                     :setter (lambda (,new-value)
                               (setf ,place ,new-value)))))

(defun dereference (reference)
  (funcall (reference-getter reference)))

(defun (setf dereference) (new-value reference)
  (funcall (reference-setter reference) new-value))

Und dann können Sie es verwenden:

(defun increase-by-one (var-ref)
  (incf (dereference var-ref)))

(defun test-inc-by-one (n)
  (let ((m n))
    (increase-by-one (ref m))
    (values m n)))

(test-inc-by-one 10) => 11, 10

InformationsquelleAutor dmitry_vk

1

Makros sind wahrscheinlich das, was Sie wollen, weil Sie nicht zu bewerten, Ihre Argumente, so dass, wenn Sie übergeben Sie eine variable-Namen, erhalten Sie einen Variablen-Namen, nicht seinen Wert.

INCF genau das tut, was Sie wollen, also, wenn Sie google "defmacro incf" finden Sie eine ganze Reihe von Definitionen für diesen, von denen einige noch nicht richtig zu schließen. 🙂

Edit: ich wurde darauf hindeutet, INCF nicht als eine alternative zum schreiben Ihren eigenen, sondern weil es das macht, was Sie wollen, und ist ein makro, so dass Sie leicht finden können-source-code für Sie, z.B., ABCL oder CMUCL.
- Danke! Ich kannte incf durch die Art und Weise, dies war nur ein Beispiel um das problem zu demonstrieren natürlich, ich habe nicht versucht zu implementieren incf.
InformationsquelleAutor Ken
0

Ich denke, Sie sind nicht auf eines der wichtigsten Konzepte der funktionalen Programmierung - Sie sollten nicht ändern Sie den Status der Objekte, sobald Sie erstellt wurden. Ändern etwas über einen Verweis gegen, die.
- Fair genug, ich nehme an.
- Zerstörung ist Häufig in der Programmierung
- Sie sollten nicht davon ausgehen, dass ein muss Programm im funktionalen Stil in Common Lisp. Eines der schönen Dinge über es ist, dass es multi-Paradigma und nicht zwingen, einen Stil der Programmierung auf Sie. Wenn Sie möchten, um zu sehen, ein Beispiel, wo diese Tatsache ist explizit genutzt werden, um frame-einen einführenden text zur Sprache, check out D. Touretsky die "Common Lisp: A Gentle Introduction to Symbolic Computation".
- Es ist trotzdem gut unterstützt in Common Lisp, die nicht eine pure funktionale Sprache.
InformationsquelleAutor
-3

Wie ein Anfänger kam ich hierher, um herauszufinden, wie zu tun, was sollte eine triviale Prozedur in jeder Sprache. Die meisten Lösungen, die oben gepostet haben, nicht richtig funktionieren, wurde möglicherweise komplizierter als das, was erforderlich war, oder um unterschiedliche Implementierungen. Hier ist eine einfache Lösung für SBCL:
```
(defmacro inc-by-num (var num)
           (set var (+ (eval var) num)))
```
Anscheinend können Sie nicht verwenden setf b/c es schränkt den Anwendungsbereich in der Erwägung, dass set nicht. Auch Sie verwenden müssen, um eval vor var wenn man ein "argument X ist keine Zahl" - Fehler.
- Greg ' s Lösung ist viel besser, Sie laufen nicht in seltsame Risiken aufrufen von eval die ganze Zeit...
- Nein. Funktioniert das nicht so wie Sie vielleicht denken, es tut. Ich habe nicht die Zeit und den Ort hier zeigen die komplizierten Mechanismen, die geschehen, um Sie glauben zu machen, dass der Effekt, den Sie wünschen erreicht ist, also werde ich einfach ein Hinweis: die Einstellung erfolgt auf der makro-expansion der Zeit.
InformationsquelleAutor user1079212

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.