Scala Cheatsheet

Scala Cheatsheet

Language

Thanks to Brendan O’Connor, this cheatsheet aims to be a quick reference of Scala syntactic constructions. Licensed by Brendan O’Connor under a CC-BY-SA 3.0 license.

variables 
var x = 5

Good
x = 6
 Variable. 
val x = 5

Bad
x = 6
 Constant. 
var x: Double = 5
 Explicit type.
functions
Good
def f(x: Int) = { x * x }

Bad
def f(x: Int) { x * x }
 Define function.
Hidden error: without = it’s a procedure returning Unit; causes havoc. Deprecated in Scala 2.13.
Good
def f(x: Any) = println(x)

Bad
def f(x) = println(x)
 Define function.
Syntax error: need types for every arg.		 
type R = Double
 Type alias. 
def f(x: R)
vs.
def f(x: => R)
 Call-by-value.

Call-by-name (lazy parameters).		 
(x: R) => x * x
 Anonymous function. 
(1 to 5).map(_ * 2)
vs.
(1 to 5).reduceLeft(_ + _)
 Anonymous function: underscore is positionally matched arg. 
(1 to 5).map(x => x * x)
 Anonymous function: to use an arg twice, have to name it. 
(1 to 5).map { x =>
 val y = x * 2
 println(y)
 y
}
 Anonymous function: block style returns last expression. 
(1 to 5) filter {
 _ % 2 == 0
} map {
 _ * 2
}
 Anonymous functions: pipeline style (or parens too). 
def compose(g: R => R, h: R => R) =
 (x: R) => g(h(x))

val f = compose(_ * 2, _ - 1)
 Anonymous functions: to pass in multiple blocks, need outer parens. 
val zscore =
 (mean: R, sd: R) =>
 (x: R) =>
 (x - mean) / sd
 Currying, obvious syntax. 
def zscore(mean: R, sd: R) =
 (x: R) =>
 (x - mean) / sd
 Currying, obvious syntax. 
def zscore(mean: R, sd: R)(x: R) =
 (x - mean) / sd
 Currying, sugar syntax. But then: 
val normer =
 zscore(7, 0.4) _
 Need trailing underscore to get the partial, only for the sugar version. 
def mapmake[T](g: T => T)(seq: List[T]) =
 seq.map(g)
 Generic type. 
5.+(3); 5 + 3

(1 to 5) map (_ * 2)
 Infix sugar. 
def sum(args: Int*) =
 args.reduceLeft(_+_)
 Varargs.
packages 
import scala.collection._
 Wildcard import. 
import scala.collection.Vector

import scala.collection.{Vector, Sequence}
 Selective import. 
import scala.collection.{Vector => Vec28}
 Renaming import. 
import java.util.{Date => _, _}
 Import all from java.util except Date.
At start of file: 
package pkg

Packaging by scope: 
package pkg {
 ...
}

Package singleton: 
package object pkg {
 ...
}
 Declare a package.
data structures 
(1, 2, 3)
 Tuple literal (Tuple3). 
var (x, y, z) = (1, 2, 3)
 Destructuring bind: tuple unpacking via pattern matching.
Bad
var x, y, z = (1, 2, 3)
 Hidden error: each assigned to the entire tuple. 
var xs = List(1, 2, 3)
 List (immutable). 
xs(2)
 Paren indexing (slides). 
1 :: List(2, 3)
 Cons. 
1 to 5
same as 
1 until 6

1 to 10 by 2
 Range sugar. 
()
 Empty parens is singleton value of the Unit type.
Equivalent to void in C and Java.
control constructs 
if (check) happy else sad
 Conditional. 
if (check) happy

same as
if (check) happy else ()
 Conditional sugar. 
while (x < 5) {
 println(x)
 x += 1
}
 While loop. 
do {
 println(x)
 x += 1
} while (x < 5)
 Do-while loop. 
import scala.util.control.Breaks._
breakable {
 for (x <- xs) {
 if (Math.random < 0.1)
 break
 }
}
 Break (slides). 
for (x <- xs if x % 2 == 0)
 yield x * 10

same as
xs.filter(_ % 2 == 0).map(_ * 10)
 For-comprehension: filter/map. 
for ((x, y) <- xs zip ys)
 yield x * y

same as
(xs zip ys) map {
 case (x, y) => x * y
}
 For-comprehension: destructuring bind. 
for (x <- xs; y <- ys)
 yield x * y

same as
xs flatMap { x =>
 ys map { y =>
 x * y
 }
}
 For-comprehension: cross product. 
for (x <- xs; y <- ys) {
 val div = x / y.toFloat
 println("%d/%d = %.1f".format(x, y, div))
}
 For-comprehension: imperative-ish.
sprintf style.		 
for (i <- 1 to 5) {
 println(i)
}
 For-comprehension: iterate including the upper bound. 
for (i <- 1 until 5) {
 println(i)
}
 For-comprehension: iterate omitting the upper bound.
pattern matching
Good
(xs zip ys) map {
 case (x, y) => x * y
}

Bad
(xs zip ys) map {
 (x, y) => x * y
}
 Use case in function args for pattern matching.
Bad
val v42 = 42
3 match {
 case v42 => println("42")
 case _ => println("Not 42")
}
 v42 is interpreted as a name matching any Int value, and "42" is printed.
Good
val v42 = 42
3 match {
 case `v42` => println("42")
 case _ => println("Not 42")
}
 `v42` with backticks is interpreted as the existing val v42, and "Not 42" is printed.
