Duck typing, ele deve ser dinâmico?

Question

Hotéis-pensão-costumava dizer* sobre pato-digitação:

Em programação de computadores com orientada a objetos linguagens de programação, duck typing é um estilo de dinâmica digitando em que um objeto atual conjunto de métodos e propriedades determina o válido semântica, ao invés de de sua herança a partir de um determinado de classe ou a implementação de um determinado interface.

_{(* Ed.nota:Desde esta questão foi publicado, o artigo da Wikipédia que foi editado para remover a palavra "dinâmica".)}

Ele diz sobre estruturais de digitação:

Estrutural tipo de sistema (ou com base na propriedade tipo de sistema) é um dos principais classe de tipo de sistema, em que tipo de de compatibilidade, e equivalência determinado pela estrutura do tipo, e não através de declarações explícitas.

Ele contrastes estruturais subtyping com pato-de escrever assim:

[Sistemas estruturais] contrasta com ...duck typing, em que apenas o parte da estrutura acessado em tempo de execução está marcada para compatibilidade.

No entanto, o termo pato-digitação parece-me, pelo menos intuitivamente, subsume estrutural sub-digitação de sistemas.Na verdade, diz a Wikipédia:

O nome do conceito-de-pato de digitação] refere-se à pato teste, atribuído a James Whitcomb Riley, que pode ser formulado como segue:"quando eu vejo um pássaro que anda como um pato, nada como um pato e grasna como um pato, eu chamo isso de um pássaro pato."

Então a minha pergunta é:por que não posso chamar de estruturais subtyping-de-pato escrever?Não há ainda existem linguagens de tipo dinâmico, que não pode ser classificado como sendo de pato escreveu?

Postscript:

Como alguém chamado daydreamdrunk no reddit.com então, eloquentemente colocá-lo "Se ele compila como um pato e links como um pato ..."

Post-scriptum

Muitas respostas parecem ser, basicamente, apenas revisitando o que eu já citado aqui, sem abordar a questão mais profunda, que é, por que não usar o termo-de-pato escrever para a cobertura de tipagem dinâmica e estrutural sub-escrever?Se você só quer falar sobre o pato-de escrever e não estruturais sub-digitando, em seguida, basta chamá-lo pelo que ele é: membro dinâmico de pesquisa.O meu problema é que nada sobre o termo pato-digitação me diz, isso só se aplica para linguagens dinâmicas.

Answer 1

C++ e D modelos são um perfeito exemplo do duck typing que não é dinâmico.É definitivamente:

digitando em que um objeto do atual conjunto de métodos e propriedades determina a válida semântica, ao invés da sua herança a partir de uma determinada classe ou a implementação de um determinado interface.

Você não especificar explicitamente uma interface que o tipo deve herdar de instanciar o modelo.Ele só precisa ter todas as características que são usados dentro da definição de modelo.No entanto, tudo é resolvido em tempo de compilação, e compilado para baixo para raw, inescrutáveis os números hexadecimais.Eu chamo isso de "tempo de compilação duck typing".Eu escrevi bibliotecas inteiras a partir desta mentalidade de que o modelo implícito de instanciação é tempo de compilação duck typing e acho que é uma das mais apreciadas funcionalidades lá fora.

Answer 2

Sistema de tipo estrutural

Um sistema de tipo estrutural compara um tipo inteiro com outro tipo inteiro para determinar se eles são compatíveis. Para dois tipos A e B para ser compatível, A e B deve ter a mesma estrutura - isto é, todo método em A e em B deve ter a mesma assinatura.

Digitação de pato

A digitação de pato considera dois tipos para serem equivalentes Para a tarefa em questão Se eles puderem lidar com essa tarefa. Para dois tipos A e B ser equivalente a um pedaço de código que deseja escrever em um arquivo, A e B Ambos devem implementar um método de gravação.

Resumo

Os sistemas de tipo estrutural comparam todas as assinaturas do método (estrutura inteira). A digitação de pato compara os métodos relevantes para uma tarefa específica (estrutura relevante para uma tarefa).

Answer 3

Digitação de pato significa Se apenas se encaixa, está tudo bem

Isso se aplica a ambos digitados dinamicamente

def foo obj
    obj.quak()
end

ou idiomas compilados estaticamente digitados

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

O ponto é que, em ambos os exemplos, não houve nenhuma informação sobre o tipo fornecido. Apenas quando usado (no tempo de execução ou no tempo de compilação!), Os tipos são verificados e se todos os requisitos forem atendidos, o código funcionará. Valores Não tem um tipo explícito no ponto de declaração deles.

