Duck typing

En els llenguages de programació orientats a objectes, es coneix com duck typing o tipado ànet l'estil de tipificación dinàmica de senyes que el conjunt actual de métodos i propietats determina la validea semàntica, en lloc de que ho facen l'herència d'una classe en particular o l'implementació d'un interfaç específic. El nom del concepte es referix a la prova de l'ànet, una humorada de raonament inductivo atribuïda a James Whitcomb Riley (vore Història més avall), que va poder ser com seguix:

"Quan veig un au que camina com un ànet, res com un ànet i sona com un ànet, a eixa au yo la cride un ànet."

En duck typing, el programador solament s'ocupa dels aspectes de l'objecte que van a usar-se, i no del tipo d'objecte que es tracta. Per eixemple en un llenguage sense duck-typing un pot crear una funció que pren un objecte de tipo Ànet i crida els métodos "caminar" i "parpar" d'eixe objecte. En un llenguage en duck-typing, la funció equivalent prendria un objecte de qualsevol tipo i invocaria els métodos caminar i parpar. Si l'objecte tractat no té els métodos demanats, la funció enviarà una senyal d'error en temps d'eixecució. Este fet de que la funció accepte qualsevol tipo d'objecte que implemente correctament els métodos solicitats és lo que evoca la cita precedent i dona nom a la forma d'tipificación.

El Duck typing usualment és acompanyat per l'hàbit de no provar el tipo dels arguments en els métodos i funcions, i en lloc d'això confiar en la bona documentació, el còdic clar i la prova per a assegurar l'us correcte. Els usuaris de llenguages en tipificat estàtic en iniciar-se en llenguages de tipificat dinàmic a sovint es veuen tentats a agregar chequeos de tipo estàtics (previs a eixecució), desaprofitant la flexibilitat i beneficis del duck typing i restringint el dinamisme del llenguage.

Eixemples del concepte

Considera el següent pseudocódigo per a un llenguage en duck-typing:

funció calcular(a, b, c) => torna (a+b)c

eixemple1 = calcular (1, 2, 3)
eixemple2 = calcular ([1, 2, 3], [4, 5, 6], 2)
eixemple3 = calcular ('pomes ', 'i taronges, ', 3)

mostrar a_cadena eixemple1
mostrar a_cadena eixemple2
mostrar a_cadena eixemple3

En l'eixemple, cada volta que es diu la funció calcular es poden amprar objectes sense relació d'herència (números, llestes i cadenes). En tant i en quant els objectes soporten els métodos "+" i "*" l'operació tindrà èxit. Si es traduïx este algoritme a Ruby o Python per eixemple, el resultat de l'eixecució serà:

9
[1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6]
pomes i taronges, pomes i taronges, pomes i taronges,  

Aixina, el duck typing permet polimorfisme sense herència. L'únic requeriment de la funció calcular per a les variables és que soporten els métodos "+" i "*".

La prova de l'ànet pot vore's en el següent eixemple (en Python). Fins a a on a la funció en_el_bosc li importa, l'objecte és un ànet:

class Ànet:
    def parpar(self): 
        print "Cuac!"
    def plomes(self): 
        print "L'ànet té plomes blanques i grises."
 
class Persona:
    def parpar(self):
        print "La persona imita el sò d'un ànet."
    def plomes(self): 
        print "La persona pren una ploma del sol i la mostra."
 
def en_el_bosc(ànet):
    ànet.parpar()
    ànet.plomes()
 
def joc():
    donald = Ànet()
    juan = Persona()
    en_el_bosc(donald)
    en_el_bosc(juan)

joc()

Duck typing en llenguages d'tipificación estàtica

Certs llenguages que usualment són d'tipificación estàtica com Boo i la versió 4 de C# tenen anotacions extra de tipos que instruïxen al compilador per a que disponga el chequeo de tipo de les classes en temps d'eixecució i no en temps de compilació, i que incloga còdic de chequeo de tipos en temps d'eixecució en l'eixida compilada. Estos agregats permeten al llenguage gojar de la major part dels beneficis del duck-typing en l'única desventaja de tindre que identificar i especificar qué classes seran dinàmiques en temps de compilació.