Duck Typing aplicado no Scala

Nem me lembro a última vez que eu passei aqui… Estava aqui num projeto pessoal e achei um caso bem legal para o famoso Duck Typing. 

A minha situação é a seguinte. Tenho um método que tem que atualizar a localização de um objeto no banco. A assinatura do método tinha que ser mais ou menos assim:

   def update(crawledUrl: String, latitude: Double; longitude: Double)

O problema aqui é que eu quero receber um objeto que representa a localização. Normalmente, seria necessário criar uma classe para representar esse objeto. O que levaria o código a ficar assim:

  def update(crawledUrl: String, localizacao:MinhaLocalizaco) = {
         println(localizacao.getLatitude)
         println(localizacao.getLongitude)
  }

Só que na ponta onde eu invoco o método, preciso transformar a localização que vem da biblioteca para o meu objeto do tipo MinhaLocalizacao.  Na verdade não tem nenhum problema, só que demos uma volta meio grande para recebe-lo. Nesses cenários, ter uma linguagem a mais na sua caixa de ferramenta pode deixar o código mais flexível. Aqui está uma outra opção para a implementação do mesmo método.

  def update(crawledUrl: String, location: { def getLatitude: Double; def getLongitude: Double })

Perceba que eu pouco me importo com o tipo de objeto, o que eu defino é uma interface que exige os métodos getLatitude getLongitude. Não forço ninguém a criar nada, posso receber objeto de qualquer tipo, bem mais tranquilo. Isso é o que a galera chama no Scala de Structural TypingNo mundo de linguagens de script é chamado de Duck Typing. A invocação do método, que por sinal está em uma classe Java, segue abaixo:

   //getLocation retorna um objeto da biblioteca...
   dao.update(id, location.getGeometry().getLocation())

O único detalhe que saímos perdendo aqui, é que como a chamada do método está num método escrito em Java, não vai ter a checagem do tipo sendo passado. Então não rola uma garantia de compilação, o que é um ponto bem legal dessa abordagem no Scala. Se a chamada estivesse num código Scala, só seria permitido passar algum objeto que respondesse para os métodos necessários.

Bom, era isso. Já chegaram a usar Duck Typing nas outras linguagens? O que achou dessa solução? Poste aqui para o bem e para o mal.

Advertisements

6 thoughts on “Duck Typing aplicado no Scala

  1. C# tem também classes anônimas, mas elas não tem contratos bem definidos como esses de Scala. Ou seja, o compilador, quando informado que aquele tipo é dinâmico, deixa tudo pra runtime.

    Interessante isso. Mas preciso pensar melhor sobre quando NÃO usar essa feature da linguagem.

  2. Duck Typing em Ruby é bem bacana também e ele só vai checar se aquele método existe ou não ao executar o código.
    Bem decente a abordagem do Scala de validar se o objeto já tem o método.

  3. Gosto do structural typing, mas me incomoda o tipo { def getLatitude: Double; def getLongitude: Double } ficar sem um nome e a sujeira que fica na assinatura dos métodos (e, se mais de um método usa o mesmo tipo, a repetição dessa sujeira). Felizmente, dá pra resolver tudo isso com type aliases:

    type Localizacao = { def getLatitude: Double; def getLongitude: Double }
    def update(crawledUrl: String, location: Localizacao)

    Post legal. Escreva mais. 🙂

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s