Scala Bruno Barros e Rebeka Gomes

Roteiro Introdução Paradigmas Especificação Concorrência Scala x Java Exercícios

Introdução Autor: Martin Odersky  Co-designer do generics de Java e implementou o javac Criada em 2001 na École Polytechnique Fédérale de Lausanne (EPFL) Primeira versão disponibilizada em 2003 A versão mais recente é de Maio de 2008

Introdução Definição:  Linguagem híbrida (funcional/orientada a objeto) e estaticamente tipada  Pode ser interpretada ou compilada em byte- code.  Existe versão para a plataforma Java e a.NET

Paradigmas Orientação a objeto  Tudo é objeto  Comportamento dos objetos são descritos em classes e Traits  Herança e overriding  Genericity

Paradigmas Funcional  Toda função é um valor  Permite usar pattern matching  Suporta funções de alta ordem e anônimas  Suporta funções aninhadas e currying

Paradigmas def sort(xs: Array[int]) { def swap(i: int, j: int) { val t = xs(i); xs(i) = xs(j); xs(j) = t } def sort1(l: int, r: int) { val pivot = xs((l + r) / 2) var i = l; var j = r while (i <= j) { while (xs(i) < pivot) { i = i + 1 } while (xs(j) > pivot) { j = j - 1 } if (i <= j) { swap(i, j) i = i + 1 j = j - 1 } if (l < j) sort1(l, j) if (j < r) sort1(i, r) } sort1(0, xs.length 1) } def sort(xs: Array[int]): Array[int] = if (xs.length <= 1) xs else { val pivot = xs(xs.length / 2) Array.concat( sort(xs filter (pivot >)), xs filter (pivot ==), sort(xs filter (pivot <))) }

Especificação Funções  Toda função é um objeto É possível:  passar funções como parâmetros  guardar funções em variáveis  retornar funções

Especificação object Timer { def oncePerSecond(callback: () => unit) { while (true) { callback(); Thread sleep 1000 } } def timeFlies() { println("time flies like an arrow...") } def main(args: Array[String]) { oncePerSecond(timeFlies) }

Especificação  Funções anônimas object TimerAnonymous { def oncePerSecond(callback: () => unit) { while (true) { callback(); Thread sleep 1000 } } def main(args: Array[String]) { oncePerSecond(() => println("time flies like an arrow...") ) }

Especificação Classes  Declaração: class Complex(real: double, imaginary: double) { def re() = real def im() = imaginary }  Criando uma instância new Complex(1.5, 2.3)

Especificação Overriding class Complex(real: double, imaginary: double) { def re = real def im = imaginary override def toString() = "" + re + (if (im < 0) "" else "+") + im + "i" }

Especificação Herança class Real (r: double) extends Complex (r,0){ override def im = 0; }

Especificação Classes abstratas abstract class IntSet { def insert(x: int): IntSet def contains(x: int): boolean }

Especificação Trait trait Printer{ def print(): String } trait Set{ def insert(a: Any): Set def contains(a: Any): boolean }

Especificação class EmptyPrintVector() extends Printer with Set { def print() = “Empty” def insert(a: Any) = this def contains(a: Any) = false }

Especificação trait Printer{ def print(): String } trait EmptySet{ def insert(a: Any) = this def contains(a: Any) = false }

Especificação class EmptyPrintVector() extends Printer with EmptySet { def print() = “Empty” }

Especificação  Mixins trait Ord { def < (that: Any): boolean def <=(that: Any): boolean = (this < that) || (this == that) def > (that: Any): boolean = !(this <= that) def >=(that: Any): boolean = !(this < that) }

Especificação class Date(y: int, m: int, d: int) extends Ord { def year = y def month = m def day = d override def equals(that: Any): boolean = that.isInstanceOf[Date] && { val o = that.asInstanceOf[Date] o.day == day && o.month == month && o.year == year } def <(that: Any): boolean = { if (!that.isInstanceOf[Date]) error("cannot compare " + that + " and a Date") val o = that.asInstanceOf[Date] (year < o.year) || (year == o.year && (month < o.month || (month == o.month && day < o.day))) }

Especificação Case Classes e pattern matching 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

Especificação type Environment = String => int //val env: Environment = { case "x" => 5 case "y" => 7 } def eval(t: Tree, env: Environment): int = t match { case Sum(l, r) => eval(l, env) + eval(r, env) case Var(n) => env(n) case Const(v) => v }

Especificação Genericity class Reference[T] { private var contents: T = _ def set(value: T) { contents = value } def get: T = contents }

Especificação object IntegerReference { def main(args: Array[String]) { val cell = new Reference[Int] cell.set(13) println("Reference contains the half of " + (cell.get * 2)) }

Concorrência Monitores def synchronized[a] (e: => a): a def wait() def wait(msec: long) def notify() def notifyAll()

Concorrência class BoundedBuffer[a] (N: int) { var in = 0, out = 0, n = 0 val elems = new Array[a](N) def put(x: a) = synchronized { while (n >= N) wait() elems(in) = x ; in = (in + 1) % N ; n = n + 1 if (n == 1) notifyAll() } def get: a = synchronized { while (n == 0) wait() val x = elems(out) ; out = (out + 1) % N ; n = n 1 if (n == N 1) notifyAll() x }

Concorrência Semaphores package scala.concurrent class Lock { var available = true def acquire = synchronized { while (!available) wait() available = false } def release = synchronized { available = true notify() }

Concorrência SyncVars Futures Parallel Computations Readers/Writers Asynchronous Channels Synchronous Channels Workers Mailboxes Actors

Scala x Java object HelloWorld { def main(args: Array[String]) { println("Hello, world!") } import scala.Predef$; import scala.ScalaObject; public final class HelloWorld$ implements ScalaObject { public static final HelloWorld$ MODULE$ = this; static { new HelloWorld$(); } public static void main(String args[]) { Predef$.MODULE$.println("Hello, world!"); } public int $tag() { return scala.ScalaObject.class.$tag(this); }

Exercícios 1 - Defina as seguintes funções square e sumSquare em Scala; 2 - Como ficaria o seguinte código Haskell em Scala? fibonnaci :: Num a => a -> a fibonnaci 0 = 1 fibonnaci 1 = 1 fibonnaci n = fibonnaci (n - 1) + fibonnaci (n - 2) 3 - Explique brevemente alguns tipos de abstrações utilizadas para obter concorrência em Scala

Referências Scala documentation