Busy. Please wait.
or

show password
Forgot Password?

Don't have an account?  Sign up 
or

Username is available taken
show password

why

Make sure to remember your password. If you forget it there is no way for StudyStack to send you a reset link. You would need to create a new account.

By signing up, I agree to StudyStack's Terms of Service and Privacy Policy.


Already a StudyStack user? Log In

Reset Password
Enter the associated with your account, and we'll email you a link to reset your password.

Remove ads
Don't know
Know
remaining cards
Save
0:01
To flip the current card, click it or press the Spacebar key.  To move the current card to one of the three colored boxes, click on the box.  You may also press the UP ARROW key to move the card to the "Know" box, the DOWN ARROW key to move the card to the "Don't know" box, or the RIGHT ARROW key to move the card to the Remaining box.  You may also click on the card displayed in any of the three boxes to bring that card back to the center.

Pass complete!

"Know" box contains:
Time elapsed:
Retries:
restart all cards




share
Embed Code - If you would like this activity on your web page, copy the script below and paste it into your web page.

  Normal Size     Small Size show me how

Linguagem Scala

Trabalho de LP - Linguagem Scala

ConceitoExemplo
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)) }
Created by: grupoKarem