Warum zieht es die Lisp-Community vor, alle Klammern am Ende der Funktion zu akkumulieren?

Warum zieht es die Lisp-Community vor, alle Klammern am Ende der Funktion zu akkumulieren:

(defn defer-expensive [cheap expensive]
  (if-let [good-enough (force cheap)]
    good-enough
    (force expensive)))

Warum nicht eine Konvention wie C oder Java verwenden?
Nun gut, Lisp ist viel älter als diese Sprachen, aber ich spreche über die zeitgenössischen Lispers.

(defn defer-expensive [cheap expensive]
  (if-let [good-enough (force cheap)]
    good-enough
    (force expensive)
  )
)

Hinweis: Das Code-Snippet stammt aus dem Buch "The Joy of Clojure".

Ein Grund, warum Algol-basierte Sprachen die geschweiften Klammern in ihrer eigenen Zeile anregen, besteht darin, mehr Zeilen zwischen den Begrenzungsklammern einzufügen, ohne die geschweiften Klammern verschieben zu müssen. Das heißt, wenn man mit anfängt

if (pred)
{
  printf("yes");
}

Es ist einfach mitzukommen und eine weitere Aussage in die geschweiften Klammern einzufügen:

if (pred)
{
  printf("yes");
  ++yes_votes;
}

Wäre die ursprüngliche Form gewesen

if (pred)
{ printf("yes"); }

dann müssten wir zwei Klammern "bewegt" haben , aber mein Beispiel befasst sich mehr mit letzterer. Hier begrenzen die geschweiften Klammern, was beabsichtigt ist, eine Folge von Anweisungen zu sein , die meistens für Nebenwirkungen aufgerufen werden.

Umgekehrt fehlen Lisp Aussagen; Jede Form ist ein Ausdruck , der einen Wert ergibt - auch wenn in einigen seltenen Fällen (unter Berücksichtigung von Common Lisp) dieser Wert absichtlich als "keine Werte" über eine leere (values)Form ausgewählt wird. Es ist weniger üblich, Sequenzen von Ausdrücken zu finden , als verschachtelte Ausdrücke . Der Wunsch, "eine Abfolge von Schritten bis zum schließenden Begrenzer zu eröffnen", tritt nicht so häufig auf, da mit dem Wegfall von Anweisungen und der Verbreitung von Rückgabewerten der Rückgabewert eines Ausdrucks seltener ignoriert wird selten, um eine Sequenz von Ausdrücken allein auf Nebenwirkungen zu untersuchen.

In Common Lisp ist das prognFormular eine Ausnahme (wie auch seine Geschwister):

(progn
  (exp-ignored-return-1)
  (exp-ignored-return-2)
  (exp-taken-return))

Hier prognwerden die drei Ausdrücke nacheinander ausgewertet, die Rückgabewerte der ersten beiden werden jedoch verworfen. Man könnte sich vorstellen , dass die letzten schließenden Klammer in einer eigenen Zeile zu schreiben, aber beachten Sie wieder , dass seit der letzten Form hier speziell ist (nicht im Common Lisp Sinn des Seins besondere , obwohl), mit unterschiedlichen Behandlung, es ist wahrscheinlich , dass man möchte hinzufügen , neue Ausdrücke in der Mitte der Sequenz und nicht nur "Hinzufügen eines weiteren am Ende", da Aufrufer dann nicht nur von neuen Nebenwirkungen, sondern auch von einer wahrscheinlichen Änderung des Rückgabewerts betroffen wären.

Um eine grobe Vereinfachung zu erreichen, begrenzen die Klammern in den meisten Teilen eines Lisp-Programms Argumente, die an Funktionen übergeben werden - genau wie in C-ähnlichen Sprachen - und nicht Anweisungsblöcke. Aus den gleichen Gründen neigen wir dazu, die Klammern, die einen Funktionsaufruf in C begrenzen, in der Nähe der Argumente zu belassen, und tun dies auch in Lisp, mit weniger Motivation, von dieser engen Gruppierung abzuweichen.

