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.
We do not share your email address with others. It is only used to allow you to reset your password. For details read our Privacy Policy and Terms of Service.


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

Scala

Trabalho para disciplina de Conceitos e Linguagem de Programação

ConceitoImplementação
Valores imutáveis int x = 10 PS: Uma vez atribuído o valor, ele não poderá ter seu valor alterado durante todo o tempo de vida.
Coleções var listaString = List("palavra", "outra", "mais uma") var listaInt = List(3, 4, 2, 7)
Funções de alta ordem def chamandoFuncao(callback: () => Unit){ println("\nChamando uma função...") callback() }
Casamento de padrões abstract class T case class Num(x: int) extends T case class Plus(left: T, right: T) extends T object Interpreter { def eval(term: T): int = term match { case Num(x) => x case Plus(left, right) => eval(left) + eval(right) } }
Recursividade em Cauda def fatorial(num: Int):Int = { def fatorialIter(num: Int, acc: Int):Int = { if(num == 0) acc else fatorialIter(num - 1, acc * num) } fatorialIter(num, 1) }
Funções Anônimas 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...")) } }
Curryng def mod(div: Int)(num :Int) = (num % div) == 0) def main(args: Array[String]):Unit = { for(valor <- 1 to 20) { println("Valor " + valor + " é " + (if (mod(2) (valor)) "par" else "impar" )) } }
Programação orienta a Objeto(Classe) class Complex(real: Double, imaginary: Double) { def re() = real def im() = imaginary }
Herança abstract class Person(val name:String,val age:Int){ override def toString = "Name:"+name+"age:"+age def doSomething; } class Student(name:String,age:Int)extends Person(name,age){ override def doSomething = println(this + " I'm studying!") }
Programação Funcional def qsort(l: List[Int]): List[Int] = { l match { case List() => l case _ => qsort(for(x <- l.tail if x < l.head) yield x) ::: List(l.head) ::: qsort(for(x <- l.tail if x >= l.head) yield x) } }
Membros abstratos abstract class AbsCell { type T; val init: T; private var value: T = init; def get: T = value; def set(x: T): unit = { value = x } } val cell = new AbsCell { type T = int; val init = 1 }
Métodos Genérico def swap[T](x: GenCell[T], y: GenCell[T]): unit = { val t = x.get; x.set(y.get); y.set(t) }
Classe Case abstract class Tree case class Sum(l : Tree, r:Tree) extends Tree case class Var(n : String) extends Tree case class Const(v : Int) extends Tree
For-comprehention object ComprehensionTest1 extends Application { def even(from: Int, to: Int): List[Int] = for (i <- List.range(from, to) if i % 2 == 0) yield i Console.println(even(0, 20)) }
Traits abstract class Animal {def walk:String} trait Injury extends Animal { abstract override def walk = super.walk + quot; But I'm injured :( quot; } class Dog extends Animal{ def walk = quot;I'm walking.quot; } val goodDog = new Dog goodDog.walk
Pattern Match def fac(x : Int) : Int = x match { case 0 => 1 case xpto => xpto * fac(xpto ­ 1) } match val p = new Person(18, quot;Gabrielquot;) val (age, name) = (p.age, p.name) age: Int = 18 name: String = Gabriel
Tupla val t = new Tuple3(1, "hello", Console)
Iterators val it: Iterator[Int] = Iterator.range(1, 100) while (it.hasNext) { val x = it.next println(x * x) }
Streams val fibs: Stream[BigInt] = BigInt(0) #:: BigInt(1) #:: fibs.zip( fibs.tail).map(n => { println("Adding %d and %d".format(n._1, n._2)) n._1 + n._2 }) fibs take 5 foreach println
Expressões Regulares import scala.util.matching.Regex object Test { def main(args: Array[String]) { val pattern = "Scala".r val str = "Scala is Scalable and cool" println(pattern findFirstIn str) } }
Created by: ed.araujo