A digitação estrutural depende de digitando explicitamente Seus valores, como sempre - a diferença é apenas que o tipo de concreto não é identificado pela herança, mas por sua estrutura.

Um código digitado estruturalmente (estilo scala) para o exemplo acima seria

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

Não confunda isso com o fato de que alguns idiomas estruturalmente digitados, como o OCAML, combinam isso com inferência de tipo para impedir que definirmos explicitamente os tipos.

Answer 4

Não tenho certeza se realmente responde à sua pergunta, mas ...

O código C ++ modelo parece muito parecido com o pato, mas é estático, com tempo de compilação, estrutural.

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

Answer 5

Entendo que a digitação estrutural é usada por infernos do tipo e similar a informação do tipo (pense em Haskell ou OCAML), enquanto a digitação de pato não se importa com "tipos" em si, apenas que a coisa pode lidar com uma invocação específica de método/ Acesso à propriedade, etc. (pense respond_to? na verificação de rubi ou capacidade em JavaScript).

Answer 6

Sempre haverá exemplos de algumas linguagens de programação que violam algumas definições de vários termos. Por exemplo, o ActionScript suporta programação de estilo de pato em instâncias que não são tecnicamente dinâmicas.

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

Nesse caso, testamos se a instância do objeto em "X" tem um método "começa" antes de chamá -lo em vez de usar uma interface. Isso funciona no ActionScript e é praticamente um pato, mesmo que a classe Someclass () não seja dinâmica.

Answer 7

Existem situações em que a digitação dinâmica de patos e o código de tipo estático semelhante (no IE C ++) se comportam de maneira diferente:

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

Em C ++, o objeto deve ter os dois isAlive e quak métodos para o código compilar; Para o código equivalente em idiomas tipados dinamicamente, o objeto só precisa ter o quak Método se isAlive() retorna verdadeiro. Eu interpreto isso como uma diferença entre estrutura (digitação estrutural) e comportamento (digitação de pato).

(No entanto, cheguei a essa interpretação, tomando a "tipo de pato deve ser dinâmica", da Wikipedia, e tentar fazer sentido. A interpretação alternativa que a digitação estrutural implícita é a digitação de patos também é coerente.)

Answer 8

Eu vejo o "duck typing" mais como um estilo de programação, considerando que "estruturais digitando" é um tipo de recurso do sistema.

Estruturais escrever refere-se à capacidade de o tipo de sistema de express tipos que incluem todos os valores que têm certas propriedades estruturais.

Duck typing refere-se a escrever código que utiliza apenas as características dos valores que ele é passado, que são realmente necessários para o trabalho na mão, sem impor quaisquer outras restrições.

Para que eu pudesse utilização tipos estruturais de um código em um duck typing estilo, por formalmente declarar meu "pato" tipos como tipos estruturais.Mas eu também poderia usar tipos estruturais sem "fazendo duck typing".Por exemplo, se eu escrever interfaces para um monte de funções relacionadas/métodos/procedimentos/predicados/classes/whatever declarando e nomenclatura comum estrutural tipo e, em seguida, usando em todos os lugares, é muito provável que algumas das unidades de código não necessário todos as características estruturais do tipo, e então eu tenho desnecessariamente restrita de alguns deles, para rejeitar os valores nos quais elas poderiam, teoricamente, funcionar correctamente.

Então, enquanto eu posso ver como lá é comum chão, eu não acho duck typing inclui estruturais de digitação.A maneira que eu penso sobre eles, duck typing não é mesmo uma coisa que poderia ter sido capaz de englobar estruturais de digitação, porque eles não são o mesmo tipo de coisa.Pensando em duck typing em linguagens dinâmicas como apenas "implícita, não verificado tipos estruturais" está faltando algo, IMHO.Duck typing é um estilo de codificação que você escolher usar ou não, e não apenas uma técnica característica de uma linguagem de programação.

Por exemplo, é possível usar isinstance verifica em Python para falso OO estilo "classe ou subclasse de" tipo de restrições.É possível, também, verificar particular atributos e métodos, para falso estruturais restrições de tipo (você pode até mesmo colocar as verificações em uma função externa, assim, efetivamente recebendo uma chamada estrutural tipo!).Eu diria que nenhuma destas opções está exemplificando duck typing (a menos que os tipos estruturais são bastante finos e mantidos em estreita sincronia com o código de verificação para eles).