Good
val UppercaseVal = 42
3 match {
 case UppercaseVal => println("42")
 case _ => println("Not 42")
}
 UppercaseVal is treated as an existing val, rather than a new pattern variable, because it starts with an uppercase letter. Thus, the value contained within UppercaseVal is checked against 3, and "Not 42" is printed.
object orientation 
class C(x: R)
 Constructor params - x is only available in class body. 
class C(val x: R)

var c = new C(4)

c.x
 Constructor params - automatic public member defined. 
class C(var x: R) {
 assert(x > 0, "positive please")
 var y = x
 val readonly = 5
 private var secret = 1
 def this() = this(42)
}
 Constructor is class body.
Declare a public member.
Declare a gettable but not settable member.
Declare a private member.
Alternative constructor.		 
new {
 ...
}
 Anonymous class. 
abstract class D { ... }
 Define an abstract class (non-createable). 
class C extends D { ... }
 Define an inherited class. 
class D(var x: R)

class C(x: R) extends D(x)
 Inheritance and constructor params (wishlist: automatically pass-up params by default). 
object O extends D { ... }
 Define a singleton (module-like). 
trait T { ... }

class C extends T { ... }

class C extends D with T { ... }
 Traits.
Interfaces-with-implementation. No constructor params. mixin-able.		 
trait T1; trait T2

class C extends T1 with T2

class C extends D with T1 with T2
 Multiple traits. 
class C extends D { override def f = ...}
 Must declare method overrides. 
new java.io.File("f")
 Create object.
Bad
new List[Int]

Good
List(1, 2, 3)
 Type error: abstract type.
Instead, convention: callable factory shadowing the type.		 
classOf[String]
 Class literal. 
x.isInstanceOf[String]
 Type check (runtime). 
x.asInstanceOf[String]
 Type cast (runtime). 
x: String
 Ascription (compile time).
options 
Some(42)
 Construct a non empty optional value. 
None
 The singleton empty optional value. 
Option(null) == None
Option(obj.unsafeMethod)
but 
Some(null) != None
 Null-safe optional value factory. 
val optStr: Option[String] = None
same as 
val optStr = Option.empty[String]
 Explicit type for empty optional value.
Factory for empty optional value.		 
val name: Option[String] =
 request.getParameter("name")
val upper = name.map {
 _.trim
} filter {
 _.length != 0
} map {
 _.toUpperCase
}
println(upper.getOrElse(""))
 Pipeline style. 
val upper = for {
 name <- request.getParameter("name")
 trimmed <- Some(name.trim)
 if trimmed.length != 0
 upper <- Some(trimmed.toUpperCase)
} yield upper
println(upper.getOrElse(""))
 For-comprehension syntax. 
option.map(f(_))
same as 
option match {
 case Some(x) => Some(f(x))
 case None => None
}
 Apply a function on the optional value. 
option.flatMap(f(_))
same as 
option match {
 case Some(x) => f(x)
 case None => None
}
 Same as map but function must return an optional value. 
optionOfOption.flatten
same as 
optionOfOption match {
 case Some(Some(x)) => Some(x)
 case _ => None
}
 Extract nested option. 
option.foreach(f(_))
same as 
option match {
 case Some(x) => f(x)
 case None => ()
}
 Apply a procedure on optional value. 
option.fold(y)(f(_))
same as 
option match {
 case Some(x) => f(x)
 case None => y
}
 Apply function on optional value, return default if empty. 
option.collect {
 case x => ...
}
same as 
option match {
 case Some(x) if f.isDefinedAt(x) => ...
 case Some(_) => None
 case None => None
}
 Apply partial pattern match on optional value. 
option.isDefined
same as 
option match {
 case Some(_) => true
 case None => false
}
 true if not empty. 
option.isEmpty
same as 
option match {
 case Some(_) => false
 case None => true
}
 true if empty. 
option.nonEmpty
same as 
option match {
 case Some(_) => true
 case None => false
}
 true if not empty. 
option.size
same as 
option match {
 case Some(_) => 1
 case None => 0
}
 0 if empty, otherwise 1. 
option.orElse(Some(y))
same as 
option match {
 case Some(x) => Some(x)
 case None => Some(y)
}
 Evaluate and return alternate optional value if empty. 
option.getOrElse(y)
same as 
option match {
 case Some(x) => x
 case None => y
}
 Evaluate and return default value if empty. 
option.get
same as 
option match {
 case Some(x) => x
 case None => throw new Exception
}
 Return value, throw exception if empty. 
option.orNull
same as 
option match {
 case Some(x) => x
 case None => null
}
 Return value, null if empty. 
option.filter(f)
same as 
option match {
 case Some(x) if f(x) => Some(x)
 case _ => None
}
 Optional value satisfies predicate. 
option.filterNot(f(_))
same as 
option match {
 case Some(x) if !f(x) => Some(x)
 case _ => None
}
 Optional value doesn't satisfy predicate. 
option.exists(f(_))
same as 
option match {
 case Some(x) if f(x) => true
 case Some(_) => false
 case None => false
}
 Apply predicate on optional value or false if empty. 
option.forall(f(_))
same as 
option match {
 case Some(x) if f(x) => true
 case Some(_) => false
 case None => true
}
 Apply predicate on optional value or true if empty. 
option.contains(y)
same as 
option match {
 case Some(x) => x == y
 case None => false
}
 Checks if value equals optional value or false if empty.

Contributors to this page:

AltStyle によって変換されたページ (->オリジナル) /