Conceito | Exemplo |
A função timeFlies é definida apenas para ser passada como parâmetro para a função oncePerSecond. Funções anônimas, são exatamente o que parecem: funções sem nome. | object TimerAnonymous {
def oncePerSecond(callback: () => unit) {
while (true) { callback(); Thread sleep 1000 }
}
def main(args: Array[String]) {
oncePerSecond(() =>
println("o tempo corre como um raio..."))
}
} |
Fazer chamadas seguidas de nossa função somaEntreComF para intervalo de números diferentes, porém com o mesma função a ser aplicada entre os números. | scala> somaEntreComF(5, 15, x => x)
res13: Int = 110
scala> somaEntreComF(10, 20, x => x)
res14: Int = 165 |
Devolve uma função, que ao ser executada com os parâmetros que você precise no momento, lhe dê o resultado. | scala> def somaEntre(f: Int => Int): (Int, Int) => Int = { def retFunc(a: Int, b: Int): Int = if (a > b) 0 else f(a) + retFunc(a+1, b); retFunc }
somaEntre: (f: (Int) => Int)(Int, Int) => Int |
Declaração de Campo Simples: Um campo é uma variável que é acessível dentro de todo o objeto. Isto é contrário às variáveis locais, os quais são acessíveis apenas dentro do método em que são declarados | class MyClass {
var myField : int = 0;
} |
Uma vez que 0 é por defeito assumido como sendo um Int , o compilador Scala, pode-se inferir o tipo de myField 0 com base no que lhe é atribuído . | class MyClass {
var myField : int = 0;
def este (value: Int) = {
este ();
this.myField = valor ;
}
} |
Scala é uma linguagem funcional, não é puramente funcional, mas permite programação funcional. | def prime(x : Int) : Boolean = 2.to(x-1).filter(x % _ == 0).isEmpty
println(prime(1))
println(prime(5))
println(prime(9))
println(prime(11)) |
Expressão If: Ele testa uma condição e executa um dos dois ramos do código dependendo se a condição é verdadeira | var filename = "default.txt"
if (!args.isEmpty)
filename = args(0) |
Currying é a técnica de transformar uma função que recebe vários argumentos em uma função que recebe um único argumento (os outros argumentos tendo sido especificado pelo curry). | def complemento (x: Int, y: int) = x + y
adicionar (1, 2) / / 3
adicionar (7, 3) / / 10 |
Em Scala existe a palavra-chave return. No entanto, como todas as expressões da linguagem possuem um valor de retorno, muitas vezes o uso explícito deste termo é redundante | val dez = 10
def vinte = dez * 2 |
Currying: a idéia é avisar o compilador que podemos passar parte dos parâmetros, e que isto deve gerar uma outra função, com os parâmetros que faltam, já na declaração | def multiply2(x : Int)(y : Int) = x * y
def doIt(a : Int, f : (v : Int)=> Int) : Int = f(a)
println(doIt(3,multiply2(5))) |
Como não existe diferenciação entre valores primitivos, conseguimos criar listas
com
diferentes tipos | var a = {2, “Casa”}
var b = { 1, {5, “Texto”,
true
}, false } |
Scala é uma linguagem orientada a objetos, e dessa forma possui o conceito de classes. | object Classes {
def main(args: Array[String]) {
val pt = new Point(1, 2)
println(pt)
pt.move(10, 10)
println(pt)
}
} |
Para facilitar nossa vida, e para evitar a definição de funções que serão pequenas e para casos específicos, existe um açucar sintático em Scala chamado de funções anônimas. Como o próprio nome diz, nada mais são do que funções sem um nome definido | scala> somaEntreComF(1, 10, (x: Int) => x)
res6: Int = 55 |
Classes, em Scala, são declaradas usando uma sintaxe muito parecida com a do Java. Uma das diferenças mais marcantes é que
classes em Scala podem ter parâmetros. | class Complex(real: Double, imaginary: Double) {
def re() = real
def im() = imaginary
} |
List: Em Scala, listas são definidas em uma estrutura de dados de maneira recursiva. | var listaInt = List(3, 4, 2, 7) |
List: Existe uma outra forma de se construir listas: com o operador :: . | var lista = 1 :: 4 :: 5 :: 8 :: Nil |
Iterators em Scala são bem parecidos com os iterators de Java, e podemos também utilizá-los em for-comprehensions como listas. | val it = Iterator.from(7)
println(it.next); // Saida: 7
println(it.next); // Saida 8 |
Operações com Listas: Listas disponibilizam alguns métodos básicos para operar sobre listas. | var lista = 1 :: 4 :: 5 :: 8 :: Nil
lista.isEmpty // Saida: false
lista.head // Saida: 1
lista.tail // Saida: (4, 5, 8)
lista.tail.head // Saida: 4 |
No foreach apenas executamos a função passada, sem que seja devolvida uma lista com o resultado da operação | var lista = 1 :: 4 :: 5 :: 8 :: Nil
lista foreach ((x: Int) => print(x + ", ")) // Saida: 1, 4, 5, 8, |
Classe Abstrata: Tipos abstratos são tipos cuja identidade não é conhecida com precisão. | abstract class Buffer {
type T
val element: T
} |
Um pacote é um objeto especial que define um conjunto de classes de membros, objetos e pacotes. Ao contrário de outros objetos, os pacotes não são introduzidos por uma definição. | package p1 {
object test extends Application {
println("p1.test")
}
}
package p2 {
object test extends Application {
println("p2.test")
}
} |
Métodos em Scala podem ser parametrizados com ambos os valores e tipos. Como no nível de classe, o valor dos parâmetros estão alojados em um par de parênteses, enquanto que o tipo dos parâmetros são declaradas dentro de um par de parênteses | object PolyTest extends Application {
def dup[T](x: T, n: Int): List[T] =
if (n == 0) Nil
else x :: dup(x, n - 1)
println(dup[Int](3, 4))
println(dup("three", 3))
} |