Scala: A brief tutorial
Upcoming SlideShare
Loading in...5
×
 

Scala: A brief tutorial

on

  • 369 views

Introduction to Scala showing the main concept as part of the Scala talk from SourceTalkDays

Introduction to Scala showing the main concept as part of the Scala talk from SourceTalkDays

Statistics

Views

Total Views
369
Views on SlideShare
368
Embed Views
1

Actions

Likes
0
Downloads
1
Comments
0

1 Embed 1

https://twitter.com 1

Accessibility

Categories

Upload Details

Uploaded via as Adobe PDF

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

Scala: A brief tutorial Scala: A brief tutorial Presentation Transcript

  • (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
  • Copyright © 2010 Source-Knights.com Overview • Basics • Data types • Tuples • Exceptions • Modifiers • Special Types • Operators • Code flow • Classes • Functions • Matching
  • Copyright © 2010 Source-Knights.com 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
  • Copyright © 2010 Source-Knights.com 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)
  • Copyright © 2010 Source-Knights.com Basics • Exceptions • no checked exceptions in Scala • use throws annotation such that Java code can catch exception • @throws(classOf[IOException])
  • Copyright © 2010 Source-Knights.com 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)
  • Copyright © 2010 Source-Knights.com Basics • Special types • Nothing (sub type of all other types) • Null (sub type of all reference types) • Unit (empty return type)
  • Copyright © 2010 Source-Knights.com 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)
  • Copyright © 2010 Source-Knights.com 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
  • Copyright © 2010 Source-Knights.com 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) }
  • Copyright © 2010 Source-Knights.com 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
  • Copyright © 2010 Source-Knights.com 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 }
  • Copyright © 2010 Source-Knights.com 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) } }
  • Copyright © 2010 Source-Knights.com 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) }
  • Copyright © 2010 Source-Knights.com 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))) }
  • Copyright © 2010 Source-Knights.com 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.
  • Copyright © 2010 Source-Knights.com 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
  • Copyright © 2010 Source-Knights.com 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
  • Copyright © 2010 Source-Knights.com 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)
  • Copyright © 2010 Source-Knights.com 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 once def isEven = isDivisibleBy(2) // calls isDivisibleBy everytime isEven(9)
  • Copyright © 2010 Source-Knights.com 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)
  • Copyright © 2010 Source-Knights.com 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) }
  • Copyright © 2010 Source-Knights.com 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
  • Copyright © 2010 Source-Knights.com 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.
  • Copyright © 2010 Source-Knights.com 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 } ) }
  • Copyright © 2010 Source-Knights.com 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 }
  • Copyright © 2010 Source-Knights.com 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...
  • Copyright © 2010 Source-Knights.com Critics
  • Copyright © 2010 Source-Knights.com Agile Tour London • Friday 1st November 2013 • Combine the holiday for a long weekend in London ;) • http://www.agiletourlondon.co.uk
  • Copyright © 2013 Source-Knights.com Thxalot Question? oliver.szymanski@source-knights.com (c) 2013 All rights reserved