Digitazione graduale: "Quasi ogni lingua con un sistema di tipo statico ha anche un sistema di tipo dinamico"

Questa affermazione di Aleks Bromfield afferma:

Quasi ogni lingua con un sistema di tipo statico ha anche un sistema di tipo dinamico. A parte C, non riesco a pensare a un'eccezione

È un reclamo valido? Capisco che con Reflection o Loading classi in fase di runtime Java diventa un po 'così - ma questa idea di "digitazione graduale" può essere estesa a un gran numero di lingue?

Tweeter originale qui. :)

Prima di tutto, sono un po 'divertito / scioccato dal fatto che il mio tweet sia preso così sul serio! Se avessi saputo che sarebbe stato così ampiamente diffuso, avrei trascorso più di 30 secondi a scriverlo!

Thiago Silva ha giustamente sottolineato che "statico" e "dinamico" descrivono più accuratamente il controllo del tipo , piuttosto che i sistemi di tipo . In effetti, non è proprio esatto affermare che una lingua sia tipizzata staticamente o dinamicamente. Piuttosto, una lingua ha un sistema di tipi e un'implementazione di quella lingua potrebbe imporre il sistema di tipi usando il controllo statico, il controllo dinamico, o entrambi, o nessuno dei due (anche se non sarebbe un'implementazione del linguaggio molto accattivante!).

In effetti, ci sono alcuni sistemi di tipo (o caratteristiche dei sistemi di tipo) che sono più suscettibili al controllo statico e ci sono alcuni sistemi di tipo (o caratteristiche dei sistemi di tipo) che sono più suscettibili al controllo dinamico. Ad esempio, se la tua lingua ti consente di specificare nel testo di un programma che un determinato valore deve sempre essere un array di numeri interi, allora è ragionevolmente semplice scrivere un controllo statico per verificare quella proprietà. Al contrario, se la tua lingua ha un sottotitolo e se consente il downcasting, è ragionevolmente semplice verificare la validità di un downcast in fase di esecuzione, ma è estremamente difficile farlo al momento della compilazione.

Quello che intendevo veramente con il mio tweet è semplicemente che la stragrande maggioranza delle implementazioni linguistiche esegue un certo controllo dinamico del tipo. O, equivalentemente, la stragrande maggioranza delle lingue ha alcune caratteristiche che sono difficili (se non impossibili) da controllare staticamente. Il downcasting è un esempio. Altri esempi includono overflow aritmetico, controllo dei limiti dell'array e controllo null. Alcuni di questi possono essere controllati staticamente in alcune circostanze, ma nel complesso, sarebbe difficile trovare un'implementazione del linguaggio che non esegua alcun controllo in fase di esecuzione.

Questa non è una brutta cosa. È solo un'osservazione che ci sono molte proprietà interessanti che vorremmo far applicare alle nostre lingue e che non sappiamo davvero come controllare staticamente. Ed è un promemoria che distinzioni come "tipi statici" rispetto a "tipi dinamici" non sono così nette come alcune persone vorrebbero farti credere. :)

Un'ultima nota: i termini "forte" e "debole" non sono realmente utilizzati nella comunità di ricerca del linguaggio di programmazione e non hanno un significato coerente. In generale, ho scoperto che quando qualcuno dice che una lingua ha "digitazione forte" e un'altra lingua ha "digitazione debole", stanno davvero dicendo che la loro lingua preferita (quella con "digitazione forte") impedisce loro di commettendo un errore che l'altra lingua (quella con "digitazione debole") non - o viceversa, che la loro lingua preferita (quella con "digitazione debole") consente loro di fare qualcosa di interessante che l'altra lingua (il uno con "digitazione forte") no.

Beh si. Puoi avere borse di proprietà in qualsiasi lingua tipizzata staticamente. La sintassi sarà terribile mentre allo stesso tempo otterrai tutti gli svantaggi del sistema tipizzato dinamicamente. Quindi non c'è davvero alcun vantaggio a meno che il compilatore non ti permetta di usare una sintassi migliore, come dynamicsta facendo C # .

Inoltre, puoi farlo abbastanza facilmente anche in C.

