simplifying development-full - mirco dotta (typesafe)

ScalaSimplifying Development

ScalaDay ItalyMilan, 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 SyntaxSaturday, May 25, 13

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 typedbut feels dynamic


val x = 2type is inferred

no semicolon


Unifies OOP and FPSaturday, May 25, 13

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 = 10val 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 + 2val c2 = new Complex(2, 2) //> c2 : Complex = 2 + 2val c = c1 + c2 //> c : Complex = 3 + 4

default argument


• new types can look like built-in ones

• “grow the language”


Powerful collectionsSaturday, May 25, 13

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, filter, 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)) //> res: List[Time] = List(Time(2,0), Time(3,0), Time(13,30), Time(17,15))

for(time <- times) yield Time(time.hours + 1, time.minutes) //> res: List[Time] = List(Time(2,0), Time(3,0), Time(13,30), Time(17,15))


Desugared to calls to filter, map, and flatMap


Readily available on any class implementing those methods!


TraitsSaturday, May 25, 13

• 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

InterfaceSaturday, May 25, 13

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 DSLsSaturday, May 25, 13

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 ConversionsSaturday, May 25, 13

• 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 c = new Complex(1, 2) //> c : Complex = 1 + 2val 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!Saturday, May 25, 13

implicit def int2richInt(n: Int) = new RichInt(n)

val c = new Complex(1, 2) //> c : Complex = 1 + 2val c1 = 1 + c //> c1 : Complex = 2 + 2

And the compiler will take care of applying the conversion

val c1 = int2richInt(1) + c


Scala simplifies 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




Thankstwitter: @mircodotta


simplifying development-full - mirco dotta (typesafe)

Technology

def

csaturday

hours 1

gt

time gt

time time

gt

class