title: Duck typing
text: # Duck typing
  
  En los lenguajes de programación orientados a objetos, se conoce como duck typing o tipado pato el estilo de tipificación dinámica de datos en que el conjunto actual de métodos y propiedades determina la validez semántica, en vez de que lo hagan la herencia de una clase en particular o la implementación de una interfaz específica. El nombre del concepto se refiere a la prueba del pato, una humorada de razonamiento inductivo atribuida a James Whitcomb Riley (ver Historia más abajo), que pudo ser como sigue:
      "Cuando veo un ave que camina como un pato, nada como un pato y suena como un pato, a esa ave yo la llamo un pato."
  En duck typing, el programador solo se ocupa de los aspectos del objeto que van a usarse, y no del tipo de objeto que se trata. Por ejemplo en un lenguaje sin duck-typing uno puede crear una función que toma un objeto de tipo Pato y llama los métodos "caminar" y "parpar" de ese objeto. En un lenguaje con duck-typing, la función equivalente tomaría un objeto de cualquier tipo e invocaría los métodos caminar y parpar. Si el objeto tratado no tiene los métodos pedidos, la función enviará una señal de error en tiempo de ejecución. Este hecho de que la función acepte cualquier tipo de objeto que implemente correctamente los métodos solicitados es lo que evoca la cita precedente y da nombre a la forma de tipificación.
  El Duck typing usualmente es acompañado por el hábito de no probar el tipo de los argumentos en los métodos y funciones, y en vez de eso confiar en la buena documentación, el código claro y la prueba para asegurar el uso correcto. Los usuarios de lenguajes con tipificado estático al iniciarse con lenguajes de tipificado dinámico a menudo se ven tentados a agregar chequeos de tipo estáticos (previos a ejecución), desaprovechando la flexibilidad y beneficios del duck typing y restringiendo el dinamismo del lenguaje.
  
  # Duck typing
  ## Ejemplos del concepto
  
  Considera el siguiente pseudocódigo para un lenguaje con duck-typing:
  En el ejemplo, cada vez que se llama la función calcular se pueden emplear objetos sin relación de herencia (números, listas y cadenas). En tanto y en cuanto los objetos soporten los métodos "+" y "*" la operación tendrá éxito. Si se traduce este algoritmo a Ruby o Python por ejemplo, el resultado de la ejecución será:
  Así, el duck typing permite polimorfismo sin herencia. El único requerimiento de la función calcular para las variables es que soporten los métodos "+" y "*".
  La prueba del pato puede verse en el siguiente ejemplo (en Python). Hasta donde a la función en_el_bosque le importa, el objeto es un pato:
  
  # Duck typing
  ## Duck typing en lenguajes de tipificación estática
  
  Ciertos lenguajes que usualmente son de tipificación estática como Boo y la versión 4 de C# tienen anotaciones extra de tipos que instruyen al compilador para que disponga el chequeo de tipo de las clases en tiempo de ejecución y no en tiempo de compilación, y que incluya código de chequeo de tipos en tiempo de ejecución en la salida compilada. Estos agregados permiten al lenguaje gozar de la mayor parte de los beneficios del duck-typing con la única desventaja de tener que identificar y especificar qué clases serán dinámicas en tiempo de compilación.
  
  # Duck typing
  ## Comparación con otros tipos de tipificación
  ### Sistemas de tipificación estructural
  
  El duck typing es similar pero diferente a la tipificación estructural. La tipificación estructural es un sistema de tipificación estática que determina la compatibilidad y la equivalencia de tipos según su estructura, mientras que el duck typing es dinámico y determina dicha compatibilidad basándose en la parte de la estructura que se accede en tiempo de ejecución. El lenguaje de programación Objective Caml usa un sistema de tipificación estructural.
  
  # Duck typing
  ## Comparación con otros tipos de tipificación
  ### Interfaces
  
  Las interfaces pueden proveer algunos de los beneficios del duck typing pero este es diferente en cuanto no se define explícitamente una interfaz. Por ejemplo, si una librería Java de terceros implementa una clase que no es posible modificar, no se podrá usar una instancia de esa clase en lugar de una interfaz definida por uno mismo, mientras que el duck typing sí permite hacerlo.
  
  # Duck typing
  ## Comparación con otros tipos de tipificación
  ### Templates o tipos genéricos
  
  Los Template, funciones o métodos genéricos aplican la prueba del pato en un contexto de tipificación estática; esto reúne todas las ventajas y desventajas de la tipificación estática contra la tipificación dinámica en general. El duck typing puede también ser más flexible en que solo los métodos llamados en tiempo de ejecución necesitan ser implementados, mientras que los templates requieren que se implemente todos los métodos que no deban resultar inaccesibles en tiempo de compilación.
  Puede mencionarse como ejemplos los lenguajes C++ y D con templates, que derivaron de los genéricos de Ada.
  
  # Duck typing
  ## Críticas
  
  Una crítica citada a menudo dice:
      Un problema con el duck typing es que fuerza al programador a tener un entendimiento mucho más amplio del código con que está trabajando en todo momento. En un lenguaje con tipificación estática y fuerte que use controles de tipo en jerarquías y parámetros, es mucho más difícil pasarle un tipo inesperado de objeto a una clase. Por ejemplo en Python podrías fácilmente crear una clase llamada Vino, que espera una clase que implemente el atributo "prensa" como un ingrediente. Sin embargo una clase llamada Imprenta podría también implementar un método llamado prensa. Con duck typing, para poder prevenir errores extraños y difíciles de detectar el desarrollador debe ser consciente de cada uso potencial del método "prensa", aunque esté conceptualmente desvinculado del tema con que esté trabajando.
      Esencialmente, el problema es que "si camina como pato y se oye como pato", podría ser un dragón haciendo el pato. No siempre querrás dejar los dragones en el estanque, aunque sepan hacerse pasar por patos.
  Los defensores del duck typing como Guido van Rossum argumentan que el asunto se maneja con pruebas, y con el conocimiento del código necesario para mantenerlo.
  Las críticas acerca del duck typing tienden a ser casos especiales de aspectos más amplios relacionados con la disputa entre la tipificación estática y la dinámica.
  
  # Duck typing
  ## Historia
  
  Alex Martelli hizo uso precoz (2000) del término en un mensaje del grupo de noticias comp.lang.python. También resaltó la malinterpretación de la prueba literal del pato, lo que podría indicar que el término ya era usado.
      En otras palabras, no chequeen si ES un pato, chequeen si PARPA como pato, CAMINA como pato, etc, etc, dependiendo de exactamente qué parte de la conducta de un pato necesitan para jugar su juego de lenguaje..
  
  # Duck typing
  ## Implementaciones
  ### En C#
  
  En C# 4.0 el compilador y la ejecución colaboran para implementar dynamic member lookup.
  
  # Duck typing
  ## Implementaciones
  ### En ColdFusion
  
  El lenguaje de scripting para desarrollo de aplicaciones web ColdFusion permite que los argumentos de las funciones sean de tipo any (cualquiera). Para este tipo de argumento, puede pasarse un tipo arbitrario de objeto y las llamadas a métodos son entabladas en tiempo de ejecución. Si un objeto no implementa un método solicitado, se arroja una excepción en tiempo de ejecución que puede ser capturada y manejada adecuadamente. En ColdFusion 8, esta circunstancia se puede capturar con el evento onMissingMethod en vez de con un manejador de excepciones. Un tipo alternativo de argumento WEB-INF.cftags.component restringe el tipo de objeto solo a componentes ColdFusion (CFC) lo cual permite un mejor manejo de mensajes de error cuando se pasan elementos que no sean objetos.
  
  # Duck typing
  ## Implementaciones
  ### En Common Lisp
  
  Common Lisp provee una extensión orientada a objetos (Common Lisp Object System, abreviado CLOS). La combinación de CLOS y la tipificación dinámica de Lisp hacen del duck typing un estilo de programación habitual en Common Lisp.
  Con Common Lisp uno tampoco necesita averiguar los tipos, porque en la ejecución se obtendrá una señal de error en caso de que una función no sea aplicable. El error puede manejarse con el Sistema de Condiciones de Common Lisp. Los métodos se definen fuera de las clases y también pueden definirse para objetos específicos.
  El estilo usual de desarrollo en Common Lisp (usando un Lisp REPL como SLIME) permite también la reparación interactiva:
  De este modo se puede desarrollar el software extendiendo código duck-typed que funciona parcialmente.
  
  # Duck typing
  ## Implementaciones
  ### En Objective-C
  
  Objective-C, un híbrido entre C y Smalltalk, permite declarar objetos de tipo 'id' y enviarles cualquier mensaje, como en SmallTalk. Quien envía puede probar un objeto para ver si ha respondido al mensaje, el objeto puede decidir al recibir el mensaje si responderá al mensaje o no, y si el remitente envía un mensaje al que el receptor no puede responder, se arroja una excepción. Así, duck typing es completamente soportado en Objective-C.
  
  # Duck typing
  ## Implementaciones
  ### En Python
  
  El duck typing se usa intensivamente en Python. El Glosario de Python define el duck typing como sigue:
  El ejemplo estándar de duck typing en Python son las clases que se asimilan a archivos. Estas clases pueden implementar algunos o todos los métodos de archivo y pueden usarse donde normalmente se usaría archivo. Por ejemplo, GzipFile implementa un objeto similar a un archivo para acceder a datos comprimidos con el algoritmo gzip. cStringIO permite tratar una cadena como un archivo. Los sockets y los archivos también comparten muchos atributos. Sin embargo, los sockets no disponen del método tell y no pueden usarse dondequiera que puede usarse GzipFile. Esto demuestra la flexibilidad del duck typing: un objeto que se asemeja a un archivo implementa solo los métodos que puede, y consecuentemente solo puede usarse donde tiene sentido hacerlo.
  El principio de "es más fácil pedir perdón que pedir permiso" describe el uso del manejo de excepciones. Por ejemplo en vez de ver si un objeto que supuestamente se asemeja al objeto Pato usado en el ejemplo precedente tiene o no el método parpar (usando if hasattr(azulon, "parpar"): ... es preferible rodear el intento de parpar con un manejo de excepciones:
  Las ventajas de esta forma de trabajo son que favorece el manejo estructurado de otras clases de errores (así, por ejemplo, una subclase de Pato mudo podría arrojar una excepción de tipo CuacException que podría agregarse al manejador sin ahondar mucho en la lógica del código, y manejar situaciones en que diferentes clases de objetos pudieran tener colisiones de nombres por miembros incompatibles (si tuviésemos una persona de apellido Azulón con un atributo lógico "parpa=True"; un intento de ejecutar Azulón.parpar arrojaría un TypeError)).
  Volviendo al campo de los ejemplos más prácticos que implementan conductas similares a las de un archivo, es preferible generalmente emplear las herramientas de tratamiento de excepciones de Python para manejar la amplia variedad de errores de E/S que pueden ocurrir debido a numerosos problemas ambientales y de sistema operativo que escapan al control del programador. Aquí nuevamente las excepciones de "duck typing" pueden ser atrapadas junto a las de SO, E/S u otros posibles errores sin complicados chequeos ni lógicas de comprobación de errores.
  
  # Duck typing
  ## Implementaciones
  ### En Julia
  
  Julia usa despacho múltiple, funciones genéricas, anotaciones de tipos opcionales e inferencia de tipos automática por defecto, el tipo Any es el super-tipo de toda la jerarquía, ejemplo en el REPL (bucle de lectura-evaluación-impresión) interactivo de Julia: