Perché Swift non richiede punti e virgola? [chiuso]

Normalmente codice in c # o Objective-C e di recente mi sono impegnato a imparare il nuovo linguaggio di programmazione di Apple: Swift.

La prima cosa che ho notato è che non è necessario aggiungere punti e virgola per terminare una riga in Swift, ma se lo fai, almeno da quello che ho testato, non interferisce con il compilatore.

Quando scrivo:

int someNumber = 0;

in Objective-C il punto e virgola indica al programma che la riga è finita e che non passa alla riga successiva.

Con Swift posso dichiarare una variabile con

var someNumber:Int = 5

e non aggiungere un punto e virgola e il sistema sa che questa è la fine della riga.

Cosa consente ad alcune lingue di farlo e altre no? Perché non mantenere un sistema uniforme di aggiunta del punto e virgola alla fine?

Cosa consente ad alcune lingue di farlo e altre no? Perché non mantenere un sistema uniforme di aggiunta del punto e virgola alla fine?

Robert ha dato una buona risposta riguardo Swift, proverò ad aggiungere qualcosa in più sull'analisi in generale e sul perché usare o meno i punti e virgola.

Quando compili il programma, ci sono diversi passaggi prima che il tuo file sorgente venga trasformato in codice eseguibile, uno dei primi che legge e analizza . Durante l'analisi il codice viene trasformato da una sequenza di caratteri in una rappresentazione strutturata in base alla grammatica della lingua. Per questo è necessario che gli elementi che compongono il tuo codice (variabili, costanti, dichiarazioni, ecc.) Siano in qualche modo identificati e separati. Quando fai una dichiarazione come:

int someNumber = 0;

È solo una sequenza di personaggi che in qualche modo deve essere trasformata nel concetto "crea una" cosa "chiamata someNumberdi tipo inte assegnagli 0" .

Ciò richiede l'identificazione del punto esatto in cui inizia e termina la frase. Immagina se avessi questo:

int someNumber = 0;
int otherNumber = 1;

Dovresti sapere che quelle sono due dichiarazioni diverse. I ;linguaggi simili a C sono usati per questo, quindi il parser legge i caratteri fino a quando non ne trova uno, e tenta di capire ciò che è stato appena letto come una singola istruzione. Ciò consente, come ha detto Robert, di avere diverse dichiarazioni nella stessa riga, come:

int someNumber = 0; int otherNumber = 1;

Che ha esattamente lo stesso effetto di scriverli in due righe.

In altre lingue, come Python , ci si aspetta che inserisca ogni istruzione in una riga diversa.

x = 3
if x < 10:
   print 'x smaller than 10'
else:
   print 'x is bigger than 10 or equal'

Quindi non è necessario aggiungere un ;, perché la lingua stessa ti impedisce di aggiungere istruzioni nella stessa riga!

Eppure altre lingue, come LISP o Scheme , hanno un modo molto diverso di raggruppare le dichiarazioni (ok, non sono in realtà affermazioni, ma ignoriamolo per ora). Quindi hai solo parentesi per tutto:

(define (do-stuff x)
  (begin
    (display (format "value: ~a" x))
    x))

Anche in questo caso, non è necessario il ;solo perché si utilizzano gli stessi simboli ( ), () per le cose che in altre lingue sono {, }, :, ecc Qualcuno che conosce solo la sintassi Lisp potrebbe chiedere: Perché avete bisogno ;alla fine delle sue dichiarazioni ?

Solo per aggiungere un esempio sconosciuto: OCaml non ha solo un punto e virgola alla fine delle dichiarazioni ... ne ha due!

let rec fact x =
    if x <= 1 then 1 else x * fact (x - 1);;

Perché? Non lo so. :)

Lingue diverse sono progettate con scopi e filosofie diverse. Se tutte le lingue condividessero la stessa sintassi e convenzioni, probabilmente ti permetterebbero di fare le stesse cose allo stesso modo.

Le interruzioni di riga vengono utilizzate al posto dei punti e virgola per delimitare la fine di un'istruzione.

In Guida linguistica: Le basi dice:

A differenza di molte altre lingue, Swift non richiede di scrivere un punto e virgola (;) dopo ogni istruzione nel codice, sebbene tu possa farlo se lo desideri. I punti e virgola sono necessari, tuttavia, se si desidera scrivere più istruzioni separate su una sola riga.

Perché? Perché è così che i designer linguistici volevano farlo.

La seconda frase sopra suggerisce il motivo per cui non hai bisogno di punti e virgola; la maggior parte delle affermazioni sono a riga singola. Osservare questo esempio di ordinamento delle bolle; la combinazione di istruzioni a riga singola e nessun punto e virgola crea una sintassi molto chiara simile a VB, ma meno dettagliata:

func bubbleSort<T:Comparable>(inout list:[T]) {
    var done = false
    while !done {
        done = true
        for i in 1..<list.count {
            if list[i - 1] > list[i] {
                (list[i], list[i - 1]) = (list[i - 1], list[i])
                done = false
            }
        }
    }
}

Poiché le istruzioni in Swift di solito terminano con un'interruzione di riga, viene ridotta la necessità di punti e virgola per contrassegnare la fine di un'istruzione. Altre lingue che usano il punto e virgola non funzionano in questo modo; puoi scrivere liberamente istruzioni multilinea, ma l'unico modo in cui il compilatore sa che l'istruzione è terminata è quando inserisci il punto e virgola alla fine di esso.

Quando le istruzioni non terminano con un'interruzione di riga, è necessario posizionare l'interruzione di riga in un punto che il compilatore Swift possa riconoscere come una continuazione della riga precedente:

let s2 = str
        .lowercaseString
        .replace("hello", withString: "goodbye")