Cheat sheet: The complete guide to Scala

Scala has emerged from the field as a serious contender. Designed to address the common criticisms of Java, Scala is functional, concise, and has a powerful type system. What fascinates me about Scala is the connection between functional programming on the JVM and a very expressive type system. Another bonus is the possible interoperability with Java, especially if you want to migrate from a grown Java codebase to Scala incrementally.

I’ve collected over twenty essential tips and tricks for Scala. If you just need a reference sheet for your own personal use, it’s all covered here. So let’s get started!

If you’d like to see it in its original form, check it out here. If a true cheat sheet is what you want, you won’t be disappointed.

Variables & methods

var x = "mutable"
val y = "immutable"

// Initialized once on first access
lazy val z = "lazy"

// Pattern matching on left side
val (one, two) = ("one", 2)

// Simple method
def add(n: Int, m: Int): Int = n + m

// Curried version (one argument per list)
def add(n: Int)(m: Int): Int = n + m

// By-name parameters, evaluates ‘a‘ twice
def twice[A](a: => A) = { a; a }

// Repeated Parameters (Varargs)
def many(ns: Int*): Seq[Int] = ns

// Calling a varargs method with a ‘Seq‘
> many(Seq(1, 2) :_*) 

Strings

val answer: Int = 42
// add ‘s‘ prefix for interpolation
s"The answer is: $answer"

// use ${} for more complex expressions
s"The answer is: ${21 * 2}"

// """ enclose a multiline string
"""
Inside triple quotes there
is no need to escape: \
"""

Regular Expressions

val time = """(\d{1,2}):(\d{2})""".r

> "16:03" match { case time(_*) => "matched!" }

res: String = matched!

// extract matched groups
> "16:12" match { case time(h,m) =>
  s"Hours: $h, minutes: $m"
}

res: String = Hours: 16, minutes: 12 

Classes

// Implicit default constructor
// ‘AnyRef‘ plays the role of ‘Object‘
class Foo extends AnyRef {
  val bar: Int = 42
  def foobar: Boolean = true
}

// Parameterized constructor
class Foo(msg: String) { ... }

// Additional constructor
class Foo(msg: String) {
  def this(n: Int) = this(n.toString)
}

// Can inherit from exactly one class
class Bar extends Foo("foo") 

Objects

Objects hold “static” members. When used as a companion object, it is relevant during implicit search. Objects are singletons.

object Foo {
  val hello: String = "Hello"
  def world: String = "World"
}

// Companion object:
// class and object share name and source file
class Bar
object Bar { ... } 

Traits

The sealed modifier forbids extension of the trait from a different source file than the one it is defined in. This allows exhaustiveness checks while pattern matching.

trait Foo {
  // can have abstract members
  def foo: String

  // can have implementations
  def bar: Unit = println("bar")
}

// Multiple traits can be mixed-in
trait Bar
class Foobar extends Foo with Bar {
  override def foo = "foo"
} 

Case classes

// class definition prefixed with ‘case‘
case class Person(name: String, age: Int) 

What case does:
1. constructor parameters are promoted to fields
2. generates companion object with apply and unapply
3. generates the copy method
4. generates equals, hashCode and toString

For-loop and For-comprehension

For-loops: iterate for side-effects only. For-comprehensions: chain effectful computations.

// for-loop
for (i <- 1 to 10) println(i)

// nested for-loop
for (i <- 1 to 10; j <- 1 to 10) println((i, j))

// for-comprehension
for (i <- 1 to 3; j <- 1 to i) yield i * y

// guards in for-loops and for-comprehensions
for (i <- 1 to 5 if i > 4) yield i

// curly braces for multiline expressions
for {
  i <- 1 to 5
  j <- 1 to i
  if j % 2 == 1
} yield i * j 

Pattern-matching

arg match {
  // Variable Patterns
  case x =>
  // Typed Patterns
  case x: String =>
  // Literal Patterns
  case 42 =>
  // Stable Identifier Patterns
  case ‘foo‘ =>
  // Constructor Patterns
  case Foo(x,y) =>
  // Tuple Patterns
  case (x,y,z) =>
  // Extractor Patterns
  // (See ’Custom Extractors’)
  case NumString(x) =>
  // Pattern Sequences
  case x1 +: x2 +: xs =>
  // Pattern Alternatives
  case true | 42 | "str" =>
  // Pattern Binders
  case [email protected](x,y) =>
}	

Custom extractors