In risposta ad altre risposte: penso che le persone stiano confondendo la digitazione statica / dinamica con la digitazione forte / debole. La tipizzazione dinamica riguarda la possibilità di modificare la struttura dei dati in fase di runtime e il codice di poter utilizzare i dati che si adattano solo alle esigenze del codice. Questo si chiama Duck Typing .

Menzionare la riflessione non sta raccontando l'intera storia, perché la riflessione non consente di modificare la struttura esistente dei dati. Non è possibile aggiungere un nuovo campo a una classe o struttura in C, C ++, Java o C #. Nei linguaggi dinamici, l'aggiunta di nuovi campi o attributi alle classi esistenti non è solo possibile, ma in realtà abbastanza comune.

Ad esempio, guarda Cython , il compilatore da Python a C. Crea codice C statico, ma il sistema di tipi mantiene ancora la sua natura dinamica. C è un linguaggio tipicamente statico, ma è in grado di supportare la tipizzazione dinamica da Python.

Le lingue dinamiche sono lingue statiche . Quello che comunemente viene chiamato "tipizzazione dinamica" è in realtà un caso speciale di tipizzazione statica - il caso in cui ti sei limitato ad avere un solo tipo. Come esperimento mentale, immagina di scrivere un programma in Java o C # usando solo Objectvariabili / campi / parametri e di eseguire il down-casting immediatamente prima di chiamare qualsiasi metodo. Sarebbe più accurato chiamare linguaggi come Python o Javascript "unityped". (Questa affermazione probabilmente confonderà / disturberà molte persone, considerando che un tale programma Java o C # userebbe molti sottotipi, ma questo perché il linguaggio OOP medio comprende tipi e classi. Leggi il post sul blog per maggiori dettagli.)

Nota che anche C ha una digitazione "dinamica": puoi lanciare qualsiasi puntatore su un puntatore void(e se la memoria mi serve char) e viceversa. E nota, inoltre, che non esiste un runtime che controlla lì; se sbagli, goditi il ​​tuo comportamento indefinito!

La differenza tra tipizzazione statica e dinamica è quando viene controllato il tipo di un valore: tempo di compilazione vs. tempo di esecuzione. Nelle lingue in cui i valori portano con sé il loro tipo (ad es. Oggetti Java), puoi sempre ricorrere alla tipizzazione dinamica anche quando la lingua preferisce la tipizzazione statica. Ecco un esempio in Java, con un metodo digitato in modo dinamico:

void horribleJava(List untypedList) {
  for (Object o : untypedList)
    ((SpecificType) o).frobnicate();
}

Notare come viene controllato il tipo di ciascun elemento in fase di esecuzione. Il metodo equivalente digitato staticamente è:

void goodJava(List<SpecificType> typedList) {
  for (SpecificType o : typedList) {
    o.forbnicate();
  }
}

In C, i valori (e in particolare i puntatori) non mantengono il loro tipo durante il runtime - ogni puntatore equivale a void *. Invece, le variabili e le espressioni hanno un tipo. Per ottenere una digitazione dinamica, è necessario portare da sé le informazioni sul tipo (ad es. Come un campo in una struttura).

La tipizzazione statica e dinamica si riferisce essenzialmente al modo in cui i tipi vengono controllati. La tipizzazione statica significa che la verifica dei tipi di varie variabili o espressioni viene verificata in base al codice effettivo (solitamente dal compilatore) mentre in un sistema di tipo dinamico questa verifica viene eseguita solo in fase di esecuzione, dall'ambiente di runtime.

Ciò a cui credo si riferisca il testo è che anche se i tipi sono effettivamente controllati staticamente, vengono anche controllati in fase di esecuzione, cioè dinamicamente. Hai citato correttamente Java Reflection; reflection viene eseguito solo in fase di runtime e Java Runtime Environment (JVM) esegue effettivamente il controllo del tipo quando si utilizza il reflection, il che significa sostanzialmente controllo dinamico del tipo.

L'esclusione è sbagliata: C ha anche un importante sistema di tipo dinamico. Semplicemente non lo controlla ("C è fortemente tipizzato, debolmente controllato"). Ad esempio, trattare una struttura come uno double( reinternpret_caststile) produce un comportamento indefinito, un errore di tipo dinamico.