Seductions of Scala

The Seductions of Scala

1

Dean [email protected]@deanwamplerpolyglotprogramming.com/talks

April 3, 2011

http://creativecommons.org/licenses/by/3.0/









Co-author,Programming

Scala

programmingscala.com

2

<shameless-plug/>

mailto:[email protected]


Why do we need a new language?

3

#1We needFunctional

Programming…

4

… for concurrency.… for concise code.… for correctness.

5

#2We need a better

Object Model…

6

… for composability.… for scalable designs.

7

Scala’s Thesis: Functional Prog.

Complements Object-Oriented

Prog.

8

Scala’s Thesis: Functional Prog.

Complements Object-Oriented

Prog.Despite surface contradictions...

8

But we want tokeep our investment

in Java/C#.

9

Scala is...

• A JVM and .NET language.

• Functional and object oriented.

• Statically typed.

• An improved Java/C#.

10

Martin Odersky

• Helped design java generics.

• Co-wrote GJ that became javac (v1.3+).

• Understands Computer Science and Industry.

11

Everything can be a Function

12

Objects as

Functions13

14

class Logger(val level:Level) {

def apply(message: String) = { // pass to Log4J... Log4J.log(level, message) }}



15



15

class body is the “primary” constructor



15

makes “level” a field




15

makes “level” a field


method

16



val error = new Logger(ERROR)

16



val error = new Logger(ERROR)

16



…error("Network error.")

17




17




“function object”apply is called

When you put an arg list

after any object,apply is called.

18

Everything is an Object

19

Int, Double, etc. are true objects.

20

Int, Double, etc. are true objects.

20

But they are compiled to primitives.

Functions as

Objects21

First, About Lists

22

val list = List(1, 2, 3, 4, 5)

First, About Lists

The same as this “list literal” syntax:

22

val list = List(1, 2, 3, 4, 5)

val list = 1 :: 2 :: 3 :: 4 :: 5 :: Nil

val list = 1 :: 2 :: 3 :: 4 :: 5 :: Nil

23

val list = 1 :: 2 :: 3 :: 4 :: 5 :: Nil

23

“cons”

val list = 1 :: 2 :: 3 :: 4 :: 5 :: Nil

empty list

23

“cons”

val list = 1 :: 2 :: 3 :: 4 :: 5 :: Nil

empty list

23

“cons”

head

val list = 1 :: 2 :: 3 :: 4 :: 5 :: Nil

empty list

23

“cons”

tailhead

val list = 1 :: 2 :: 3 :: 4 :: 5 :: Nil

24

Baked into the Grammar?

val list = Nil.::(5).::(4).::( 3).::(2).::(1)

val list = 1 :: 2 :: 3 :: 4 :: 5 :: Nil

No, just method calls!

24

Baked into the Grammar?

val list = Nil.::(5).::(4).::( 3).::(2).::(1)

val list = 1 :: 2 :: 3 :: 4 :: 5 :: Nil

25

val list = Nil.::(5).::(4).::( 3).::(2).::(1)

val list = 1 :: 2 :: 3 :: 4 :: 5 :: Nil

25

Method names can contain almost any character.

val list = Nil.::(5).::(4).::( 3).::(2).::(1)

val list = 1 :: 2 :: 3 :: 4 :: 5 :: Nil

26

Any method ending in “:” binds to the right!

val list = Nil.::(5).::(4).::( 3).::(2).::(1)

val list = 1 :: 2 :: 3 :: 4 :: 5 :: Nil

27

If a method takes one argument, you can drop the “.” and the parentheses, “(“ and “)”.

"hello" + "world"

28

Infix Operator Notation

"hello" + "world"

is actually just

28


"hello".+("world")

Similar mini-DSLs have been defined for other types.

29

Similar mini-DSLs have been defined for other types.

29

Also in many third-party libraries.

Back tofunctions as objects...

30

Classic Operations on “Container” Types

31

List, Map, ... map

fold/reduce

filter

32

val list = "a" :: "b" :: Nil

32

list map { s => s.toUpperCase }

// => "A" :: "B" :: Nil


33


33


map called on list (dropping the “.”)

33


map called on list (dropping the “.”) argument to map

(using “{“ vs. “(“)

33


map called on list (dropping the “.”) argument to map

(using “{“ vs. “(“)

“function literal”

33



functionargument list

argument to map (using “{“ vs. “(“)


33



functionargument list

function body

argument to map (using “{“ vs. “(“)


34


34


inferred type

34


list map { (s:String) => s.toUpperCase }

Explicit type

inferred type

So far, we have usedtype inference

a lot...

35

How the Sausage Is Made

class List[A] { … def map[B](f: A => B): List[B] …}

36



36

Parameterized type



36

Declaration of map

The function argument

Parameterized type

map’s return type


trait Function1[-A,+R] {

def apply(a:A): R …}

37




37

like an “abstract” class




37

No method body:=> abstract

like an “abstract” class




37

No method body:=> abstract

like an “abstract” class“contravariant”,

“covariant” typing

(s:String) => s.toUpperCase

38

new Function1[String,String] { def apply(s:String) = { s.toUpperCase }}

What the Compiler Does


38

What you write.


What the compiler generates

An anonymous class



38

What you write.


What the compiler generates

An anonymous class


No “return” needed

Recap

39


// => "A" :: "B" :: Nil


Recap

39


// => "A" :: "B" :: Nil


Function “object”

Recap

39


// => "A" :: "B" :: Nil


Function “object”

{…} ok, instead of (…)

More Functional

Hotness40

sealed abstract class Option[+T] {…}

case class Some[+T](value: T) extends Option[T] {…}

case object None extends Option[Nothing] {…}

Avoiding Nulls

41


case class Some[+T](value: T) extends Option[T] {…}


Avoiding Nulls

41An Algebraic Data Type

// Java style (schematic) class Map[K, V] { def get(key: K): V = { return value || null; }}

42


42


42Which is the better API?

// Scala styleclass Map[K, V] { def get(key: K): Option[V] = { return Some(value) || None; }}

val m = Map("one" -> 1, "two" -> 2)…val n = m.get("four") match { case Some(i) => i case None => 0 // default}

43

In Use:

val m = Map("one" -> 1, "two" -> 2)…val n = m.get("four") match { case Some(i) => i case None => 0 // default}

43

Use pattern matching to extract the value (or not)

In Use:Literal syntax for map creation


Option Details: sealed

44


Option Details: sealed

44

All children must be defined in the same file

case class Some[+T](value: T)

Case Classes

45

case class Some[+T](value: T)

Case Classes

45

●Provides factory method, pattern matching, equals, toString, etc.●Makes “value” a field without val keyword.

Object

46


Object

46

A “singleton”. Only one instance will exist.



Nothing

47


Nothing

47

Special child type of all other types. Used for this special

case where no actual instances required.

Succinct Code 48

Succinct Code 48

A few things we’ve seen so far.

"hello" + "world"


49

same as

"hello" + "world"

"hello".+("world")


49

Type Inference

50

// JavaHashMap<String,Person> persons = new HashMap<String,Person>();

Type Inference

50


vs.

// Scalaval persons = new HashMap[String,Person]

Type Inference

51


vs.


Type Inference

51


vs.


52


52


no () needed.Semicolons inferred.

User-defined Factory Methods

53

val words = List("Scala", "is", "fun!")

User-defined Factory Methods

53

val words = List("Scala", "is", "fun!")

no new needed.Can return a subtype!

class Person { private String firstName; private String lastName; private int age;

public Person(String firstName, String lastName, int age){ this.firstName = firstName; this.lastName = lastName; this.age = age; } public void String getFirstName() {return this.firstName;} public void setFirstName(String firstName) { this.firstName = firstName; }

public void String getLastName() {return this.lastName;} public void setLastName(String lastName) { this.lastName = lastName; }

public void int getAge() {return this.age;} public void setAge(int age) { this.age = age; } } 54

class Person { private String firstName; private String lastName; private int age;

public Person(String firstName, String lastName, int age){ this.firstName = firstName; this.lastName = lastName; this.age = age; } public void String getFirstName() {return this.firstName;} public void setFirstName(String firstName) { this.firstName = firstName; }

public void String getLastName() {return this.lastName;} public void setLastName(String lastName) { this.lastName = lastName; }

public void int getAge() {return this.age;} public void setAge(int age) { this.age = age; } }

Typical Java54

class Person( var firstName: String, var lastName: String, var age: Int)

55


55

Typical Scala!


56


Class body is the“primary” constructor

Parameter list for c’tor

Makes the arg a fieldwith accessors

No class body {…}. nothing else needed!

56

case class Person( firstName: String, lastName: String, age: Int)

57

Even Better...

case class Person( firstName: String, lastName: String, age: Int)

57

Constructor args are automatically vals, plus other goodies.

Even Better...

Scala’s Object Model: Traits

58

Scala’s Object Model: Traits

58

Composable Units of Behavior

We would like to compose objects

from mixins.

59

Java: What to Do?class Server extends Logger { … }

60


60

“Server is a Logger”?


60

class Server implements Logger { … }

“Server is a Logger”?

Logger isn’t an interface!

Java’s object model

61

Java’s object model

• Good

• Promotes abstractions.

• Bad

• No composition through reusable mixins.

61

Like interfaces with implementations,

62

Traits

… or like abstract classes +

multiple inheritance (if you prefer).

63

Traits

64

trait Logger { val level: Level // abstract

def log(message: String) = { Log4J.log(level, message) }}

Logger as a Mixin:

64

trait Logger { val level: Level // abstract

def log(message: String) = { Log4J.log(level, message) }}

Logger as a Mixin:

Traits don’t have constructors, but

you can still define fields.

65

trait Logger { val level: Level // abstract …}

Logger as a Mixin:

val server = new Server(…) with Logger { val level = ERROR }server.log("Internet down!!")

65


Logger as a Mixin:


65


Logger as a Mixin:

mixed in Logging


65


Logger as a Mixin:

mixed in Logging

abstract member defined

Actor Concurrency

66

When you share mutable

state...

67


state...

Hic sunt dracones(Here be dragons)

67

Actor Model

• Message passing between autonomous actors.

• No shared (mutable) state.

68

Actor Model

• First developed in the 70’s by Hewitt, Agha, Hoare, etc.

• Made “famous” by Erlang.

• Scala’s Actors patterned after Erlang’s.

69

“self” Display

draw

draw

??? error!

exit“exit”

2 Actors:

70

package shapes

case class Point( x: Double, y: Double) abstract class Shape { def draw() }

Hierarchy of geometric shapes71

package shapes

case class Point( x: Double, y: Double) abstract class Shape { def draw() }

abstract “draw” method

Hierarchy of geometric shapes71

case class Circle( center:Point, radius:Double) extends Shape { def draw() = …}

case class Rectangle( ll:Point, h:Double, w:Double) extends Shape { def draw() = …}

72

case class Circle( center:Point, radius:Double) extends Shape { def draw() = …}

case class Rectangle( ll:Point, h:Double, w:Double) extends Shape { def draw() = …}

concrete “draw” methods

72

package shapes import akka.actor._ class ShapeDrawingActor extends Actor { def receive = { … }}

73

Actor for drawing shapes


73

Use the “Akka” Actor library



73

Use the “Akka” Actor library

Actor

receive and handle each message


receive = { case s:Shape => print("-> "); s.draw() self.reply("Shape drawn.") case "exit" => println("-> exiting...") self.reply("good bye!") case x => // default println("-> Error: " + x) self.reply("Unknown: " + x)}

74

Receive method



75



75

pattern matching



75

pattern matching



75

pattern matching



76


draw shape & send reply

76


done

76


unrecognized message76


76

77

package shapes import akka.actor._class ShapeDrawingActor extends Actor { receive = { case s:Shape => print("-> "); s.draw() self.reply("Shape drawn.") case "exit" => println("-> exiting...") self.reply("good bye!") case x => // default println("-> Error: " + x) self.reply("Unknown: " + x) }}

Altogether77

package shapes import akka.actor._class ShapeDrawingActor extends Actor { receive = { case s:Shape => print("-> "); s.draw() self.reply("Shape drawn.") case "exit" => println("-> exiting...") self.reply("good bye!") case x => // default println("-> Error: " + x) self.reply("Unknown: " + x) }}

import shapes._import akka.actor._import akka.actor.Actor

object Driver { def main(args:Array[String])={ val driver = actorOf[Driver] driver.start driver ! "go!" }}class Driver …

78


object Driver { def main(args:Array[String])={ val driver = actorOf[Driver] driver.start driver ! "go!" }}class Driver … driver to try it out

78

a “singleton” type to hold main



78




78


! is the message send “operator”

…class Driver extends Actor { val drawer = actorOf[ShapeDrawingActor] drawer.start def receive = { … }}

driver to try it out79

…class Driver extends Actor { val drawer = actorOf[ShapeDrawingActor] drawer.start def receive = { … }}

driver to try it out79

Its “companion” object Driver was on the previous slide.

def receive = { case "go!" => drawer ! Circle(Point(…),…) drawer ! Rectangle(…) drawer ! 3.14159 drawer ! "exit" case "good bye!" => println("<- cleaning up…") drawer.stop; self.stop case other => println("<- " + other)}

80

driver to try it out


80


sent by main


80


sent by main

sent bydrawer

// run Driver.main (see github README.md)-> drawing: Circle(Point(0.0,0.0),1.0)-> drawing: Rectangle(Point(0.0,0.0),2.0,5.0)-> Error: 3.14159-> exiting...<- Shape drawn.<- Shape drawn.<- Unknown: 3.14159<- cleaning up...

81

“<-” and “->” messages may be interleaved!!

case "go!" => drawer ! Circle(Point(…),…) drawer ! Rectangle(…) drawer ! 3.14159 drawer ! "exit"

… // ShapeDrawingActorreceive = { case s:Shape => s.draw() self.reply("…")

case … case … }

82


case … case … }

Functional-style pattern matching

82


case … case … }

Functional-style pattern matching

“Switch” statements are not evil!

Object-oriented-style polymorphism

82

Recap

83

Scala is...

84

85

a better Java and C#,

85

86

object-orientedand

functional,86

87

succinct, elegant,

andpowerful.

87

[email protected]

@deanwampler

polyglotprogramming.com/talksprogrammingscala.com

thinkbiganalytics.com

88












Extra Slides 89

Modifying Existing Behaviorwith Traits

90

Example

trait Queue[T] { def get(): T def put(t: T) }

91

Example

trait Queue[T] { def get(): T def put(t: T) }

A pure abstraction (in this case...)91

Log put trait QueueLogging[T] extends Queue[T] { abstract override def put( t: T) = { println("put("+t+")") super.put(t) }}

92


93


What is “super” bound to??

93

class StandardQueue[T] extends Queue[T] { import ...ArrayBuffer private val ab = new ArrayBuffer[T] def put(t: T) = ab += t def get() = ab.remove(0) … }

94

class StandardQueue[T] extends Queue[T] { import ...ArrayBuffer private val ab = new ArrayBuffer[T] def put(t: T) = ab += t def get() = ab.remove(0) … }

Concrete (boring) implementation94

val sq = new StandardQueue[Int] with QueueLogging[Int] sq.put(10) // #1 println(sq.get()) // #2 // => put(10) (on #1) // => 10 (on #2)

95


Example use95


96


Mixin composition; no class required

96

Example use

Traits give us advice, but not a join point “query” language.

97

Like Aspect-Oriented Programming?

Traits are a powerful composition mechanism!

98

Functional Programming

99

What is Functional

Programming?

100

What is Functional

Programming?Don’t we already write “functions”?

100

y = sin(x)

101

y = sin(x)

101

Based on Mathematics

y = sin(x)

102

y = sin(x)

Setting x fixes y

∴ variables are immutable102

20 += 1 ??

103

20 += 1 ??We never modify the 20 “object”

103

Concurrency

104

No mutable state

∴ nothing to synchronize

Concurrency

104


state...

105


state...

Hic sunt dracones(Here be dragons)

105

y = sin(x)

106

y = sin(x)Functions don’t

change state∴ side-effect free

106

Side-effect free functions

• Easy to reason about behavior.

• Easy to invoke concurrently.

• Easy to invoke anywhere.

• Encourage immutable objects.

107

tan(Θ) = sin(Θ)/cos(Θ)

108

tan(Θ) = sin(Θ)/cos(Θ)

Compose functions of other functions

∴ first-class citizens108

Even More Functional

Hotness109

val l = List( Some("a"), None, Some("b"), None, Some("c"))

for (Some(s) <- l) yield s// List(a, b, c)

110

For “Comprehensions”

val l = List( Some("a"), None, Some("b"), None, Some("c"))

for (Some(s) <- l) yield s// List(a, b, c)

110

No “if ” statement

Pattern match; only take elements of “l”

that are Somes.

For “Comprehensions”

Technology

Seductions of Scala