Das Schließen der Klammern ist weniger wichtig als das Einrücken des Formulars, in dem sie geöffnet werden. Mit der Zeit lernt man, die Klammern zu ignorieren und nach Form zu schreiben und zu lesen - ähnlich wie es Python-Programmierer tun. Lassen Sie sich jedoch nicht von dieser Analogie dazu verleiten, zu denken, dass es sich lohnen würde , die Klammern vollständig zu entfernen . Nein, das ist eine Debatte, für die man am besten aufgehoben ist comp.lang.lisp.

Weil es nicht hilft. Wir verwenden Einrückungen, um die Codestruktur anzuzeigen. Wenn wir Codeblöcke trennen wollen, verwenden wir wirklich leere Zeilen.

Da die Lisp-Syntax so konsistent ist, sind die Klammern sowohl für den Programmierer als auch für den Editor die endgültige Richtlinie für das Einrücken.

(Für mich ist die Frage eher, warum C- und Java-Programmierer gerne ihre Klammern umdrehen.)

Nur um zu demonstrieren, unter der Annahme, dass diese Operatoren in einer C-ähnlichen Sprache verfügbar waren:

Foo defer_expensive (Thunk cheap, Thunk expensive) {
    if (Foo good_enough = force (cheap)) {
        return good_enough; }
    else {
        return force (expensive); }}

Zwei schließende Klammern schließen zwei Verschachtelungsebenen. Die Syntax ist offensichtlich korrekt. In Analogie zur Python-Syntax sind die geschweiften Klammern nur explizite INDENT- und DEDENT-Token.

Natürlich ist dies möglicherweise nicht der "One True Brace Style" ^TM , aber ich glaube, dass dies nur ein historischer Zufall und eine Gewohnheit ist.

Der Code ist dann viel kompakter. Die Bewegung im Editor erfolgt ohnehin durch S-Ausdrücke, sodass Sie diesen Platz nicht zum Bearbeiten benötigen. Code wird hauptsächlich nach Struktur und Sätzen gelesen - nicht nach Trennzeichen.

Lispers, wissen Sie, gehässig bletcherous es auch sein mag, es ist eine gewisse je ne sais quoi das zweite Beispiel:

(defn defer-expensive [cheap expensive]
  (if-let [good-enough (force cheap)]
    good-enough
    (force expensive)
  )
)

Zuerst konnte ich sozusagen keinen Finger auf die Quelle der Anziehungskraft legen, und dann bemerkte ich, dass nur ein Auslöser fehlt:

(defn defer-expensive [cheap expensive]      
  (if-let [good-enough (force cheap)]
    good-enough   ;   )
    (force expensive) 
  )
)

Voilà!

Ich werde jetzt meinen Lisp-Gangstergriff üben!

In meinem Fall finde ich die Zeilen, die Begrenzern gewidmet sind, eine Verschwendung von Platz auf dem Bildschirm, und wenn Sie Code in C schreiben, gibt es auch den Stil von

if (pred) {
   printf("yes");
   ++yes_votes;
}

Warum setzen die Leute die öffnende Klammer in dieselbe Zeile des "if", um Platz zu sparen, und weil es überflüssig erscheint, eine eigene Zeile zu haben, wenn das "if" bereits eine eigene Zeile hat?

Sie erreichen das gleiche Ergebnis, indem Sie am Ende die Klammern setzen. In C würde komisch aussehen, weil Anweisungen mit einem Semikolon enden und das Klammerpaar nicht so geöffnet wird

{if (pred)
    printf("yes");
}

es ist wie die schließende Klammer am Ende, sieht fehl am Platz. es öffnet sich so

if (pred) {
    printf("yes");
}

Verschaffen Sie sich mit '{' & '}' einen klaren Überblick über den Block und seine Grenzen

Und mit Hilfe eines Editors, der Klammern anpasst, indem er sie hervorhebt, wie es vim tut, können Sie bis zum Ende gehen, wo alle Klammern gepackt sind, sie leicht durchgehen und mit allen Eröffnungsklammern übereinstimmen und das verschachtelte Lispel-Formular sehen

(defn defer-expensive [cheap expensive]
    _(if-let [good-enough (force cheap)]
    good-enough
    (force expensive)_))

Sie können den Cursor in die abschließende Parene in der Mitte setzen und die öffnende Parene der If-Let hervorheben.