Punto e virgola facoltativo

Rendendoli obbligatori (o disabilitandoli completamente) riduce il numero di casi d'angolo, elimina una potenziale fonte di bug oscuri e semplifica la progettazione del compilatore / interprete.

I designer di lingue che hanno scelto di renderli opzionali hanno scelto per vivere con l'ambiguità in cambio di una maggiore flessibilità sintattica.

JavaScript ci ha mostrato che questa è una pessima idea. Ad esempio:

return
0;

In C, restituisce un valore pari a 0. In JavaScript, restituisce undefined perché viene inserito un punto e virgola dopo l'istruzione return, e non è immediatamente evidente il motivo per cui il tuo codice si sta rompendo a meno che tu non sappia dei dettagli di inserimento automatico del punto e virgola.

Semplifica la grammatica e il parser in qualche modo per rendere obbligatorio il punto e virgola. Essenzialmente, permette al lexer di scaricare tutti gli spazi bianchi, incluse le nuove linee, e il parser non deve preoccuparsi affatto di esso.

D'altra parte, una volta che inizi a voler dire al parser degli spazi bianchi, non è difficile rendere facoltativo il punto e virgola. Spesso puoi raggrupparli insieme con un token whitespace e il tuo parser può gestirli bene.

Ad esempio, prova a inserire il punto e virgola nella seguente serie di istruzioni C.

functionCall(3, 4) 9 + (3 / 8) variable++ while(1) { printf("Hello, world\n") }

Mentre ci sono alcune cose strane che non puoi più fare, come while(1); , per la maggior parte, è relativamente facile con le moderne tecniche di analisi per determinare dove terminano le istruzioni senza un delimitatore specifico. Anche se vuoi ancora consentire le cose strane, non è difficile rendere un newline_or_semicolon non-terminale.

I punti e virgola sono utili in una grammatica per 2 motivi. In primo luogo, ti consente di dividere le dichiarazioni lunghe in più righe senza avere caratteri di continuazione divini (sto parlando di te, Fortran e Basic). In secondo luogo, lascia che il parser abbia un modo per "abbandonare" l'analisi quando la sintassi diventa veramente complicata a causa di un errore di battitura. Rubare dall'esempio di Karl Bielefeldt,

functionCall(3, 4) 9 + (3 / 8) variable++ while(1) { printf("Hello, world\n") }

immagina di aver digitato un altro paren aperto:

functionCall((3, 4) 9 + (3 / 8) variable++ while(1) { printf("Hello, world\n") }

ora dov'è l'errore? Se hai il punto e virgola, è più facile che il parser si arrenda al primo punto e virgola. Potrebbe anche continuare l'analisi dopo il punto e virgola, se lo desidera.

functionCall((3, 4);  <- something is wrong here. emit error and keep going.
                      9 + (3 / 8); variable++; while(1) { printf("Hello, world\n"); }

Ora sul parser è più semplice segnalare un errore e individuare più facilmente la linea / colonna in cui si è verificato.

I punti e virgola non sono sempre all-or-nothing come menzioni nella tua domanda. Ad esempio, la grammatica Lua è progettata con cura per essere di forma libera (tutti gli spazi bianchi, inclusi i newline, possono essere ignorato) ma anche senza usare alcun punto e virgola. Ad esempio, i seguenti programmi sono equivalenti:

--One statement per line
x = 1
y = 2

--Multiple statements per line
x = 1 y = 2

--You can add semicolons if you want but its just for clarity:
x = 1; y = 2

A parte il design e la costruzione, credo che molti programmatori abbiano origini diverse e alcuni abbiano imparato a usare il punto e virgola e altri no. Un sacco di lingue più recenti che stanno emergendo non richiedono un punto e virgola ma permetteranno comunque che esista. Penso che potrebbe essere solo un modo per far sì che più programmatori imparino a codificare in queste nuove lingue senza dover rinunciare alle proprie abitudini da quando hanno iniziato.