Parenthèses Lisp

Question

Pourquoi les Lispers formatent-ils leur code comme indiqué dans l'exemple 1 et non comme indiqué dans l'exemple 2 ? Pour moi (et je suppose, pour la plupart des autres personnes venant d'horizons de programmation différents de Lisp), le formatage montré dans l'exemple 2 serait plus facile à lire. Y a-t-il une raison particulière pour laquelle les Lispers préfèrent le style de l'échantillon 1 ?

Echantillon 1

(defun factorial (n)
  (if (<= n 1)
    1
    (* n (factorial (- n 1)))))

Echantillon 2

(defun factorial (n)
  (if (<= n 1)
    1
    (* n (factorial (- n 1)))
  )
)

Answer 1

Les environnements IDE LISP ont tendance à équilibrer automatiquement les parenthèses et à gérer les retraits en fonction du niveau d'imbrication. L'échantillon 2 n'apporte aucun avantage dans ces situations.

Dans l'héritage C/FORTRAN/Pascal, vous avez tendance à mettre l'accent sur le séquençage plutôt que sur l'imbrication (les arbres d'analyse du code sont moins profonds et plus larges). La fin de la portée est un événement plus significatif dans votre code : par conséquent, l'accent a été et est toujours, dans une certaine mesure, plus important.

Answer 2

Pour les utilisateurs expérimentés de Lisp, le niveau d'imbrication est plus important que la recherche de parenthèses fermantes. Le fait de placer les parenthèses fermantes sur leurs propres lignes n'aide pas vraiment à déterminer les niveaux d'imbrication.

L'idée de base est que les parenthèses entourent directement leur contenu.

(a)

et non

(a
)

Voici ce qui suit :

(defun foo (bar)
  (foo (bar (baz
              ...
             )
         ...
        )
    ...
   )
 )

vs.

(defun foo (bar)
  (foo (bar (baz ...) ...) ...))

L'une des idées de base lors de l'édition de texte Lisp est que vous pouvez sélectionner une liste en (double-) cliquant sur les parenthèses (ou en utilisant une commande clavier lorsque le curseur se trouve à l'intérieur de l'expression ou sur les parenthèses). Vous pouvez ensuite couper/copier l'expression et la coller à un autre endroit dans une autre fonction. L'étape suivante consiste à sélectionner l'autre fonction et réindenter la fonction. C'est fait. Il n'est pas nécessaire de supprimer ou d'introduire de nouvelles lignes pour les parenthèses fermantes. Il suffit de coller et de réindenter. Cela s'intègre parfaitement. Sinon, soit vous perdriez du temps à formater le code, soit vous devriez le reformater avec un outil d'édition (pour que les parenthèses fermantes soient sur leurs propres lignes). La plupart du temps, cela créerait un travail supplémentaire et gênerait le déplacement du code.

Il y a une occasion où les lispers expérimentés écrivent parfois les parenthèses fermantes sur leur propre ligne :

(defvar *persons*
   (list (make-person "fred")
         (make-person "jane")
         (make-person "susan")
         ))

Il indique ici que de nouvelles personnes peuvent être ajoutées. Placez le curseur juste avant la deuxième parenthèse fermante sur la dernière ligne, appuyez sur c-o (ouvrir la ligne), ajoutez la clause et indentez les parenthèses pour qu'elles soient à nouveau alignées. Cela évite d'avoir à trouver les bonnes parenthèses et à appuyer sur la touche retour, lorsque toutes les parenthèses sont fermées sur une ligne.

Answer 3

Parce qu'il n'est pas nécessaire d'aligner les parenthèses fermantes. Cela n'ajoute rien sémantiquement. Pour savoir combien en fermer, la plupart des Lispers utilisent un bon éditeur, comme Emacs, qui fait correspondre les parens aux parens fermantes et rend donc la tâche triviale.

En Python, il n'y a pas de parenthèses de fermeture ou de end mots-clés du tout, et les pythonistes vivent très bien.

Answer 4

Après un certain temps avec Lisp, vous ne remarquez plus les parenthèses, donc votre exemple deux se présente comme ayant un tas d'espaces blancs inutiles à la fin. Plus précisément, la plupart des lispers utilisent un éditeur qui est conscient des parenthèses et se charge de fermer les formes correctement, de sorte que vous, en tant que développeur, n'avez pas besoin de faire correspondre les parenthèses ouvrantes et fermantes comme vous le faites en C, par exemple.

Quant à savoir si le dernier formulaire doit être

(* n (factorial (- n 1)))

ou

(* n
   (factorial (- n 1)))

c'est surtout une question de préférence personnelle et de quantité de choses qui se passent dans le code (dans ce cas, je préfère la première solution parce qu'il y a si peu de choses qui se passent dans le code).

Answer 5

Outre le fait que la plupart des IDE Lisp utilisent la correspondance des parens, la quantité d'espace que vous utiliseriez pour écrire un programme raisonnable serait ridicule ! Vous auriez le syndrome du canal carpien à cause de tous les défilements. Un programme de 1 000 lignes serait proche d'un million de lignes de code si vous mettiez toutes les parenthèses fermantes sur leur propre ligne. Cela peut sembler plus joli et plus facile à lire dans un petit programme, mais cette idée ne serait pas du tout évolutive.