Duck Typing

O método de tipagem dinâmica Duck Typing, utilizado pela linguagem Ruby, baseia-se nesta premissa:

"If it walks like a duck and quacks like a duck, I would call it a duck"
"Se anda como um pato e faz 'quack' como um pato, eu posso chamar isso de um pato"

Logo, Ruby preocupa-se mais com os métodos de um objeto que são chamados do que o tipo do objeto em si. Por exemplo, se existir uma classe Pato, com métodos quack() e anda(), e uma outra classe chamada Marreco, com métodos com o mesmo nome da classe Pato, e uma função que simplesmente dado um objeto como argumento invoca os métodos quack() e anda(), não importa se objeto passado como argumento para a função será da classe Pato ou Marreco. O que definirá que a semântica é válida é que ambos os objetos responderão aos métodos quack() e anda(). Isso difere muito de outras linguagens, como C++, que não permitiriam isso a menos de polimorfismo e herança.

Exemplo:

class Pato
_def quack
__puts "Quack do Pato!"
_end
_def anda
__puts "O pato andou!"
_end
end


class Marreco
_def quack
__puts "Quack do Marreco!"
_end
_def anda
__puts "O marreco andou!"
_end
end

# Note que não há declaração de que tipo é o objeto passado como argumento.
# O que será levado em conta é como o objeto responde aos métodos que são chamados e assim será realizada a inferência de tipo.
def chama( objeto )
_objeto.quack
_objeto.anda
end

p = Pato.new
m = Marreco.new
chama(p)
chama(m)

Produz como resultado:
Quack do Pato!
O pato andou!
Quack do Marreco!
O Marreco andou!

Assim, uma linguagem com tipagem dinâmica do tipo duck typing assume que se um objeto responde a uma chamada de método característica de um outro tipo de objeto, este primeiro pode ser encarado como sendo do segundo tipo.