Invitation to Scala

Introducing Scala
IQSS Tech-Talk, 2013-06-27
Michael Bar-Sinai
Sunday, 4 August, 13

Based in part on Scala for the impatient, Scala for
java programmers tutorial at Typesafe.com, and Prof.
Mayer Goldberg advanced programming class in
Ben-Gurion university of the Negev, Israel

In a Few Bullets
Developed in 2001, by Martin Odersky, EPFL Professor
Runs on the JVM (also, CLR)
Statically typed and with concise syntax
Object oriented and functional
Clean and elegant design
Strong collection framework
Expression-only, DSL friendly, advanced features

What is a...
Computation?

What is a computation?
PROCEDURAL
Finite automaton working on
an inﬁnite tape
...0 1 110101110

What is a computation?
PROCEDURAL FUNCTIONAL
Finite automaton working on
an inﬁnite tape
...0 1 110101110
Data ﬂowing through a
program
f(x) /2 R
f(6) 2 R

REPL
SEE ACCOMPANYING FILES

List Operations
Run some binary operator on the list items and an
intermediate results
fold, reduce, scan
Concurrent: aggregate,
reduce
ndlrowolleH

Expressions vs. Statements
STATEMENT
if ( map contains x ) {
map(x) = computeNewX(map(x))
} else {
map(x) = computeNewX( 0 )
}

STATEMENT
EXPRESSION
} else {
}
map(x) = if ( map contains x )
computeNewX( map(x) )
else
computeNewX( 0 )

STATEMENT
EXPRESSION
} else {
}
map(x) = if ( map contains x )
computeNewX( map(x) )
else
computeNewX( 0 )
ACTUAL SCALA CODE
map(x) = computeNewX( map.getOrElse(x,0) )

Class Syntax
Classes have a primary constructor that is part of
the class deﬁnition
Clients can’t distinguish between getters and
direct ﬁeld access
Better privacy control

Classes
class Person( var name:String, val id:Int ) {
! def greet = "Hello, my name is %s".format(name)
}
class Person2( name:String, val id:Int ) {
! def greet = "Hello, my name is %s".format(name)
}
class Person3( name:String, val id:Int ) {
! val greet = "Hello, my name is %s".format(name)
}

Classes (cont.)
class Person4( aName:String, anId:Int ) {
! private val id = anId
! private[this] var pName = aName
! def name = pName
! def name_=( newName:String ) { pName = newName }
! override def toString = "[Person4 id:%d name:%s]".format(id,name)
}

Multiple Inheritance
Would have been nice if it worked
It doesn’t
Java allowed only multiple
inheritance of interfaces
JDK8 would update this, slightly
Scala simulates multiple inheritance
using type linearization
Would have been nice if it worked
...it mostly does
A
B1
B2
C
A
B1
B2
C

Traits
Almost like class:
Can have ﬁelds, protocols and behavior
(implementations)
Can’t have constructor parameters
Can require minimal interface from
implementing classes
Class can extend as many as needed
Types are generated at declaration point

Objects
and the absence of static
Replace the static parts in java
Manual declaration of a runtime singletons
Classes can have “companion objects” that have
the same name
Good place for utility methods or special “apply”
methods
App trait allows script-like behavior

Pattern Matching
Control structure that allows
switching
type inquiry
variable de-composition
Specialized Classes optimized for this

Simple Pattern Matching
def toFuzzyStringInt( i:Int ) = i match {
! case 0 => "Nada"
! case 1 => "One"
! case 2 => "A Pair"
! case 12 => "a dozen"
! case _ if i<0 => "Less that zero"
! case _ => "%,d".format(i)
}

Switch by Type
def prettyPrint( a:Any ) = a match {
! case i:Int => "%,d".format(i)
! case s:String => "[%s]".format(s)
! case sym:Symbol => ":%s".format(sym)
! case _ => a.toString
}

Decomposition
First, meet the case class:
Regular class, but with immutable declared ﬁelds,
toString, equals and hashCode automatically
deﬁned
sealed abstract class Tree
case class Sum( l:Tree, r:Tree ) extends Tree
case class Var( n:String ) extends Tree
case class Con( v:Int ) extends Tree

Decomposition
def evalTree( t:Tree, e:Map[String,Int] ): Int =
t match {
! case Sum(l,r) => evalTree(l, e) + evalTree(r,e)
! case Var( n ) => e(n)
! case Con( i ) => i
}
Allows downcasting, accessing sub-classes ﬁelds and
varying actions based on the class of the parameter, in a
single syntactical maneuver

... In the real world
(merged,original) match {
case ( Pass(_), ( _, _) ) => true
case ( Unfixable(_), ( _, _) ) => false
case ( Fixable(_,t,_), (t1,t2) ) => f.ld<ld(t1)+ld(t2)
}
Given two strings, we need to decide whether it is more likely that they are
two separate words or one broken word

... In the real world
(merged,original) match {
case ( Pass(_), ( _, _) ) => true
case ( Unfixable(_), ( _, _) ) => false
case ( Fixable(_,t,_), (t1,t2) ) => f.ld<ld(t1)+ld(t2)
}
ere are two ways of constructing a software design: One way is to make it so
simple that there are obviously no deficiencies, and the other way is to make it
so complicated that there are no obvious deficiencies. e first method is far
more diﬃcult.
-- C. A. R. Hoare, Turing Award lecture, 1980
Given two strings, we need to decide whether it is more likely that they are
two separate words or one broken word

Option[T]
And the death of the NullPointerException
Indicates possibly missing values
Has two implementations: None and Some(t)
“Collection of at most one item”
Convention more than a language feature

Functions as values
Creating new functions from existing ones
Powerful tool, but can get messy
Allows for DSL creation
def bind1( f:(Int,Int)=>Int, v:Int ) =
(a:Int)=>f(a,v)

Not Covered
Creation of DSLs
Implicit conversions
Continuations
Frameworks
XML
Parsers/Combinators
Macros
Annotations
Genericity
Type System
Actors
Regular Expressions
Extractors
... many more

Pointers
www.scala-lang.org
Typesafe.com
Scala for the Impatient, by Cay Horstmann (http://
horstmann.com/scala/)
First chapters available after registering with at Typesafe’s site
(google)

Introducing Scala
IQSS Tech-Talk, 2013-06-27
Michael Bar-Sinai
THANKS

Invitation to Scala

More Related Content

Similar to Invitation to Scala (20)

More from Michael Bar-Sinai (6)

Recently uploaded (20)

Invitation to Scala