Linguagem de Programação Scala

Todos que trabalham com informática devem ter ouvido pelo menos uma vez na vida coisas como programação estruturada ou programação orientada a objetos. Quem conhece java com certeza já ouviu falar também de programação orientada a aspectos. Algumas coisas, entretanto não são muito discutidas como programação funcional e pattern matiching.

Essa linguagem nova, Scala, é uma mistura de muitas coisas. Ela trabalha orientada a objetos, suportando programação funcional e com pattern matiching. Para quem tem medo dessas linguagens novas, se vão pegar, se tem bastante frameworks não precisam se preocupar, o código que ela gera são classes java. Isso mesmo, ela é feita como uma layer sobre o java com sua própria sintaxe que, quando você complila um código, ele gera classes java mas você vai precisar do ambiente do Scala instalado para poder rodar essas classes.

Umas das coisas que me chamou a atenção nessa linguagem foi o seguinte. Imagine o seguinte código em java:

Trecho 1

public class NumeoSimple {
     protected int valor;
     public NumeoSimple(int valor){
             this.valor = valor;
     }
     public NumeoSimple soma(int valor){
             this.valor += valor;
     }
     public int getValor(){
             return valor;
     }
}
public class NumeoComposto extends
   NumeroSimples {
     public NumeoComposto (int valor){
             super(valor);
     }
     public NumeoSimple subtrai(int valor){
             this.valor -= valor;
     }
}
....
NumeoComposto numero = new NumeroComposto(10);
int i = numero.soma(10).subtrai(5).getValor();

Parece estar estar tudo certo, mas observe que o retorno do método soma é um NumeoSimple que não tem o método subtrai. A linha do Trecho 2 não poderá ser compilada, para corrigir isso podemos fazer com no Trecho 3 mas já estamos colocando mais código em uma coisa simples.

Trecho 2

int i = numero.soma(10)
   .subtrai(5).getValor();

Trecho 3

int i = ( (NumeroComposto) numero.soma(10) )
   .subtrai(5).getValor();

O mesmo código em Scala é possível com muito mais facilidade. O Trecho 4 apresenta o mesmo programa que o Trecho 1

Trecho 4

Class NumeroSimples( int : valor){
     protected var _valor = valor;
     def soma(int valor) : self.type = {
             _valor += valor;
             this;
    }
     def valor() = _valor;
}

Class NumeroComposto extends NumeroSimples {
     def subtrai(int valor) : self.type = {
             _valor -= valor;
             this;
    }
}

NumeroComposto n = new NumeroComposto(10);
n.soma(5).subtrai(2).valor();

Essa é apenas uma das caracteristicas dessa nova linguagem. Ainda não estou defendendo isso, mas parece bem promissor. Assim que der vou colocar mais algumas coisas por aqui sobre essa nova linguagem.