Escalare - A louca jornada de um programador » scala

Truques em Scala – Extractors

gbenatti — Thu, 05 Nov 2009 14:41:46 +0000

Scala muitas vezes me surpreende com a elegancia e integridade da linguagem. O que chamo aqui de integridade, é a forma como a linguagem combina vários conceitos de uma forma uniforme.

Uma das features interessantes de Scala é que ela permite ao programador extrair informações de objetos usando pattern matching, por exemplo se você tiver o seguinte tipo chamado Email:

case class Email(name: String, domain: String)

Seria possivel testar se um objeto é do tipo Email, e ao mesmo tempo retornar o name e domain com o seguinte código:

unknownObject match {
case Email(name, domain) =>
println(name + " at " + domain)
case _ =>
println("It’s not an email")
}

No caso de unknownObject ser declarado como:

val unknownObject = Email("georges", "gbenatti.net")

A saida seria “georges at gbenatti.net”

Já se unknownObject fosse declarado como:

val unknownObject: Any = "georges@gbeatti.net"

A saida seria “It’s not an email”

Mas não seria muito legal se fosse possivel fazer essa segunda opção funcionar ? Ai entra a elegância de Scala, você pode definir extractors que permitem que sejam extraidos dados de determinadas estruturas, sejam elas árvores, listas e até mesmo strings.

Um extractor é um objeto Scala que define um método unapply. A responsabilidade do unapply é fazer o matching de um valor e o separar em seus componentes, para o caso acima o extractor poderia ser definido assim:

object EmailStr {
def unapply(str: String): Option[(String, String)] = {
val parts = str split "@"
if (parts.length == 2) Some(parts(0), parts(1)) else None
}
}

Definido esse extractor poderiamos reescrever o match da seguinte forma:

unknownObject match {
case Email(name, domain) =>
println(name + " at " + domain)
case EmailStr(name, domain) =>
println(name + " at " + domain)
case _ =>
println("It’s not an email")
}

E ele funcionaria tanto com objetos da classe Email quanto com strings no formato name@domain, ou seja, código final do usuário simples e elegante.

Até mais pp pessoal…

Truques em Scala – Structural Typing

gbenatti — Tue, 27 Oct 2009 22:06:43 +0000

As linguagens dinâmicas como Ruby e Python tem algumas capacidades bem interessantes, entre elas esta a possibilidade de passar um objeto para um método e desde que o objeto implemente os métodos necessários (ex: name, height), o método executará corretamente.

Já as linguagens estáticas normalmente não tem essa capacidade, algumas, como por exemplo Boo implementam essa possibilidade através de dispatch in runtime para os métodos que necessitam dessa caracteristica, já Scala tem uma solução bem elegante.

Por exemplo, digamos que você queira definir um método que espere um objeto que tenha as propriedades name e age, uma forma comumente usada em linguagens estáticas seria a seguinte:

Definir uma interface com os métodos que interessam:

trait BasicProperties {
def name: String
def age: Int
}

Escrever as classes implementando BasicProperties e o método recebendo como parametro um objeto do tipo BasicProperties:

class Pet(val name: String, val age: Int) extends BasicProperties
class Person(val name: String, val age: Int) extends BasicProperties
def printProp(in: BasicProperties) =
println(in.name+" is " + in.age + " years old")

E então você poderia chamar o método assim:

printProp(new Pet("Galfildo", 8))
printProp(new Person("Maria", 18))

Se você tivesse uma classe tipo:

class Antique(val name: String, val Age: Int, val cost: Int)

Você não poderia usar um objeto desse tipo como parametro para printProp, já que a classe não herda BasicProperties.

A solução está na capacidade que Scala tem de definir algo que poderia ser chamado de anonymous interfaces, no caso, o método printProp seria escrito assim:

def printProp(in: {def name: String; def age: Int}) =
println(in.name+" is " + in.age + " years old")

Como se você estivesse definindo como parametro um tipo anonimo, que tem um método name do tipo String e um método age do tipo Int

E então poderia executar:

printProp(new Pet("Galfildo", 8))
printProp(new Person("Maria", 18))
printProp(new Antique("Monalisa", 450, 1000))

Como se ve, um código muito parecido com o escrito em Ruby e Python, mais ainda com uma caracteristica de documentação, já que o método é explicito sobre o que ele necessita.

Truques em Scala – Como fazer parsing de um xml

gbenatti — Tue, 27 Oct 2009 16:35:00 +0000

Ontem eu precisei extrair alguns dados de um xml, e acho que as lições aprendidas merecem ficar registradas, vai que mais alguem nesse mundão precisa fazer algo assim.

service="Service 1">
>
key="key1">value1>
key="key2">value2>
>
>

O objetivo era extrair o nome do service como uma string e as entries como um map de key values.

O servico como string é bem facil, considerando que o xml esta em uma variavel serviceXml, teriamos:

val serviceName = (serviceXml\"@service").text

O que isso faz é basicamente pegar o attributo service do nó em questão e com esse dado pegar o nó como text.

A segunda parte é um pouco mais complexa então vamos por parte, primeiro pegamos as entries:

val entries = serviceXml\"extra"\\"entry"

Esse codigo executa basicamente um XPath extraindo do xml o nó “extra” e deste a lista de nós “entry”

Então, para cada entry extraimos uma tupla com o valor da key e o value:

val entriesTuple = for (entry <- entries) yield ((entry\"@key").text, entry.text)

Aqui usamos um for expression para percorrer a lista entries e retornar (usando yield) uma tupla que contem o valor da key e o inner text da entry

E por fim criar um Map com esses dados:

val mapResult = Map(entriesTuple: _*)

Por fim, como construir um Map apartir de uma lista, ou nesse caso de um generator ?

Maps podem ser contruidos usando de um numero variavel de tuplas usando algo como Map(tupla1, tupla2, tuplaN).

Se tentarmos usar Map(entriesTuple) o compilador vai reclamar falando que esse metodo nao pode ser executado com uma Seq[(String, String)], ou seja, uma sequencia de tuplas contendo duas Strings.

Temos que dar um jeito de passar essa Seq como um numero variavel de argumentos, e os desenvolvedores de Scala nos deram uma forma de fazer isso, quando temos que passar uma lista para um método que espera um número variavel de argumentos podemos fazer assim:

Map(entriesTuples: _*)

Essa anotação diz ao compilador para expandir os parametros

Juntando tudo temos:

val mapResult = Map((for (entry <- serviceXml\"extra"\\"entry") yield ((entry\"@key").text, entry.text)): _*)

Muita explicação pra pouco código, assim é Scala

Cheers

Instalando Scala

gbenatti — Thu, 10 Sep 2009 01:18:00 +0000

Para instalar Scala no Mac OS X, baixe o instalador do seguinte link:

http://www.scala-lang.org/downloads/distrib/files/scala-2.7.5.final-installer.jar

Esse link é pra versão 2.7.5 da linguagem.

Execute o instalador, entrando no terminal, vá até o diretório onde se encontra o instalador e digite:

sudo java -jar scala-2.7.5.final-installer.jar

Escolha a linguagem de sua preferência e o local de instalação. No meu caso eu vou aceitar as opções Inglês e /usr/local/

Depois de terminada a instalação, adicione o path de instalação as variáveis de ambiente, edite o arquivo .profile no seu diretório HOME, e adicionar a seguinte linha:

export PATH=/usr/local/scala-2.7.5.final/bin:$PATH

Onde /usr/local/scala-2.7.5.final é o local onde o compilador foi instalado.

Para testar a instalação, feche o terminal e o abra novamente, digite scala -version e você deve ver a mensagem:

É isso ai, até a próxima.