Simplifying development-full - Mirco Dotta (Typesafe)

Scala
Simplifying Development
ScalaDay Italy
Milan, May 25, 2013
Mirco Dotta
Saturday, May 25, 13

Is Scala the Java of the
future?

• It has basically everything Java has now
• It has closures (planned for Java 8)
• It has rich interfaces (Java 8 defender
methods), and more
• It is completely interoperable and runs
about as fast as Java

How is Scala different
from Java?

Concise Syntax

public class Time {
private final int hours;
private final int minutes;
public Time(int hours, int minutes) {
this.hours = hours;
this.minutes = minutes;
}
public int getHours() { return hours; }
public int getMinutes() { return minutes; }
}
class Time(val hours: Int, val minutes: Int)

Statically typed
but feels dynamic

val x = 2
type is inferred
no semicolon

Uniﬁes OOP and FP

Every value is an object

List(1,2,3).filter(x => x > 2) //> res: List[Int] = List(3)
Anonymous function Int => Boolean
List(1, 2, 3).filter(
new Function[Int, Boolean] {
def apply(x: Int): Boolean = x > 2
}
)
/
//> res: List[Int] = List(3)
Functions are “just” objects

Everything is an
expression

def max(x: Int, y: Int): Int =
if (x > y) x else y
no return statement
val x: Int = {
val y = 10
val z = 5
y + z
}
blocks evaluate to last
expression

Every operation is a
method call

val x: Int = 10
val y = x + 10
same as x.+(10)

Principles, not Rules

Users can write their own operators
Principle

class Complex(val re: Int, val im: Int = 0) {
def +(that: Complex) =
new Complex(this.re + that.re, this.im + that.im)
override def toString = s"$re + $im"
}
val c1 = new Complex(1, 2) //> c1 : Complex = 1 + 2
val c2 = new Complex(2, 2) //> c2 : Complex = 2 + 2
val c = c1 + c2 //> c : Complex = 3 + 4
default argument

• new types can look like built-in ones
• “grow the language”

Powerful collections

case class Time(hours: Int, minutes: Int = 0)
val times = List(Time(1), Time(2), Time(12,30), Time(16,15))
times.filter(time => time.hours >= 12)
//> res: List[Time] = List(Time(12,30), Time(16,15))
times.map(time => Time(time.hours + 1, time.minutes))
//> res: List[Time] = List(Time(2,0), Time(3,0), Time(13,30),
Time(17,15))
times.take(2) //> res: List[Time] = List(Time(1,0), Time(2,0))
times.groupBy(time => time.minutes) //> res: Map[Int,List[Time]] =
Map(30 -> List(Time(12,30)), 15 -> List(Time(16,15)), 0 ->
List(Time(1,0), Time(2,0)))
times.head //> res: Time = Time(1,0)
times.last //> res: Time = Time(16,15)

For-comprehension

• More general than for-loops
• Used to iterate, ﬁlter, and generate new
collections

for (p <- persons; pr <- p.projects;
if pr.overdue) yield p.name
may have any number of generators
guard construct a new collection of the same
type, element by element
p is in scope for other generators

times.filter(time => time.hours >= 12)
//> res: List[Time] = List(Time(12,30), Time(16,15))
for(time <- times;
if time.hours >= 12) yield time
//>res: List[Time] = List(Time(12,30), Time(16,15))
times.map(time => Time(time.hours + 1, time.minutes))
Time(17,15))
for(time <- times)
yield Time(time.hours + 1, time.minutes)
Time(17,15))

Desugared to calls to filter, map, and
flatMap

Readily available on any class
implementing those methods!

• Like Java interfaces, but traits
• can have behavior (like Java 8 interfaces
with defender methods)
• can have state
• enable multiple inheritance

public interface Comparable<T> {
int compareTo(int o);
}
trait Comparable[T] {
def compareTo(that: T): Int
}
def <(that: T): Boolean =
(this compare that) < 0
def >(that: T): Boolean =
(this compare that) > 0
//... Rich
Interface

Multiple Inheritance
• Traits can mix-in multiple traits
• Classes can mix-in multiple traits
• Both Class and Trait can inherit at most
from one Class

trait Bird {
def fly: String = "I'm flying!"
}
trait Swimmer {
def swim: String = "I'm swimming!"
}
class Fish extends Swimmer
class Duck extends Bird with Swimmer

Embedding DSLs

val c = new Complex(1, 2) //> c : Complex = 1 + 2
Sum Complex & Int
How could we do it?
val c1 = 1 + c //> ???
val c1 = c + 1 //> ???

val c1 = 1 + c //> ???
• This doesn’t compile because the type of c
is not conform to the type expected by the
+ method
• In Java there would simply be no way to
make this work

Implicit Conversions

• When there is a type error, the compiler
looks for an implicit that could heal the
expression
• You are already used to the idea of types
being automatically converted into others
• E.g.,Type coercion in Java!
int a = 2;
double b = a;
int is converted into a
double

Scala gives you the power of creating
your own conversions

class RichInt(n: Int) {
def +(other: Complex) =
new Complex(n) + other
}
Let’s create a class that can sum Int with Complex
val c1 = RichInt(1) + c //> c1 : Complex = 2 + 2

But, we want to write
val c1 = 1 + c
And not
val c1 = RichInt(1) + c

Implicit conversion!

implicit def int2richInt(n: Int) = new RichInt(n)
val c1 = 1 + c //> c1 : Complex = 2 + 2
And the compiler will take care of applying the
conversion
val c1 = int2richInt(1) + c

Scala simpliﬁes
development because...

Less is More

Few language
constructs with high
abstraction power

It’s Fun!

Good for your
business?

Get Started in 5’
http://www.typesafe.com/platform/getstarted

Thanks
twitter: @mircodotta

Simplifying development-full - Mirco Dotta (Typesafe)

Recommended

Recommended

More Related Content

More from Scala Italy

More from Scala Italy (7)

Recently uploaded

Recently uploaded (20)

Simplifying development-full - Mirco Dotta (Typesafe)