Depois de conversar com alguns amigos do trabalho e ler alguns artigos achei que seria interessante iniciar um estudo sobre a linguagem Scala.
Achei bons materiais sobre o assunto disponíveis gratuitamente na internet.
Vou descrever a instalação e codificar um método simples, mas que já me deixou empolgado com a linguagem.
Isso foi feito no Mac OS, mas acredito que em qualquer linux deva funcionar.
A instalação não poderia ser mais simples. Baixei o binário da última versão estável no site da própria linguagem (http://www.scala-lang.org/downloads) descompactei em uma pasta de minha escolha, meu caso /opt e exportei algumas variáveis de ambiente.
Para que não precisasse ficar sempre exportando essas variáveis editei o arquivo /etc/profile para que isso acontecesse de forma “automática”.
Apenas essas duas linhas;
export SCALA_HOME="/opt/scala-2.7.7.final"
export PATH="$PATH:$SCALA_HOME/bin"
Feito isso você pode se certificar de que esta tudo OK executando no terminal o comando scala -version.
Agora vamos ao método!
Algo bem simples só para fazer algumas observações sobre a sintaxe da linguagem.
Vou criar um método que recebe um array de strings e muda todas para maiúscula, retornando o mesmo array de strings em caixa alta.
// Primeiro exemplo em Scala
class Teste {
def upper(strings: String*): Seq[String] = {
strings.map((s:String) => s.toUpperCase())
}
}
val up = new Teste
Console.println(up.upper("o", "primeiro", "codigo", "scala"))
Copie isso em algum editor de texto e salve como primeiro_teste.scala. O nome do arquivo tanto faz, Scala não faz questão que o nome do arquivo seja igual ao nome da classe.
Para rodar isso, abra o terminal va até a pasta aonde você salvou o arquivo e rode o comando scala primeiro_teste.scala. Isso ja vai compilar e executar o arquivo.
A assinatura do método.
Colocamos a palavra chave def nome do método e parâmetros entre parênteses.
Depois dos parâmetros vem o tipo de retorno precedido de :.
Seq é um tipo Collection da linguagem Scala. Usei, no retorno também, uma espécie de generics, em Scala os generics não ficam entre e sim entre [].
Outra coisa interessante é que o corpo do método sempre é precedido de =. Nem sempre os {} são necessários, mas o sinal de igual sim.
Saindo um pouco da assinatura do método outra característica interessante. O return não é obrigatório, mas pode ser especificado. Li em alguns lugares dizendo que especificar um return ao fim do método é muito pouco usado. A linguagem Scala entende que a última linha do corpo do método corresponde ao valor de retorno.
Porem caso seja necessário retornar algo no meio do corpo do método, isso pode ser feito sem grandes problemas.
Scala é estaticamente tipada, porem caso o tipo não seja explicitamente declarado o compilador consegue fazer isso com base no valor. Fiz apenas exemplos com valores literais, e eles funcionaram comigo sem especificar o tipo explicitamente.
Pesquisando um pouco dei uma mudada nesse exemplo (perfumaria).
object Teste {
def upper(strings: String*): Seq[String] = {
val teste = "Teste"
Console.println(teste)
strings.map((s:String) => s.toUpperCase())
}
}
Console.println(Teste.upper("o", "primeiro", "codigo", "scala"))
Agora ao invés de classe declarei diretamente um objeto. Isso simula um Singleton.
Não tem como não ficar empolgado, rss.
Vou continuar escrevendo sobre meu aprendizado. Por enquanto é só isso.
Até a próxima.
.
