Invitation to Scala

Introducing ScalaIQSS Tech-Talk, 2013-06-27Michael 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 BulletsDeveloped 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 infinite tape

...0 1 110101110


What is a computation?PROCEDURAL FUNCTIONAL

Finite automaton working on an infinite tape

...0 1 110101110

Data flowing through a program

f(x) /2 Rf(6) 2 R


REPLSEE ACCOMPANYING FILES


List OperationsRun some binary operator on the list items and an intermediate results

fold, reduce, scan

Concurrent: aggregate,reduce

\ndlrow olleH


Expressions vs. StatementsSTATEMENT

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



EXPRESSION


map(x) = if ( map contains x ) computeNewX( map(x) ) else computeNewX( 0 )



EXPRESSION


map(x) = if ( map contains x ) computeNewX( map(x) ) else computeNewX( 0 )

ACTUAL SCALA CODEmap(x) = computeNewX( map.getOrElse(x,0) )


Class Syntax

Classes have a primary constructor that is part of the class definition

Clients can’t distinguish between getters and direct field access

Better privacy control


Classesclass 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 InheritanceWould have been nice if it worked

It doesn’t

Java allowed only multipleinheritance of interfacesJDK8 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


TraitsAlmost like class:

Can have fields, 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


Objectsand 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}


DecompositionFirst, meet the case class:

Regular class, but with immutable declared fields, toString, equals and hashCode automatically defined

sealed abstract class Treecase class Sum( l:Tree, r:Tree ) extends Treecase class Var( n:String ) extends Treecase 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 fields and varying actions based on the class of the parameter, in a

single syntactical maneuver


... In the real world

(merged,original) match {case ( Pass(_), ( _, _) ) => truecase ( Unfixable(_), ( _, _) ) => falsecase ( 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(_), ( _, _) ) => truecase ( Unfixable(_), ( _, _) ) => falsecase ( 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 de"ciencies, and the other way is to make it so complicated that there are no obvious de"ciencies. e "rst method is far more difficult.

-- 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 valuesCreating 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 CoveredCreation 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 ScalaIQSS Tech-Talk, 2013-06-27Michael Bar-Sinai

THANKS


Invitation to Scala

Technology

Transcript of Invitation to Scala