La digitazione della papera, deve essere dinamica?

Question

Wikipedia diceva* di digitazione dell'anatra:

Nella programmazione informatica con linguaggi di programmazione orientati agli oggetti, duck typing è uno stile di digitazione dinamica digitando in cui l'oggetto corrente di un oggetto insieme di metodi e proprietà determina la semantica valida, piuttosto che diversa dalla sua eredità da un particolare classe o l'attuazione di una specifica interfaccia.

_{(*ed.Nota:Da quando è stata pubblicata questa domanda, l'articolo di Wikipedia è stato modificato per rimuovere la parola "dinamico".)}

Dice di tipizzazione strutturale:

Un sistema di tipo strutturale (o sistema di tipi basato su proprietà) è uno dei principali classe del sistema di tipi, in cui il tipo La compatibilità e l'equivalenza sono determinato dalla struttura del tipo, e non attraverso dichiarazioni esplicite.

Contrasta il sottotipo strutturale con la tipizzazione duck in questo modo:

Sistemi strutturali] contrasta con ...La tipografia anatra, in cui si accede solo la parte della struttura in fase di esecuzione è verificata per la compatibilità.

Tuttavia, il termine digitazione dell'anatra mi sembra, almeno, che sussuma intuitivamente i sistemi di sottotipizzazione strutturale.Infatti Wikipedia dice:

Il nome del concetto [duck-typing] si riferisce alla prova dell'anatra, attribuito a James Whitcomb Riley, che può essere formulato come Segue:"Quando vedo un uccello che cammina come un'anatra e nuota come un'anatra e starnazza come un'anatra, chiamo quell'uccello un anatra."

Quindi la mia domanda è:perché non posso chiamare il sottotipo strutturale duck-typing?Esistono anche linguaggi tipizzati dinamicamente che non possono essere classificati anche come tipizzati duck?

Post scriptum:

Come qualcuno ha chiamato ubriaco da sogno su reddit.com così dirlo in modo eloquente "Se si compila come una papera e si collega come una papera..."

Post-post scriptum

Molte risposte sembrano fondamentalmente solo riformulare ciò che ho già citato qui, senza affrontare la domanda più profonda, ovvero perché non usare il termine duck-typing per coprire sia la tipizzazione dinamica che la sottotipizzazione strutturale?Se vuoi parlare solo di duck-typing e non di sotto-typing strutturale, allora chiamalo semplicemente così com'è: ricerca dinamica dei membri.Il mio problema è che non c'è nulla riguardo al termine digitazione dell'anatra mi dice, questo vale solo per i linguaggi dinamici.

Answer 1

I modelli C++ e D sono un esempio perfetto di tipizzazione duck non dinamica.È sicuramente:

digitazione in cui un l'attuale insieme di metodi dell'oggetto e proprietà determina il valore valido semantica, piuttosto che la sua ereditarietà di una particolare classe o l'attuazione di un programma interfaccia.

Non specifichi esplicitamente un'interfaccia da cui il tuo tipo deve ereditare per creare un'istanza del modello.Deve solo avere tutte le funzionalità utilizzate nella definizione del modello.Tuttavia, tutto viene risolto in fase di compilazione e compilato in numeri esadecimali grezzi e imperscrutabili.Io chiamo questa "digitazione duck in fase di compilazione".Ho scritto intere librerie partendo da questa mentalità secondo cui l'istanziazione implicita del modello è la digitazione in fase di compilazione e penso che sia una delle funzionalità più sottovalutate in circolazione.

Answer 2

Strutturale Tipo di sistema

Un sistema di tipo strutturale confronta un intero tipo ad un altro tipo intero per determinare se sono compatibili. Per due tipi A e B per essere compatibili, A e B devono avere la stessa struttura -. Questo significa che tutti metodo su A e B deve avere la stessa firma

Duck Typing

Duck digitando considera due tipi equivalenti per l'operazione attuale se entrambi possono gestire questo compito. Per due tipi A e B ad essere equivalente a un pezzo di codice che vuole scrivere in un file, e A B entrambi devono implementare un metodo di scrittura.

Sommario

sistemi di tipo strutturale confrontano ogni metodo di firma (tutta la struttura). Duck typing a confronto i metodi che sono rilevanti per un compito specifico (struttura rilevante per un compito).

Answer 3

mezzi duck typing Se si adatta solo, è OK

Questo vale sia digitato in modo dinamico

def foo obj
    obj.quak()
end

o staticamente tipizzato, linguaggi compilati

template <typename T>
void foo(T& obj) {
    obj.quak();
}

Il punto è che in entrambi gli esempi, non c'è stata alcuna informazione sul tipo specificato. Proprio quando utilizzato (sia in fase di esecuzione o compilare in tempo!), I tipi vengono controllati e se sono soddisfatti tutti i requisiti, il codice funziona. I valori non hanno un tipo esplicito nel loro punto di dichiarazione.

tipizzazione strutturale si basa su esplicitamente digitando i vostri valori, come al solito -. La differenza è solo che il tipo di cemento non è identificato per eredità, ma per la sua struttura

Un codice strutturalmente digitato (Scala-style) per l'esempio di cui sopra sarebbe

def foo(obj : { def quak() : Unit }) {
    obj.quak()
}

Non confondere questo con il fatto che alcune lingue strutturalmente digitati come OCaml combinare questo con l'inferenza di tipo per impedirci di definire i tipi in modo esplicito.

Answer 4

Non sono sicuro se risponde realmente alla tua domanda, ma ...

su modelli C ++ codice è molto simile anatra-tipizzazione, ma è statico, a tempo di compilazione, strutturale.

template<typename T>
struct Test
{
    void op(T& t)
    {
        t.set(t.get() + t.alpha() - t.omega(t, t.inverse()));
    }
};

Answer 5

E 'la mia comprensione che digitando strutturale viene utilizzato da tipo inferencers e simili per determinare le informazioni di tipo (si pensi Haskell o OCaml), mentre duck typing non si preoccupa di "tipi" di per sé, solo che la cosa in grado di gestire una specifica chiamata di metodo / accesso alle proprietà, ecc (si pensi respond_to? in Ruby o capacità check-in Javascript).

Answer 6

Ci sono sempre di essere esempi di alcuni linguaggi di programmazione che violano alcune definizioni di vari termini. Ad esempio, ActionScript supporta facendo anatra tipizzazione programmazione stile su istanze che non sono tecnicamente dinamico.

var x:Object = new SomeClass();
if ("begin" in x) {
    x.begin();
}

In questo caso abbiamo testato se l'istanza di oggetto in "x" è un metodo "inizia" prima di chiamare invece di utilizzare un'interfaccia. Questo funziona in ActionScript ed è praticamente anatra-tipizzazione, anche se la classe di SomeClass () non può essere di per sé dinamica.

Answer 7

Ci sono situazioni in cui anatra tipizzazione dinamica e il codice statico digitato simile (cioè in C ++) comportano in modo diverso:

template <typename T>
void foo(T& obj) {
    if(obj.isAlive()) {
        obj.quak();
    }
}

In C ++, l'oggetto deve avere entrambi i metodi isAlive e quak per il codice per compilare; per il codice equivalente in lingue dinamicamente tipizzati, l'oggetto ha solo bisogno di avere il metodo quak se isAlive() restituisce true. Interpreto questo come una differenza tra la struttura (battitura strutturale) e comportamento (battitura anatra).

(Comunque, ho raggiunto questa interpretazione prendendo "duck-tipizzazione deve essere dinamico" di Wikipedia al valore nominale e cercando di renderlo un senso. L'interpretazione alternativo che implicita digitazione strutturale è duck typing è anche coerente.)

Answer 8

che vedo "duck typing" più come uno stile di programmazione, mentre "tipizzazione strutturale" è una caratteristica del sistema tipo.

tipizzazione strutturale si riferisce alla capacità del sistema di tipo a esprimere tipologie dotati di tutti i valori che hanno certe proprietà strutturali.

Duck digitazione riferisce alla scrittura di codice che utilizza solo le caratteristiche di valori che viene passato che sono effettivamente necessari per il lavoro a mano, senza imporre altre limitazioni.

Così ho potuto usare tipologie strutturali al codice in uno stile di digitazione anatra, dichiarando formalmente le mie "tipi d'anatra", come tipologie strutturali. Ma potrei anche usare tipi strutturali senza "fare duck typing". Ad esempio, se scrivo interfacce a un gruppo di affini funzioni / metodi / procedure / predicati / classes / qualunque cosa dichiarando e la denominazione tipo strutturale comune e quindi utilizzando tale ovunque, è molto probabile che alcune delle unità di codice non hanno bisogno tutti delle caratteristiche di tipo strutturale, e così ho inutilmente costretto alcuni di loro a rifiutare i valori su cui si potrebbe teoricamente funzionare correttamente.

Così, mentre posso vedere come ci sia un terreno comune, non credo duck typing sussume tipizzazione strutturale. Il mio modo di pensare a loro, duck typing non è nemmeno una cosa che avrebbe potuto essere in grado di sussumere digitazione strutturale, perché non sono lo stesso genere di cose. Pensando di battitura anatra in linguaggi dinamici come solo "impliciti, tipologie strutturali non controllate" manca qualcosa, IMHO. Duck typing è uno stile di codifica si sceglie di utilizzare o meno, non solo una caratteristica tecnica di un linguaggio di programmazione.

Ad esempio, è possibile utilizzare i controlli isinstance in Python per simulare OO-style "di classe o sottoclasse-" di tipo vincoli. E 'anche possibile verificare la presenza di particolari attributi e metodi, di falsi vincoli di tipo strutturale (si potrebbe anche mettere i controlli in una funzione esterna, quindi ottenere in modo efficace un tipo strutturale di nome!). Vorrei affermare che nessuna di queste opzioni è esemplificando duck typing (a meno che le tipologie strutturali sono abbastanza a grana fine e tenuto in stretta sincronia con il codice di controllo per loro).