The Seductions of Scala Dean Wampler dean@deanwampler.com - - PowerPoint PPT Presentation

The Seductions

• f Scala

Dean Wampler dean@deanwampler.com @deanwampler polyglotprogramming.com/talks programmingscala.com

Co-author, Programming Scala

programmingscala.com

2

<shameless-plug/>

Available now from oreilly.com, Amazon, etc.

Why do we need a new language?

3

I picked Scala in late 2007 to learn because I wanted to learn a functional language. Scala appealed because it runs on the JVM and interoperates with Java...

#1 We need Functional Programming …

4

First reason, we need the benefits of FP.

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

5

#2 We need a better Object Model …

6

… for composability. … for scalable designs.

7

Scala’s Thesis: Functional Programming Complements Object-Oriented Programming

Despite surface contradictions...

8

We think of objects as mutable and methods as state-modifying, which is often appropriate. But using functional idioms reduces bugs and

• ften simplifies code. You can make your objects immutable, too!

But we want to keep 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

Odersky is the creator of Scala. He’s a prof. at EPFL in Switzerland. Many others have contributed to it, mostly his grad. students. GJ had generics, but they were disabled in javac until v1.5.

Everything can be a Function

12

Objects as Functions

13

14

class Logger(val level:Level) { def apply(message: String) = { // pass to logger system log(level, message) } }

class Logger(val level:Level) { def apply(message: String) = { // pass to logger system log(level, message) } }

15

makes “level” an immutable field class body is the “primary” constructor method

class Logger(val level:Level) { def apply(message: String) = { // pass to logger system log(level, message) } }

16

name : Type

val error = new Logger(ERROR)

17

class Logger(val level:Level) { def apply(message: String) = { // pass to logger system log(level, message) } } … error(“Network error.”) error’s type inferred

val error = new Logger(ERROR)

18

class Logger(val level:Level) { def apply(message: String) = { // pass to logger system log(level, message) } } … error(“Network error.”) “function object” apply is called

Put an arg list after any object, apply is called.

19

Everything is an Object

20

Int, Double, etc. are true objects.

21

But they are compiled to primitives.

Functions as Objects

22

First, About Lists

The same as this “list literal” syntax:

23

val list = List(1, 2, 3, 4, 5) val list = 1 :: 2 :: 3 :: 4 :: 5 :: Nil no new

val list = Nil.::(5).::(4).::( 3).::(2).::(1) val list = 1 :: 2 :: 3 :: 4 :: 5 :: Nil empty list Any method ending in “:” binds to the right!

24

“cons”

“hello” + “world” is actually just

25

“Operator” Notation

“hello”.+(“world”)

“hello” compareTo “world” is actually just

26

Similarly

“hello”.compareTo(“world”)

val map = Map( “name” -> “Dean”, “age” -> 39)

Oh, and Maps

val map = Map( “name” -> “Dean”, “age” -> 39)

Oh, and Maps

No, just method calls...

28

“baked” into the language grammar?

val map = Map( “name” -> “Dean”, “age” -> 39)

Oh, and Maps

29

An “implicit conversion” converts a string to a type that has the -> method.

Classic Operations on Functional Data Types

30

List, Map, ...

map fold/ reduce filter

Collections like List and have a set of common operations that can be used on them.

Back to functions as

• bjects...

31

32

list map { s => s.toUpperCase } // => "A" :: "B" :: Nil val list = “a” :: “b” :: Nil

33

list map { s => s.toUpperCase } map called on list function argument list function body map argument list “function literal” No () and ; needed!

34

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

So far, we’ve used type inference a lot...

35

How the Sausage Is Made

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

36

Declaration of map The function argument Parameterized type (like <A> in Java)

How the Sausage Is Made

trait Function1[A,R] extends AnyRef { def apply(a:A): R … }

37

No method body: => abstract like an “abstract” class Java’s “Object”

(s:String) => s.toUpperCase

38

becomes: new Function1[String,String] { def apply(s:String) = { s.toUpperCase } } Compiler generates an anonymous class

What the Compiler Does

No “return” needed

39

list map {s => s.toUpperCase} val f = new Function1[…,…] { def apply(s:String) = { s.toUpperCase } } list map {s => f(s)} using a function value Alternative

Since functions are objects, they could have state...

40

41

class Counter[A](val inc:Int =1) extends Function1[A,A] { var count = 0 def apply(a:A) = { count += inc a // return input } } val f = new Counter[String](2) val l1 = “a” :: “b” :: Nil val l2 = l1 map {s => f(s)} println(f.count) // 4 println(l2) // List(“a”,”b”)

Succint Code

42

A few things we’ve seen so far.

same as

"hello" + "world" "hello".+("world")

Infix Operator Notation

Great for DSLs!

43

Type Inference

44

// Java HashMap<String,Person> persons = new HashMap<String,Person>(); vs. // Scala val persons = new HashMap[String,Person]

45

// Scala val persons = new HashMap[String,Person] no () needed. Semicolons inferred.

User-defined Factory Methods

46

val persons = Map ( “dean” -> deanPerson, “alex” -> alexPerson) no new needed. Returns an appropriate 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; } }

Typical Java

47

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

48

Typical Scala!

class Person( var firstName: String, var lastName: String, var age: Int) Class body is the “primary” constructor Parameter list for c’tor Makes the arg a field with accessors No class body {…}. nothing else needed!

49

Actually, not exactly the same:

50

val person = new Person(“dean”,…) val fn = person.firstName person.firstName = “Bubba” // Not: // val fn = person.getFirstName // person.setFirstName(“Bubba”) Doesn’t follow the JavaBean convention.

However, these are function calls:

51

class Person(fn: String, …) { // init val private var _firstName = fn def firstName = _firstName def firstName_=(fn: String) = _firstName = fn } Uniform Access Principle

Scala’s Object Model: Traits

52

Composable Units of Behavior

Java

class Queue extends Collection implements Logging, Filtering { … }

53

Java’s object model

• Good
• Promotes abstractions.
• Bad
• No composition through

reusable mixins.

54

Like interfaces with implementations,

55

Traits

… or like abstract classes + multiple inheritance (if you prefer).

56

Traits

Example

trait Queue[T] { def get(): T def put(t: T) } A pure abstraction (in this case...)

57

Log put and get

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

58

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

Log put and get

What is “super” bound to??

59

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) implementation

60

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

61

Mixin composition; no class required

62

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

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

63

Like Aspect-Oriented Programming?

Stackable Traits

64

Filter put

trait QueueFiltering[T] extends Queue[T] { abstract override def put( t: T) = { if (veto(t)) println(t+" rejected!") else super.put(t) } def veto(t: T): Boolean }

65

Filter put

trait QueueFiltering[T] extends Queue[T] { abstract override def put( t: T) = { if (veto(t)) println(t+" rejected!") else super.put(t) } def veto(t: T): Boolean }

66

“Veto” puts

val sq = new StandardQueue[Int] with QueueLogging[Int] with QueueFiltering[Int] { def veto(t: Int) = t < 0 } Defines “veto”

67

Anonymous Class

for (i <- -2 to 2) { sq.put(i) } println(sq) // => -2 rejected! // => -1 rejected! // => put(0) // => put(1) // => put(2) // => 0, 1, 2 loop from -2 to 2

68

Filtering occurred before logging Example use

What if we reverse the order

• f the Traits?

69

val sq = new StandardQueue[Int] with QueueFiltering[Int] with QueueLogging[Int] { def veto(t: Int) = t < 0 } Order switched

70

for (i <- -2 to 2) { sq.put(i) } println(sq) // => put(-2) // => -2 rejected! // => put(-1) // => -1 rejected! // => put(0) // => put(1) // => put(2) // => 0, 1, 2 logging comes before filtering!

71

Loosely speaking, the precedence goes right to left.

72“Linearization” algorithm

Method Lookup Order

• Defined in object’s type?
• Defined in mixed-in traits,

right to left?

• Defined in superclass?

73 Simpler cases, only...

Traits are also powerful for mixin composition.

74

val dean = new Person(…) extends Logger dean.log(ERROR, “Bozo alert!!”)

75

trait Logger { def log(level: Level, message: String) = { Log.log(level, message) } }

Logger, revisited:

mixed in Logging

DSLs

76

Yet more features for DSL creation...

Building Our Own Controls

77

Exploiting First-Class Functions

also the same as 1 + 2 // => 3 1.+(2) // => 3

Recall infix operator notation:

Why is this useful?? 1 + {2}

78

// Print with line numbers. loop (new File("…")) { (n, line) => printf("%3d: %s\n", n, line) }

Make your own controls

79

// Print with line numbers. loop (new File("…")) { (n, line) => printf("%3d: %s\n", n, line) }

Make your own controls

control? How do we do this? File to loop through what do for each line Arguments passed to...

80

1: // Print with line … 2: 3: 4: loop(new File("…")) { 5: (n, line) => 6: 7: printf("%3d: %s\n", … 8: }

Output on itself:

81

import java.io._

• bject Loop {

def loop(file: File, f: (Int,String) => Unit) = {…} }

82

import java.io._

• bject Loop {

def loop(file: File, f: (Int,String) => Unit) = {…} } _ like * in Java “singleton” class == 1 object loop “control” function taking line # and line two parameters like “void”

83

• bject Loop {

def loop(file: File, f: (Int,String) => Unit) = {…} } two parameters

84

loop (new File("…")) { (n, line) => … }

• bject Loop {

def loop(file: File) ( f: (Int,String) => Unit) = {…} } two parameters lists

85

loop (new File("…")) { (n, line) => … }

// Print with line numbers. import Loop.loop loop (new File("…")) { (n, line) => printf("%3d: %s\n", n, line) }

Why 2 Param. Lists?

2nd parameter: a “function literal” import new method 1st param.: a file

86

• bject Loop {

def loop(file: File) ( f: (Int,String) => Unit) = { val reader = new BufferedReader( new FileReader(file)) def doLoop(n:Int) = {…} doLoop(1) } } Finishing Loop.loop...

87

nested method

• bject Loop {

… def doLoop(n: Int):Unit ={ val l = reader.readLine() if (l != null) { f(n, l) doLoop(n+1) } } }

88

Finishing Loop.loop... “f” and “reader” visible from outer scope recursive

doLoop is Recursive. There is no mutable loop counter!

Classic Functional Programming technique

89

def doLoop(n: Int):Unit ={ … doLoop(n+1) }

90

Scala optimizes tail recursion into loops

It is Tail Recursive

// Print with line numbers. import Loop.loop loop (new File("…")) { (n, line) => printf("%3d: %s\n", n, line) }

Recap: Make a DSL

91

More Functional Hotness

92

abstract class Option[T] {…} case class Some[T](t: T) extends Option[T] {…} case object None extends Option[Nothing] {…}

Avoiding Nulls

93

Child of all other types

case class Some[T](t: T)

Case Classes

94

Provides factory, pattern matching, equals, toString, and other goodies.

class Map1[K, V] { def get(key: K): V = { return v; // if found return null; // if not found } } class Map2[K, V] { def get(key: K): Option[V] = { return Some(v); // if found return None; // if not found } }

95

Which is the better API?

val l = List( Some(“a”), None, Some(“b”), None, Some(“c”)) for (Some(s) <- l) yield s // List(a, b, c)

96

No “if” statement Pattern match; only take elements of “l” that are Somes.

For “Comprehensions”

Actor Concurrency

97

When you share mutable state...

Hic sunt dracones (Here be dragons)

98

Hard!

Actor Model

• Message passing between

autonomous actors.

• No shared (mutable) state.

99

Actor Model

• First developed in the 70’s by

Hewitt, Agha, Hoare, etc.

• Made “famous” by Erlang.
• Scala’s Actors patterned

after Erlang’s.

100

The actor model is not new!!

“self” Display

draw draw ??? error! exit “exit”

2 Actors:

101

package shapes case class Point( x: Double, y: Double) abstract class Shape { def draw() } Hierarchy of geometric shapes

• methods. Great for “structural” objects.

package shapes case class Point( x: Double, y: Double) abstract class Shape { def draw() } abstract “draw” method Hierarchy of geometric shapes

103

• methods. Great for “structural” objects.

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 Hierarchy of geometric shapes

104

package shapes import scala.actors._, Actor._

• bject ShapeDrawingActor

extends Actor { def act() { loop { receive { … } } } } Actor for drawing shapes

105

package shapes import scala.actors._, Actor._

• bject ShapeDrawingActor

extends Actor { def act() { loop { receive { … } } } } Actor library “singleton” Actor loop indefinitely receive and handle each message

106

Actor for drawing shapes

receive { case s:Shape => s.draw() sender ! "drawn" case "exit" => println("exiting...") sender ! "bye!" // exit case x => println("Error: " + x) sender ! ("Unknown: " + x) }

107

Receive method

receive { case s:Shape => s.draw() sender ! "drawn" case "exit" => println("exiting...") sender ! "bye!" // exit case x => println("Error: " + x) sender ! ("Unknown: " + x) }

108

pattern matching

receive { case s:Shape => s.draw() sender ! "drawn" case "exit" => println("exiting...") sender ! "bye!" // exit case x => println("Error: " + x) sender ! ("Unknown: " + x) } done unrecognized message draw shape & send reply

109

package shapes import …

• bject ShapeDrawingActor extends Actor {

def act() { loop { receive { case s: Shape => s.draw() sender ! "drawn" case "exit" => println("exiting...") sender ! "bye!" //; exit case x => println("Error: " + x) sender ! ("Unknown: " + x) } } } }

Altogether

110

import shapes._ import scala.actors.Actor._ def sendAndReceive(msg: Any) ={ ShapeDrawingActor ! msg self.receive { case reply => println(reply) } } script to try it out

111

import shapes._ import scala.actors.Actor._ def sendAndReceive(msg: Any) ={ ShapeDrawingActor ! msg self.receive { case reply => println(reply) } } wait for a reply send message...

112

script to try it out helper method parent of AnyRef, AnyVal

… ShapeDrawingActor.start() sendAndReceive( Circle(Point(0.0,0.0), 1.0)) sendAndReceive( Rectangle(Point(0.0,0.0), 2, 5)) sendAndReceive(3.14159) sendAndReceive("exit") // => Circle(Point(0.0,0.0),1.0) // => drawn. // => Rectangle(Point(0.0,0.0),2.0,5.0) // => drawn. // => Error: 3.14159 // => Unknown message: 3.14159 // => exiting... // => bye!

113

… ShapeDrawingActor.start() sendAndReceive( Circle(Point(0.0,0.0), 1.0)) sendAndReceive( Rectangle(Point(0.0,0.0), 2, 5)) sendAndReceive(3.14159) sendAndReceive("exit") // => Circle(Point(0.0,0.0),1.0) // => drawn. // => Rectangle(Point(0.0,0.0),2.0,5.0) // => drawn. // => Error: 3.14159 // => Unknown message: 3.14159 // => exiting... // => bye!

114

… receive { case s:Shape => s.draw() sender ! "drawn" case … case … } Functional style pattern matching A powerful combination! Object-

• riented

polymorphism

115

Recap

116

Scala is...

117

a better Java and C#,

118

• bject-oriented

and functional,

119

succinct, elegant, and powerful.

120

Thanks!

dean@deanwampler.com @deanwampler polyglotprogramming.com/talks programmingscala.com

121

Extra Slides

122

Functional Programming

123

What is Functional Programming?

Don’t we already write “functions”?

124

y = sin(x)

125

Based on Mathematics

“Functional Programming” is based on the behavior of mathematical functions and variables.

y = sin(x)

Setting x fixes y ∴ variables are immutable

126

“Functional Programming” is based on the behavior of mathematical functions. “Variables” are actually immutable values.

20 += 1 ??

We never modify the 20 “object”

127

No mutable state ∴ nothing to synchronize

Concurrency

128

FP is breaking out of the academic world, because it ofgers a better way to approach concurrency, which is becoming ubiquitous.

When you share mutable state...

Hic sunt dracones (Here be dragons)

129

y = sin(x)

Functions don’t change state ∴ side-effect free

130

A math function doesn’t change any “object” or global state. All the work it does is returned by the function. This property is called “referential transparency”.

Side-effect free functions

• Easy to reason about behavior.
• Easy to invoke concurrently.
• Easy to invoke anywhere.
• Encourage immutable objects.

131

tan(Θ) = sin(Θ)/cos(Θ) Compose functions of

• ther functions

∴ first-class citizens

132

More on DSLs

133

Yet more features for DSL creation...

“Pimp My Library”

134

Typesafe “monkey patching”

// Print with line numbers. import Loop.loop loop (new File("…")) { (n, line) => printf("%3d: %s\n", n, line) }

Recall our “Loop”

135

Suppose we want a loop method on File instead?

136

val file = new File("…") file.loop { (n, line) => printf("%3d: %s\n", n, line) }

137

Now a method

• n File?

class File; …; end file = File.new … def file.loop n = 0 while line = self.gets yield n, line n += 1 end end

Ruby

138

Open Types Add a method to the object!

Implicits

139

class WithLoop (file: File) { def loop ( f: (Int,String) => Unit) = {…} }

• bject WithLoop {

implicit def file2WithLoop( file: File) = new WithLoop (file) }

• n the original type. The compiler finds the best-matching implicit conversion method in scope and applies it for you.

// Print with line numbers. import WithLoop._ (new File("…")).loop { (n, line) => printf("%3d: %s\n", n, line) }

Using the Implicit

140

import required!

Implicits can be used to mimic Haskell-like type classes.

141

http://debasishg.blogspot.com/2010/06/ scala-implicits-type-classes-here-i.html