Canard frappe, doit-il être dynamique?

StackOverflow https://stackoverflow.com/questions/1948069

Question

Wikipedia l'habitude de dire * sur le canard frappe :

  

Dans la programmation informatique avec   langages de programmation orientés objet,   frappe de canard est un style de dynamique   typage dans lequel le courant d'un objet   définir des méthodes et des propriétés   détermine la sémantique valides, plutôt   que son héritage d'un particulier   classe ou la mise en œuvre d'un particulier   interface.

(* NDLR:.. Comme cette question a été publiée, l'article de Wikipedia a été modifié pour supprimer le mot "dynamique")

Il dit sur la saisie structurelle :

  

Un système de type structural (ou   système de type à base de propriété) est un important   classe de système de type, dans lequel le type   la compatibilité et de l'équivalence sont   déterminé par la structure du type,   et non par des déclarations explicites.

Il contraste avec la structure sous-typage canard-typage comme ceci:

  

[systèmes structurels] contraste avec   ... frappe de canard, dans lequel seule la   une partie de la structure consultée à   exécution de vérifier la compatibilité.

Cependant, le terme canard taper me semble au moins subsumer intuitivement des systèmes de sous-typage de structure. En fait Wikipedia dit:

  

Le nom du concept [de canard frappe]   fait référence à un test de canard du , attribué à   James Whitcomb Riley qui peut être formulée comme   suit: « quand je vois un oiseau qui marche   comme un canard et nage comme un canard et   Les charlatans comme un canard, que j'appelle un oiseau   canard. "

Alors, ma question est: pourquoi je ne peux pas appeler canard tapant sous-typage structurel? Ne il existe même des langues dynamiquement tapées qui ne peuvent également être classés comme étant le canard typé?

Postscript:

Comme quelqu'un nommé daydreamdrunk sur reddit.com si

Autres conseils

Système Type de construction

Un système de type structural compare un type entier à un autre type entier pour déterminer si elles sont compatibles. Pour deux types A et B soient compatibles, A et B doivent avoir la même structure -. Par conséquent, toutes les méthodes sur A et B doit avoir la même signature

Taper Duck

duck typing considère deux types comme équivalent pour la tâche si elles sont capables de gérer cette tâche. Pour deux types A et B être équivalent à un morceau de code qui veut écrire dans un fichier, et A B les deux doivent mettre en œuvre une méthode d'écriture.

Résumé

systèmes de type structural comparer chaque signature de la méthode (structure entière). Canard frappe compare les méthodes qui sont pertinentes pour une tâche spécifique (structure pertinente à une tâche).

moyens de frappe de canard S'il convient juste, il est OK

Cela vaut à la fois tapé dynamiquement 

def foo obj
    obj.quak()
end

ou statiquement typé, langages compilés 

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

Le point est que dans les deux exemples, il n'y a pas eu d'informations sur le type donné. Juste quand il est utilisé (que ce soit lors de l'exécution ou la compilation!), Les types sont vérifiées et si toutes les conditions sont remplies, le code fonctionne. Les valeurs ne disposent pas d'un type explicite à leur point de déclaration.

Saisie structurelle repose sur en tapant explicitement vos valeurs, comme d'habitude -. La différence est juste que le type de béton est pas identifié par héritage, mais par sa structure

Un code structurellement typé (Scala style) pour l'exemple ci-dessus serait 

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

Ne pas confondre avec le fait que certains structurellement langages typés comme OCaml combiner avec l'inférence de type afin de nous empêcher de définir les types explicitement.

Je ne sais pas si cela répond vraiment à votre question, mais ...

code C ++ basé sur un modèle ressemble beaucoup à canard frappe, mais est statique, la compilation, structurelle. 

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

Je crois comprendre que le typage structurel est utilisé par type d'inferencers et autres pour déterminer les informations de type (pensez Haskell ou OCaml), tandis que le canard frappe ne se soucie pas de « types » en soi, juste que la chose peut gérer un particulier appel de méthode / accès à la propriété, etc. (pensez respond_to? en Ruby ou la capacité de vérification en Javascript).

Il y aura toujours des exemples de certains langages de programmation qui ne respectent pas certaines définitions des termes différents. Par exemple, ActionScript prend en charge la programmation faisant de style typage de canard sur les instances qui ne sont pas techniquement dynamiques. 

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

Dans ce cas, nous avons testé si l'instance d'objet dans « x » a une méthode « commencer » avant de l'appeler au lieu d'utiliser une interface. Cela fonctionne dans ActionScript et est à peu près de canard frappe, même si la SomeClass de classe () ne peut pas être lui-même dynamique.

Il y a des situations dans lesquelles la saisie de canard dynamique et le même code statique typée (en savoir C ++) se comportent différemment: 

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

C ++, l'objet doit avoir à la fois les méthodes de isAlive et quak pour le code à compiler; pour le code équivalent dans les langues dynamiquement tapées, l'objet n'a besoin que d'avoir la méthode quak si isAlive() renvoie true. J'interprète cela comme une différence entre la structure (dactylographie structurel) et le comportement (typage de canard).

(Cependant, je suis arrivé à cette interprétation en prenant « canard frappe doit être dynamique » de Wikipédia à leur valeur nominale et d'essayer de faire sens. L'autre interprétation que le typage structurel implicite frappe de canard est également cohérente.)

Je vois plus comme un style de programmation « canard tapant », alors que « la saisie structurelle » est une caractéristique du système de type.

typage structurel fait référence à la capacité du système de type à exprimer types qui incluent toutes les valeurs qui ont certaines propriétés structurelles.

duck typing fait référence au code d'écriture qui utilise simplement les caractéristiques des valeurs qu'il est passé qui sont réellement nécessaires pour le travail à la main, sans imposer d'autres contraintes.

Je pourrais utiliser à code dans un style de frappe de canard types de structure, en déclarant formellement mes « types de canard » comme types de structure. Mais je pourrais aussi utiliser des types de structure sans « faire taper de canard ». Par exemple, si j'écris des interfaces à un groupe de fonctions connexes / méthodes / procédures / prédicats / classes / tout en déclarant et en nommant un type de structure commune, puis en utilisant que partout, il est très probable que certaines des unités de code ne ont pas besoin tous des caractéristiques du type de structure, et donc je l'ai inutilement contraint certains d'entre eux de rejeter les valeurs sur lesquelles ils pourraient théoriquement fonctionner correctement.

Ainsi, alors que je peux voir comment il y a un terrain d'entente, je ne pense pas taper de canard subsume frappe structurale. La façon dont je pense à eux, la frappe de canard est même pas une chose qui aurait pu être en mesure de subsumer frappe structurelle, parce qu'ils ne sont pas le même genre de chose. Vous songez duck typing dans les langages dynamiques comme juste « implicites, les types de structure non vérifiées » manque quelque chose, à mon humble avis. frappe de canard est un style de codage que vous choisissez d'utiliser ou non, et pas seulement une caractéristique technique d'un langage de programmation.

Par exemple, il est possible d'utiliser des contrôles de isinstance en Python pour faux-style OO « classe ou sous-classe » contraintes de type. Il est également possible de vérifier les attributs particuliers et des méthodes, des contraintes de type structurel faux (vous pouvez même mettre les contrôles dans une fonction externe, obtenant ainsi efficacement un type de structure nommée!). Je ne prétendra que aucune de ces options est illustrative frappe de canard (à moins que les types de structure sont tout à fait à grains fins et maintenu en phase étroite avec le code de vérification pour eux).

Non affilié à StackOverflow
scroll top