Qual è la logica dietro l'ordinamento del valore / dichiarazione delle variabili di Scala quando si include un identificatore di tipo? [duplicare]

5

Sto provando a girare la testa su Scala, e una cosa che continua a lanciarmi è l'ordinamento di una dichiarazione di variabile / valore quando si specifica il tipo.

val a = 0

ha perfettamente senso. Sembra praticamente come qualsiasi altra lingua.

val a: Int = 0

sembra davvero strano nella mia testa; sembra assurdo. Perché il tipo è immediatamente a sinistra dell'operatore di assegnazione? Quando taglio questo nella mia testa, vedo "... Int = 0", che ovviamente non ha alcun senso.

C'è una ragione logica dietro a questa che posso riferirmi? Ovviamente, mentre guardo di più il codice di Scala, mi adeguerò ad esso, ma sono anche curioso del perché Martin Odersky avrebbe scelto di organizzarlo come tale. Non può essere solo distinguersi da altre lingue, dove (per quanto ne so), l'identificatore del tipo, se ce n'è uno, precede la dichiarazione.

    
posta Carcigenicate 04.12.2014 - 01:42
fonte

2 risposte

13

stand out from other languages

No. Come già commentato Jörg, questo modulo è attualmente utilizzato in molte lingue. È probabilmente la forma più comune di dichiarazione delle variabili per numero di lingue che la usano. È stato usato allora con Pascal e lingue correlate e ora viene utilizzato da tutti quelli nuovi come TypeScript, Go, Rust e Scala.

type identifier, if there is one, precedes the declaration

Il

type identifier [ = value ]

la forma della dichiarazione in C era per alcuni aspetti un errore grave . Il suo problema serio è che rende la grammatica della lingua contestuale. Gli identificatori di tipo e oggetto hanno lo stesso aspetto sintattico, ma questa forma di dichiarazione non può essere riconosciuta senza sapere che il primo identificatore identifica un tipo. Quindi il compilatore non può costruire l'albero della sintassi senza fare riferimento alla tabella dei tipi già definiti. Ciò causa problemi ai template, perché l'interpretazione può dipendere dal parametro, quindi il compilatore non può sapere se sta ancora guardando un tipo.

In C ++ questo significa che devi usare typename keyword nei casi ambigui. Java e C # lo schivano non avendo typedef, quindi non puoi avere tipi correlati, ma ciò limita seriamente l'utilità dei loro template. E comunque complica comunque il compilatore.

D'altra parte con dichiarazioni nel modulo

keyword identifier [ : type ] [ = value ]

l'identificatore dopo : (e alcune parole chiave come new ) indica sempre che il tipo e l'identificatore in qualsiasi altro luogo non lo fanno mai e la grammatica è senza contesto e tutto è molto più semplice.

È anche più regolare quando il tipo è facoltativo. Lo hai appena omesso. Nel modulo C, devi sostituirlo con una parola chiave speciale.

    
risposta data 04.12.2014 - 07:25
fonte
3

Ci stai pensando nel modo sbagliato. Il tipo non è immediatamente a sinistra del compito, è immediatamente a destra del dichiaratore. Questa sintassi ha il vantaggio di non essere ambigua, mentre per esempio val a = 0 : Int è ambigua: l'identificatore di tipo si riferisce al letterale, alla dichiarazione o all'intera istruzione? E se l'inizializzatore è più complicato di un semplice letterale, diventa veramente confuso.

    
risposta data 04.12.2014 - 01:48
fonte

Leggi altre domande sui tag