Scala: A brief tutorial

(c) 2013
All rights reserved
Oliver Szymanski
Source-Knights.com
jsxp.org
Scala

Copyright © 2010 Source-Knights.com
Oliver
• Independent Java Enterprise Consultant
• jsxp.org and source-knights.com
• One of the founders of the Association of Java User Groups (ijug.eu)
• Speaker on conferences
• JavaOne, DOAG, JAX, SourceTalk, ...
• Author for IT-magazines
• Writer (Fantasy, Thriller, Science Fiction)
oliver-szymanski.de

Overview
• Basics
• Data types
• Tuples
• Exceptions
• Modiﬁers
• Special Types
• Operators
• Code ﬂow
• Classes
• Functions
• Matching

Basics
• Data types
• literals like
3.5 or 3.5d or 3.5D (double), 6 (integer), 3.5f or 3.5F (ﬂoat)
• Basic types:
Byte, Short, Int, Long, Float, Double, Char, String, Boolean
• String Blocks: println("""Welcome to Simply Scala.
Click 'About' for more information.""")
• Alias: type MyAlias = String => Int
• Type intererence: only local

Basics
• Tuples
• val pair = ("answer", 42) // type: (String, Int)
pair._1 // "answer"
pair._2 // 42
• val (i,c)=(1,'a') // careful with the brackets on the left side
• Tuples are in reality case classes:
• case class Tuple2[A, B](_1: A, _2: B)
• Special syntax: tuple with x1, ..., xn can be written (x1, ..., xn)
• Example:
• def divmod(x: Int, y: Int) = new Tuple2[Int, Int](x / y, x % y)

Basics
• Exceptions
• no checked exceptions in Scala
• use throws annotation such that Java code can catch exception
• @throws(classOf[IOException])

