Perché i nuovi linguaggi di programmazione spostano i tipi dall'altra parte?

Question

Se si guardano Rust, Go, Swift, TypeScript e pochi altri e li si confronta con C/C++, la prima cosa che ho notato è come i tipi hanno spostato le posizioni.

int one = 1; 

In comparsion a:

let one:int = 1; 

La mia domanda: perché?

Per me, personalmente, è strano specificare gli specificatori del tipo che sono molto in linea, poiché sono molto abituato a trovarsi a sinistra. Quindi mi interessa il motivo per cui gli specificatori di tipo vengono spostati - e questo non è il caso di uno solo, ma di molte lingue moderne/nuove che sono sul tavolo.

Answer 1

A me, personalmente, è strano tipo di lettura specificatori così lontano nella linea, dal momento che sono molto abituato a loro di essere a sinistra

e l'inglese è la lingua migliore, perché è il solo lingua in cui le parole sono pronunciate nello stesso ordine in cui le penso. Ci si chiede perché qualcuno parli il francese, con le parole tutte nell'ordine sbagliato!

Quindi mi interessa il motivo per cui gli specificatori di tipo vengono spostati - e questo non è il caso di uno solo, ma di molte lingue moderne/nuove che sono sul tavolo.

Ho notato che ignori l'esistenza di molte lingue più vecchie che usano questo modello. Visual Basic (metà anni '90) viene subito in mente.

Function F(x As String) As Object 

Pascal, 1970:

var 
    Set1 : set of 1..10; 

semplicemente digitato lambda calcolo, un linguaggio di programmazione inventato prima che i computer, nel 1940:

λx:S.λy:T:S-->T-->S 

Tutta la famiglia ML. Potrei andare avantiCi sono un sacco di lingue molto vecchie che usano i tipi sulla giusta convenzione.

Ma possiamo arrivare molto più vecchi degli anni '40. Quando dici in matematica f : Q --> R, stai mettendo il nome della funzione a sinistra e il tipo - una mappa da Q a R - a destra. Quando dici x∈R per indicare che x è reale, stai mettendo il tipo a destra. "Digita a destra" precedente al tipo a sinistra in C letteralmente secoli. Questo non è niente di nuovo!

Infatti la sintassi "tipi sulla sinistra" è quella bizzarra! Sembra naturale per te perché hai usato un linguaggio che usa questa convenzione nei tuoi anni formativi.

I tipi sulla sintassi corretta sono molto superiori, per numerose ragioni. Solo alcune:

var x : int = 1; 
function y(z : int) : string { ... }  

sottolinea che x è una variabile ed y è una funzione. Se il tipo viene a sinistra e vedi int y allora non sai se è una funzione o una variabile fino a tardi. Ciò rende i programmi più difficili da leggere per gli umani, il che è già abbastanza grave. Come sviluppatore di compilatori, lascia che ti dica che è piuttosto scomodo che il tipo venga a sinistra in C#. (Potrei evidenziare numerose incongruenze su come la sintassi C# si occupa delle posizioni dei tipi.)

Un altro motivo: nella sintassi "digita sulla destra" è possibile rendere i tipi facoltativi. Se si dispone di

var x : int = 1; 

allora si può facilmente dire "bene, possiamo dedurre l'int, e quindi eliminarlo"

var x = 1; 

ma se l'int è a sinistra, allora cosa fai ?

Inversione di questo: si cita TypeScript. TypeScript è un JavaScript tipizzato gradualmente. La convenzione in JavaScript è già

var x = 1; 
function f(y) { } 

Dato che, chiaramente è più facile modificare sia il codice esistente, e la lingua nel suo insieme, di introdurre elementi di tipo opzionali a destra di quanto lo sarebbe per fare il "var "e" funzione "parole chiave sostituite da un tipo.

Considerare anche il posizionamento. Quando si dice:

int x = 1; 

allora le due cose che devono essere coerenti - il tipo e l'inizializzazione - sono lontani tra loro come il possibile essere. Con var x : int = 1; sono affiancati. E in

int f() { 
    ... 
    ... 
    return 123; 
} 

cosa abbiamo? Il ritorno è logicamente il più a destra possibile, quindi perché la dichiarazione di funzione sposta il tipo del ritorno il più a sinistra possibile? "Con il tipo sulla sintassi corretta abbiamo questo flusso piacevole:

function f(x : string) : int 
{ ... ... ... return 123; } 

Cosa succede in una chiamata di funzione?Il flusso della dichiarazione è ora lo stesso del flusso di controllo: le cose a sinistra - l'inizializzazione dei parametri formali - avviene prima, e le cose a destra - la produzione di un valore di ritorno - si verificano per ultime.

Potrei andare avanti ad una lunghezza aggiuntiva, sottolineando come lo stile C lo fa completamente all'indietro, ma è tardi. Riassumendo: in primo luogo, il tipo sulla destra è superiore in quasi tutti i modi possibili, e in secondo luogo, è molto, molto vecchio. Le nuove lingue che usano questa convenzione sono quelle che sono coerenti con la pratica tradizionale.

Answer 2

Se si esegue una ricerca sul Web, non è difficile trovare gli sviluppatori di lingue più recenti che rispondano a questa domanda con le loro stesse parole. Ad esempio, gli sviluppatori Go hanno un FAQ entry su questo, nonché un entire article sul loro blog di lingua. Molti programmatori sono così abituati a linguaggi simili a C che ogni alternativa sembra strana, quindi questa domanda tende a venire molto ...

Tuttavia, si potrebbe sostenere che la sintassi della dichiarazione del tipo C di per sé è dispari al meglio. Le caratteristiche del modello per i puntatori e i tipi di funzione diventano scomode e non intuitive molto rapidamente, e non sono mai state sviluppate come parte di, o in alcun tipo di funzionalità di abbinamento di modelli più generale. Per motivi di familiarità, sono stati adottati in misura maggiore o minore da molti successivi linguaggi di tipo C, ma la caratteristica stessa si distingue come più di un esperimento fallito con cui dobbiamo convivere per motivi di compatibilità con le versioni precedenti.

Un vantaggio derivante dall'estrattarsi dalla sintassi del tipo C è che semplifica l'utilizzo dei tipi in più posizioni rispetto alle dichiarazioni. Se è possibile posizionare i tipi convenientemente ovunque abbiano senso, è possibile utilizzare i tipi come annotazione, come descritto nello Swift documentation.