Duck typing para niños

En el mundo de la programación, especialmente en los lenguajes que trabajan con objetos, existe un estilo llamado duck typing o tipado pato. Imagina que tienes un juguete que camina y hace "cuac". Aunque no sea un pato de verdad, si se comporta como uno, ¡lo tratas como si lo fuera!

En programación, el "tipado pato" significa que no importa de qué "tipo" sea un objeto (por ejemplo, si es un "Pato" o una "Persona"), sino qué acciones puede realizar. Si un objeto puede "caminar" y "hacer cuac", entonces puedes usarlo en cualquier parte donde se espere algo que camine y haga "cuac".

El nombre viene de una frase divertida: "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." Esto significa que, en vez de revisar la "etiqueta" de un objeto, nos fijamos en lo que puede hacer.

Con el tipado pato, los programadores se concentran en las acciones que necesitan de un objeto. Por ejemplo, si necesitas una función que haga que algo "camine" y "haga cuac", no importa si le pasas un objeto llamado "Pato" o un objeto llamado "Persona" que también sabe "caminar" y "hacer cuac". Si el objeto no puede hacer lo que se le pide, el programa mostrará un error.

Este estilo de programación es muy flexible. Permite que diferentes tipos de objetos trabajen juntos si tienen las mismas habilidades, sin necesidad de que estén relacionados de una forma específica.

¿Cómo funciona el tipado pato?

El tipado pato se usa mucho en lenguajes de programación donde los "tipos" de los objetos se revisan mientras el programa se está ejecutando, no antes. Esto significa que el programador no necesita decir de antemano qué tipo exacto de objeto va a usar, solo que ese objeto debe tener ciertas habilidades.

Ejemplos sencillos de tipado pato

Imagina que tienes una función para "calcular" cosas.

función calcular(a, b, c) => devuelve (a+b)*c

• Si llamas a `calcular` con números (por ejemplo, `calcular(1, 2, 3)`), el programa sumará y multiplicará los números. El resultado sería 9.
• Si llamas a `calcular` con listas (por ejemplo, `calcular([1, 2, 3], [4, 5, 6], 2)`), el programa unirá las listas y luego las repetirá. El resultado sería `[1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6]`.
• Si llamas a `calcular` con textos (por ejemplo, `calcular('manzanas ', 'y naranjas, ', 3)`), el programa unirá los textos y luego los repetirá. El resultado sería `manzanas y naranjas, manzanas y naranjas, manzanas y naranjas,`.

En todos estos casos, la función `calcular` no se preocupa si `a`, `b` o `c` son números, listas o textos. Solo le importa que puedan hacer las operaciones de "sumar" (+) y "multiplicar" (*). Esto es el tipado pato en acción: si los objetos pueden hacer las operaciones, ¡funcionan!

Este concepto permite el polimorfismo, que es la capacidad de que un mismo código funcione con diferentes tipos de datos.

Un ejemplo con animales

Veamos un ejemplo más claro con un código de programación (en Python):

class Pato:
    def parpar(self): 
        print "Cuac!"
    def plumas(self): 
        print "El pato tiene plumas blancas y grises."
 
class Persona:
    def parpar(self):
        print "La persona imita el sonido de un pato."
    def plumas(self): 
        print "La persona toma una pluma del suelo y la muestra."
 
def en_el_bosque(animal):
    animal.parpar()
    animal.plumas()
 
def juego():
    donald = Pato()
    juan = Persona()
    en_el_bosque(donald)
    en_el_bosque(juan)

juego()

En este ejemplo, la función `en_el_bosque` no le importa si el objeto que recibe es un `Pato` o una `Persona`. Solo le importa que ese objeto tenga los métodos `parpar()` y `plumas()`. Como tanto `Pato` como `Persona` tienen esas habilidades, ambos pueden "entrar al bosque" y la función los tratará de la misma manera.

Tipado pato en diferentes lenguajes

Muchos lenguajes de programación usan el tipado pato de forma natural o lo permiten con algunas herramientas especiales.

Python

Python es un lenguaje que usa mucho el tipado pato. En Python, en lugar de preguntar si un objeto "es" de un tipo específico, se prefiere intentar hacer la acción y, si hay un error, manejarlo. Esto se conoce como "es más fácil pedir perdón que pedir permiso". Por ejemplo, si quieres que un objeto haga "cuac", simplemente intentas que lo haga. Si no puede, el programa te avisará con un error, y tú puedes decidir qué hacer en ese caso.

C#

En versiones más recientes de C# (como C# 4.0), se añadió una característica que permite usar el tipado pato. Esto significa que el programa puede decidir qué acciones puede hacer un objeto mientras se está ejecutando, en lugar de tener que saberlo todo de antemano.

Julia

Julia también permite el tipado pato de una forma muy flexible. En Julia, puedes definir funciones que trabajan con cualquier tipo de objeto, siempre y cuando ese objeto pueda realizar las acciones que la función necesita.

Historia del concepto

El término "duck typing" se popularizó en el año 2000, especialmente en discusiones sobre el lenguaje Python. La idea principal era que no se debía verificar si un objeto "es" un pato, sino si "se comporta" como un pato (si hace "cuac", si camina como uno, etc.).

Galería de imágenes

Véase también

En inglés: Duck typing Facts for Kids