Basics
• Modifiers
• Annotations, each on their own line (lower case name), some
java ones might be upper case
• Override modifier (override)
• Access modifier (protected, private)
(also with [packagenames, classnames or this]
• Final modifier (final)

Basics
• Special types
• Nothing (sub type of all other types)
• Null (sub type of all reference types)
• Unit (empty return type)

Basics
• Operators
• Colon/Doublepoint
• The associativity of an operator is determined by its last character:
Right-associative if ending with :
Left-associative otherwise.
• x :: y :: z = x :: (y :: z) whereas x + y + z = (x + y) + z
• x :: y = y.::(x) whereas x + y = x.+(y)

Code ﬂow
• If condition: val try1 = if (1==2) 8 else 9 // equals
• while(total < 17) total += 3
• do { total+=3} while (total < 17)
• for(i <- 1 to 4) println("all four")
• for(i <- 1 until 4 ; j <- 1 to 3) println(i, j)
• for(c<-"hello") println(c) // collections
• for (i <- List.range(from, to) if i % 2 == 0) yield i
// for-comprehension for constructing a list

Example: Own loop
object Loop extends App {
def loop(body: => Unit): LoopUnlessCond = new LoopUnlessCond(body)
protected class LoopUnlessCond(body: => Unit) {
  def unless(cond: => Boolean) {
    body
    if (!cond) unless(cond)
  }
}
var i = 10
loop {
  println("i = " + i)
  i -= 1
} unless (i == 0)
}

Classes
• should be named in the CamelCase
• scala.AnyRef is base topmost class
class Point(ix:Int,iy:Int) {
var x = ix
var y = iy
}
class Point {
var x = 0
var y = 0
}
val p = new Point
p.x = 3
p.y = 4

Classes
// precondition, triggering an IllegalArgumentException
require(y > 0, "y must be positive")
// auxiliary constructor
def this(x: Int) = { ... }
// private method
private def test(a: Int): Int = { ... }
// allow access to package/subpackages/classes
protected[packagename] def test2(a: Int): Int = { ... }
// allow access to subclasses but only same instance
protected[this] def test3(a: Int): Int = { ... }
// overridden method
override def toString = { member1 + ", " + member2 }

Methods
class Point(ix:Int, iy:Int) {
var x = ix
var y = iy
def +(newpt:Point):Point = {
new Point(x+newpt.x, y+newpt.y)
}
}

Traits
trait HasXString {
val x : String // abstract ﬁeld (no value)
}
trait Ord {
def < (that: Any): Boolean // this is an abstract method
def <=(that: Any): Boolean = (this < that) || (this == that)
def > (that: Any): Boolean = !(this <= that)
def >=(that: Any): Boolean = !(this < that)
}

Traits
class Date(y: Int, m: Int, d: Int) extends Ord {
def year = y
def month = m
def day = d
//Implement the abstract trait method
def <(that: Any): Boolean = {
if (!that.isInstanceOf[Date]) error("cannot compare”)
val o = that.asInstanceOf[Date]
// latest expression is return value
(year < o.year) || (year == o.year && (month < o.month ||
(month == o.month && day < o.day)))
}

Mixin
• def foo(bar: Cloneable with Resetable): Cloneable = { /*...*/ }
• class Iter extends StringIterator(args(0)) with RichIterator
• ﬁrst parent is called thesuperclass of Iter, whereas the second
(and every other, if present) parent is called a mixin.

Case Classes
• case class Sum(l: Tree, r: Tree) extends Tree
• auto creation of a toString method, copy methods, equals
and hashCode methods, getter methods for construction
parameters
• creates Companion object with factory methods to avoid
“new” operator

Companion objects
• single instance Objects can be deﬁned like
object Bar {
def apply(foo: String) = new Bar(foo)
}
• We speak of a companion object if same name as a class
• usually used as a factory
• as a class does not have static members use companion
objects instead

Parameters
• Named parameters and default values
class HashMap[K,V](initialCapacity:Int = 16, loadFactor:Float = 0.75) {...}
// Uses the defaults
val m1 = new HashMap[String,Int]
// initialCapacity 20, default loadFactor
val m2= new HashMap[String,Int](20)
// overriding both
val m3 = new HashMap[String,Int](20,0.8)
// override only the loadFactory via
// named arguments
val m4 = new HashMap[String,Int](loadFactor = 0.8)

Functions
• deﬁned with def keyword
• usually having parameters and a return type
• return type can be guessed (not if recursion)
• Tuples are possible, use “Unit” as empty return type
def isDivisibleBy(k: Int): Int => Boolean = {
println("evaluating isDivisibleBy")
i => i % k == 0
}
val isEven = isDivisibleBy(2) // only calls isDivisibeBy once
def isEven = isDivisibleBy(2) // calls isDivisibleBy everytime
isEven(9)

Functions
• Functions are technically an object with an apply method
• val func = (x) => x + 1 // creates a function object
• def func = (x) => x + 1 // creates a function (or method in
class context)
• A Function is a set of traits
• Speciﬁcally, a function that takes one argument is an instance
of a Function1 trait.
scala> object addOne extends Function1[Int, Int] {
def apply(m: Int): Int = m + 1 }
deﬁned module addOne
A nice short-hand for extends Function1[Int, Int] is extends (Int => Int)

Functions
//Anonymous functions
(x: Int) => x + 1
val addOne = (x: Int) => x + 1
// Function as parameter
filter(lst, (x:String) => x.length() > 3)
def filter(inLst:List[Int],cond:(Int)=>Boolean):List[Int]={
if(inLst==Nil) Nil
else if(cond(inLst.head)) inLst.head::filter(inLst.tail,cond)
else filter(inLst.tail,cond)
}

More features with function
Currying:
def f(a: Int, b: Int): Int // uncurried version (uncurried type is (Int, Int) => Int)
def f(a: Int)(b: Int): Int // curried version (curried type is Int => Int => Int)
def g = f(2)
Higher Order functions: using functions as parameters and returning a
function
Composition of functions with f compose g or f andThen g is possible

Evaluation rules
• def example = a+b // evaluated when called
• val example = a+b // evaluated immediately
• lazy val example = a +b // evaluated once when needed
• def square(x: Double) // call by value
• def square(x: => Double) // call by name
• evaluates the function ﬁrst, and then evaluates the arguments if
need be
• avoids evaluation of arguments when the parameter is not used
at all by the function.

Matching
• each case is a Partial Function
def decode(n:Int){
println(n match {
case 1 => "One"
case 2 => "Two"
case 3 => "Three"
case _ => "Error" // _ is wildcard, like default
} ) }

Matching
• Pattern matching can be used with match
val res1 = Option(3)
// We want to multiply the number by 2, otherwise return 0.
val result = if (res1.isDefined) { res1.get * 2 } else { 0 }
// getOrElse lets you easily define a default value.
val result = res1.getOrElse(0) * 2
// Pattern matching fits naturally with Option.
val result = res1 match {
case Some(n) => n * 2
case None => 0
}

Outlook
• Collections
• methods: map, foreach, filter, zip, partition, find, drop,
foldLeft, flatten, flatMap...
• even concurrent collections for parallel processing
• Immutable/Mutable
• side effects, predictability, multi-threading
• Streams (like List, but tail is evaluated only on demand)
• Generics
• Implicits/Views
• classes/objects/functions/parameters...

Critics

Agile Tour London
• Friday 1st November 2013
• Combine the holiday for a long weekend in London ;)
• http://www.agiletourlondon.co.uk

Scala: A brief tutorial

More Related Content

What's hot (20)

Viewers also liked (17)

Similar to Scala: A brief tutorial (20)

Recently uploaded (20)

Scala: A brief tutorial