Vorrei evitare i termini "tipizzazione strong", "digitazione debole" o "digitazione libera", poiché non hanno una definizione generalmente accettata. Invece, parliamo della digitazione statica.
-
Una lingua è tipizzata staticamente se per qualsiasi espressione, posso determinare il tipo di tale espressione solo osservando il codice sorgente.
-
Se le espressioni non hanno un tipo statico ma il tipo fa parte di ciascun valore del tempo di esecuzione e i tipi vengono controllati in fase di esecuzione, la lingua è tipizzata dinamicamente . (Tale linguaggio è anche chiamato unityped o anche un po 'confuso chiamato untyped perché il tipo statico di ogni espressione è Any ).
-
Se il linguaggio non impone la tipizzazione statica ma consente la digitazione statica per alcune espressioni, è gradualmente digitato ("digitazione statica facoltativa").
I linguaggi OOP staticamente tipizzati di Mainstream utilizzano una combinazione di tipizzazione statica e dinamica: il tipo statico è solo un tipo associato, ma il valore di runtime potrebbe effettivamente avere un sottotipo.
Per un linguaggio tipizzato in modo statico o graduale, i tipi e i vincoli di tipo possono solitamente essere forniti come annotazioni esplicite (ad esempio Type variable o expression :: Type ). Alcune lingue supportano anche l'inferenza di tipo.
Un algoritmo tipo di inferenza assegna le variabili di tipo alle espressioni di tipi sconosciuti. Quindi tenta di dedurre tipi concreti per tali variabili di tipo da fatti noti, ad es. esaminando i tipi di letterali, utilizzando le annotazioni di tipo esplicito o esaminando le funzioni disponibili. L'inferenza di tipo deve essere gestita con attenzione poiché alcune caratteristiche del sistema di tipo (come polimorfismo, sottotipizzazione, digitazione graduale, ricorsione) rendono più difficile o addirittura impossibile eseguire sempre l'inferenza di tipo. Le lingue differiscono significativamente dal modo in cui gestiscono l'errore per dedurre i tipi coerenti. Ad esempio:
var x;
// introduce type variable $T
// type x:$T
x = 42;
// type 42:int
// unify $T = int
x = "foo";
// type "foo":string
// unify $T = string
// error because $T = int != string
// alternatively with subtyping:
// ...
// unify int <: $T
// ...
// unify string <: $T
// --> $T = LowestCommonAncestor(int, string) = object
- Un linguaggio tipizzato staticamente deve interrompere un errore se non può inferire un tipo coerente.
- Un linguaggio digitato gradualmente può impostare una variabile di tipo su
Any se non può dedurre alcun vincolo.
- Dedurre un tipo di unione (come
str|int ) è in gran parte inutile poiché non si vedrebbe mai un errore di tipo. La maggior parte degli algoritmi di inferenza di tipo lo impediscono. Se una lingua con l'inferenza di tipo supporta i tipi di unione, questa è o speciale (ad esempio per i tipi annullabili) o richiede un involucro e uno scostamento espliciti per l'unione. Dedurre i tipi di unione può essere ancora valido internamente dopo che ogni tipo di controllo è stato eseguito, poiché un tipo di unione è un vincolo di tipo migliore di Any .
Alcuni linguaggi OOP mainstream tipizzati staticamente supportano un tipo limitato di inferenza di tipo (C ++ auto , C # var , lambdas in C # e Java e deduzione argomento / tipo in C ++, Java e C #). Questi sono sufficientemente limitati in modo che l'inferenza di tipo non fallirà mai.
Un'implementazione di un linguaggio come un compilatore deve mantenere il comportamento specificato della lingua. Se l'implementazione utilizza un'ottimizzazione che modifica il comportamento specificato, quell'ottimizzazione è sbagliata.
Una possibile tecnica di ottimizzazione per i linguaggi tipizzati in modo dinamico consiste nell'utilizzare internamente l'inferenza del tipo per dedurre i tipi statici per alcune parti del codice, cioè utilizzare una digitazione graduale. Ciò potrebbe comportare significativi miglioramenti delle prestazioni. Ma dal momento che qualsiasi ottimizzazione non deve modificare il comportamento della lingua, non deve aggiungere ulteriori controlli di sicurezza. Se un compilatore JavaScript deduce che x è un int quando in seguito assegni una stringa, quel compilatore ha un bug.
Se desideri una lingua che non consente l'assegnazione di tipi diversi alla stessa variabile, quella lingua non è JavaScript. TypeScript è un super-set di JavaScript, vale a dire qualsiasi programma JavaScript sintatticamente valido è un programma TypeScript sintatticamente valido. Ma dal momento che TypeScript è una lingua diversa, può aggiungere regole di controllo del tipo. In particolare, l'esempio var x = 42; x = "foo" genererà un avvertimento o un errore. Tuttavia, TypeScript traspone in JavaScript e il controllo del tipo viene utilizzato solo come strumento di produttività per sviluppatori, non come aiuto per l'ottimizzazione del compilatore.
Questo è chiamato "TypeScript è una lingua diversa da JavaScript".
Il sistema di tipi di TypeScript può essere caratterizzato come "digitazione graduale o (in base alle impostazioni) digitazione statica con inferenza di tipo".