Scala, un Java miglioreintroduzione al linguaggio che rende

più efficace la programmazione.

   

Scalable Language

   

Object Oriented

   

Object Oriented Pure

   

Functional

   

Java Virtual Machine

   

println(1 * 2)

val numbers = List(1, 2, 3)

numbers.foreach(n => println(n))

   

$ scala

scala> println(1 * 2)

2

scala> var numbers = List(1, 2, 3)

scala> numbers.foreach(n => println(n))

1

2

3

   

Scala conventions

   

return is “almost” optional

   

def sum(a: Int, b: Int) = return a + b

   

scala> def sum(a: Int, b: Int) = a + b

scala> println(sum(1, 2))

3

   

; is optional

   

def sum(a: Int, b:Int) = {

println(a);

println(b);

a + b;

}

   

Type inference

   

Scala is strongly typed

   

Type is inferred by scala

   

Type definition is “almost” optional

   

val a:Int = 1

   

def funz(a:Int) = 1

   

def funz(a: Int):Int = 1

   

Operator Overloading

   

Scala hasn't operators

   

Operators are object's functions

   

+ - * / are valid function names

   

Lenient invocation syntax

   

object.method(object)

object method object

   

object.+(object)

object + object

   

1.+(1)

1 + 1

   

Operator precedence?

   

1.+(1).+(2).*(2) == 8

   

1.+(1).+(2).*(2) == 6

   

Immutability rocks

   

Value vs Variable

   

A value is immutable

   

A variable is mutable

   

var a = 1

a = 2 // ok

   

val a = 1

a = 2 // error: reassignment to val

   

scala val ~= java final attribute

   

classes

   

public class Car {

private int milesDriven;

private final int age;

public Car(int age) { this.age = age; }

public void driveFor(int distance) {

milesDriven += distance;

}

public int getAge() { return age; }

public int getMiles() { return miles; }

}

   

class Car(val age:Int) {

private var milesDriven = 0

def driveFor(distance:Int) = milesDriven += distance

def miles = milesDriven

}

   

val car = new Car(2010)

car driveFor 100

println(car.age)

println(car.miles)

   

Class constructor?

   

Class costructor is class body itself!

   

class Person(name:String) {

var age = 0

println(name)

}

   

Costructors override

   

class Person(name:String) {

var age = 0

def this(name:String, anAge:Int) {

this(name)

age = anAge

}

}

   

Map

   

val map = Map(

“key1” -> “value2”,

“key2” -> “value2”

)

map(“key1”)

map(“key2”)

   

List

   

val list = List(1, 2, 3)

list.foreach(i => println(i))

   

Mutable vs Immutable Collections

   

:: is concatenate operator

   

val L = List()

val L1 = 3 :: L

val L2 = 1 :: 2 :: L1

   

When you want exactly one object

   

Many way to make singleton in java

   

Java Singleton simple way

   

class App {

private static final App instance;

public static final App getInstance() {

if(instance == null) {

instance = new App();

}

return instance;

}

}

   

Scala hasn't static

   

because Scala is object oriented

   

Scala allow you to define object

   

object App {

def doSomething() = ...

}

App.doSomething()

   

Object and class work togheter

   

class Color(name:String)

object Color {

private val colors = Map(

“red” -> new Color(“red”),

“green” -> new Color(“green”),

“blue” -> new Color(“blue”),

)

def mk(name:String) = colors(name)

}

   

val red = Color.mk(“red”)

var green = Color.mk(“green”)

   

val red = Color(“red”)

?

   

object Color {

...

def apply(name:String) = colors(name)

}

val red = Color(“red”)

   

Pattern Matching

   

switch(poor) {

case 1:

doSomething();

break;

case 2:

doSomethingElse();

break;

default:

inOtherCases();

}

   

Scala match is powerfull

   

def activity(day: String) {

day match {

case “sunday” => println(“sleep”)

case _ => println(“code”)

}

}

List(“monday”, “sunday”).foreach { activity }

   

can match int, string..

   

can match list!

   

List(1, 2) match {

case List(2, 1) => println(“!match”)

case List(1, 2) => println(“match!”)

}

   

can match case class!

   

case class?

   

are special classes

used in pattern matching

   

case class Color(name:String)

new Color(“red”)

   

case class Red extends Color(“red”)

case class Blue extends Color(“blue”)

def brush(color:Color) {

color match {

case Red() => print(“fire”)

case Blue() => print(“water”)

}

}

brush(Red())

   

extract matching values

   

case class Color(name:String)

val red = Color(“red”)

red match {

case Color(name) => println(name)

}

   

case class Color(name:String)

val red = Color(“red”)

red match {

case Color(name) => println(name)

}

   

case class Color(name:String)

val red = Color(“red”)

red match {

case Color(name) => println(name)

}

   

First class function

   

def f1(x) → x

def f2(x) → x * 2

def g(f, x) → f(x) + 1

g(f1, 3) → f1(3) + 1 → 4

g(f2, 3) → f2(3) + 1 → 7

   

def f1(x: Int) = x

def f2(x: Int) = x * 2

def g(f:Int=>Int, x:Int) = f(x) + 1

g(f1, 3) → f1(3) + 1 → 4

g(f2, 3) → f2(3) + 1 → 7

   

First class function over collections

   

def m2(i:Int) = i * 2

def p2(i:Int) = i * i

List(1, 2, 3).map(m2)

List(1, 2, 3).map(p2)

   

List(1, 2, 3).map(i => i * 2)

List(1, 2, 3).map(i => i * i)

   

List(1, 2, 3).filter(i => i % 2 == 0)

List(1, 2, 3).filter(i => i < 3)

   

Around method Pattern

   

try {

doSomething();

}

finally {

cleanup();

}

   

Too many open files!?

   

def write(path:String)(block: PrintWriter =>Unit) = {

val out = new PrintWriter(new File(path))

try {

block(out)

}

finally {

out.close

}

}

   

write(“/tmp/output”) {

out => out write “scala rocks!”

}

   

while(i < 100000) write(“/tmp/output”) {

out => out write “scala rocks!”

}

Be carefull, don't try this at home!

   

www.scala-lang.org

   

Luca Marroccoluca.marrocco@gmail.com

twitter.com/lucamarrocco

Giovanni Di Mingogiovanni@dimingo.com

twitter.com/pino_otto