// Return Boolean from unapply
object Even {
  def unapply(n: Int): Boolean =
    n % 2 == 0
}
> 41 match { case Even() => ’!’ }
scala.MatchError: 41 ...
> 42 match { case Even() => "even!" }
res: String = "even!"
// Return Option from unapply
object NumString {
  def unapply(s: String): Option[Int] =
    Try(s.toInt).toOption
}
> "42" match { case NumString(n) => n }
res: Int = 42
> "scala" match { case NumString(n) => n }
scala.MatchError: scala
// Alternatively define unapplySeq
object Words {
  def unapplySeq(s: String): Option[Seq[String]] 
    Some(s.split("\\s+").to[Seq])
}
> "foo bar baz" match { case Words(ws) => ws }
res: Seq[String] = Vector("foo", "bar", "baz")
> "test" match { case Words("foo" +: _) => 1 }
scala.MatchError: test 

Type parameters

// Two type parameters A and B
def foo[A, B](a: A, b: B) = ???

// Upper Bound, A has to be a subtype
def foo[A <: String] // Lower Bound, A has to be a supertype def foo[A :> String]

// Context Bound
def foo[A: Ordering](x: A, y: A): Boolean = {
  import Ordering.Implicits._
  x < y
}
// Context Bounds desugar to implicit params
def foo[A](x: A, y: A)(
  implicit evidence$1: Ordering[A]): Boolean 

Variance

Implicits

There are two categories of places where Scala searches for implicits: identifiers accessible without prefix at the call-site; and implicit scope, all companion objects of classes associated with the implicit’s type.

// implicit values
implicit val n: Int = 42

// implicit conversions
implicit def f(n: Int): String = n.toString

// implicit classes
implicit class Wrapper[A](val a: A) {
  def printMe: Unit = println(a)
}

// implicit parameters
def foo(implicit ec: ExecutionContext) = ??? 

Types

Option

Replaces null. There is only one obvious reason for a missing value.

val some: Option[Int] = Some(1)
val none: Option[Int] = None

// getOrElse
> some.getOrElse(42)
res: Int = 1
> none.getOrElse(42)
res: Int = 42

// fold
> some.fold("")(_.toString)
res: String = "1"
> none.fold("")(_.toString)
res: String = ""

// orElse
> some.orElse(none)
res: Option[Int] = Some(1)
> none.orElse(Some(42))
res: Option[Int] = Some(42)

Either

Domain errors that have to be handled, there are multiple reasons for an error.

val right: Either[String, Int] = Right(1)
val left: Either[String, Int] = Left("oops")

// getOrElse
> right.getOrElse(42)
res: Int = 1
> left.getOrElse(42)
res: Int = 42

// map on left and right side
> right.map(_ + 1)
res: Either[String, Int] = Right(2)
> right.left.map(_.length)
res: Either[Int, Int] = Right(1)
> left.left.map(_.length)
res: Either[Int, Int] = Left(4) 

Try

Interact with Java / Legacy Code where exceptions are thrown, a means of last resort.

> import scala.util.Try

> Try { "hello".toInt }
res: Try[Int] =
  Failure(java.lang.NumberFormatException)

> Try { "42".toInt }
res: Try[Int] = Success(42)

Collections

Prefer immutable collections, falling back to a var first and use mutable collections as a last resort only. Also, prefer Vector over List.

Warning: Seq by default allows mutable implementations, import scala.collection.immutable.Seq instead.

// Creating a collection via apply:
> List(1, 2, 3)
res: List[Int] = List(1, 2, 3)
> Array(’a’, ’b’)
res: Array[Char] = Array(a, b)
> Map((’a’, 1), (’b’, 2))
res: Map[Char, Int] = Map(a -> 1, b -> 2)

// Importing mutable collections
> import scala.collection.mutable
> mutable.Buffer(1, 2, 3)
res: Buffer[Int] = ArrayBuffer(1, 2, 3) 

Important methods

Futures

Don’t blindly import Scala’s default ExecutionContext, it is optimized for CPU-bound tasks!

> import scala.concurrent._, duration._
> import ExecutionContext.Implicits.global

// Creating an asynchronous computation
> Future { 5 * 2 }
res1: Future[Int] = Future(<not completed>)

// Modify result with a pure function
> res1.map((n: Int) => n + 11)
res2: Future[Int] = Future(<not completed>)

// Use flatMap to chain Futures
> res2.flatMap((n: Int) => Future { n * 2 })
res3: Future[Int] = Future(<not completed>)

// Register callbacks
> res3.onComplete {
  case Success(r) => println(s"Success: $r")
  case Failure(e) => println(s"Failure: $e")
}

// Block thread for result (anti-pattern)
> Await.result(res3, 1.second)
res4: Int = 42 

Duration DSL

> import scala.concurrent.duration._
> 5.seconds
res: FiniteDuration = 5 seconds
> 2.hours
res: FiniteDuration = 2 hours 

Scala Plugin for IntelliJ IDEA