click below
click below
Normal Size Small Size show me how
Linguagem Scala
Trabalho de LP - Linguagem Scala
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)) } |