Scala: A brief tutorial

(c) 2013 All rights reserved

Oliver Szymanski

Source-Knights.comjsxp.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

http://jsxp.org/

http://jsxp.org/

http://source-knights.com/

http://source-knights.com/

http://ijug.eu/

http://ijug.eu/

http://www.oliver-szymanski.de

http://www.oliver-szymanski.de


Overview

• Basics• Data types• Tuples• Exceptions• Modifiers• Special Types• Operators

• Code flow• Classes • Functions• Matching


Basics

• Data types• literals like

3.5 or 3.5d or 3.5D (double), 6 (integer), 3.5f or 3.5F (float)• 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 flow

• 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 Pointp.x = 3p.y = 4


Classes

// precondition, triggering an IllegalArgumentExceptionrequire(y > 0, "y must be positive")

// auxiliary constructordef this(x: Int) = { ... }

// private method private def test(a: Int): Int = { ... }

// allow access to package/subpackages/classesprotected[packagename] def test2(a: Int): Int = { ... }

// allow access to subclasses but only same instanceprotected[this] def test3(a: Int): Int = { ... }

// overridden methodoverride 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 field (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

• first 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 defined 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 defaultsval m1 = new HashMap[String,Int]// initialCapacity 20, default loadFactorval m2= new HashMap[String,Int](20)// overriding bothval m3 = new HashMap[String,Int](20,0.8)// override only the loadFactory via// named argumentsval m4 = new HashMap[String,Int](loadFactor = 0.8)


Functions

• defined 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 oncedef 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• Specifically, 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 }defined module addOne

A nice short-hand for extends Function1[Int, Int] is extends (Int => Int)


Functions

//Anonymous functions(x: Int) => x + 1val addOne = (x: Int) => x + 1

// Function as parameterfilter(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 first, 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 matchval 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

http://www.agiletourlondon.co.uk

http://www.agiletourlondon.co.uk

Scala: A brief tutorial

Technology

Transcript of Scala: A brief tutorial