Scala Cheatsheet

var x = 5

x = 6

val x = 5

x = 6

var x: Double = 5

def f(x: Int) = { x * x }

def f(x: Int)   { x * x }

def f(x: Any) = println(x)

def f(x) = println(x)

type R = Double

def f(x: R)

def f(x: => R)

(x: R) => x * x

(1 to 5).map(_ * 2)

(1 to 5).reduceLeft(_ + _)

(1 to 5).map(x => x * x)

(1 to 5).map(2*)

(1 to 5).map(*2)

(1 to 5).map { x =>
  val y = x * 2
  println(y)
  y
}

(1 to 5) filter {
  _ % 2 == 0
} map {
  _ * 2
}

def compose(g: R => R, h: R => R) =
  (x: R) => g(h(x))

val f = compose(_ * 2, _ - 1)

val zscore =
  (mean: R, sd: R) =>
    (x: R) =>
      (x - mean) / sd

def zscore(mean: R, sd: R) =
  (x: R) =>
    (x - mean) / sd

def zscore(mean: R, sd: R)(x: R) =
  (x - mean) / sd

val normer =
  zscore(7, 0.4) _

def mapmake[T](g: T => T)(seq: List[T]) =
  seq.map(g)

5.+(3); 5 + 3

(1 to 5) map (_ * 2)

def sum(args: Int*) =
  args.reduceLeft(_+_)

import scala.collection._

import scala.collection.Vector

import scala.collection.{Vector, Sequence}

import scala.collection.{Vector => Vec28}

import java.util.{Date => _, _}

package pkg

package pkg {
  ...
}

package object pkg {
  ...
}

(1, 2, 3)

var (x, y, z) = (1, 2, 3)

var x, y, z = (1, 2, 3)

var xs = List(1, 2, 3)

xs(2)

1 :: List(2, 3)

1 to 5

1 until 6

1 to 10 by 2

()

if (check) happy else sad

if (check) happy

if (check) happy else ()

while (x < 5) {
  println(x)
  x += 1
}

do {
  println(x)
  x += 1
} while (x < 5)

import scala.util.control.Breaks._

breakable {
  for (x <- xs) {
    if (Math.random < 0.1)
      break
  }
}

for (x <- xs if x % 2 == 0)
  yield x * 10

xs.filter(_ % 2 == 0).map(_ * 10)

for ((x, y) <- xs zip ys)
  yield x * y

(xs zip ys) map {
  case (x, y) => x * y
}

for (x <- xs; y <- ys)
  yield x * y

xs flatMap { x =>
  ys map { y =>
    x * y
  }
}

for (x <- xs; y <- ys) {
  val div = x / y.toFloat
  println("%d/%d = %.1f".format(x, y, div))
}

for (i <- 1 to 5) {
  println(i)
}

for (i <- 1 until 5) {
  println(i)
}

(xs zip ys) map {
  case (x, y) => x * y
}

(xs zip ys) map {
  (x, y) => x * y
}

val v42 = 42
3 match {
  case v42 => println("42")
  case _   => println("Not 42")
}

val v42 = 42
3 match {
  case `v42` => println("42")
  case _     => println("Not 42")
}

val UppercaseVal = 42
3 match {
  case UppercaseVal => println("42")
  case _            => println("Not 42")
}

class C(x: R)

class C(val x: R)

var c = new C(4)

c.x

class C(var x: R) {
  assert(x > 0, "positive please")
  var y = x
  val readonly = 5
  private var secret = 1
  def this = this(42)
}

new {
  ...
}

abstract class D { ... }

class C extends D { ... }

class D(var x: R)

class C(x: R) extends D(x)

object O extends D { ... }

trait T { ... }

class C extends T { ... }

class C extends D with T { ... }

trait T1; trait T2

class C extends T1 with T2

class C extends D with T1 with T2

class C extends D { override def f = ...}

new java.io.File("f")

new List[Int]

List(1, 2, 3)

classOf[String]

x.isInstanceOf[String]

x.asInstanceOf[String]

x: String

Some(42)

None

Option(null) == None
Option(obj.unsafeMethod)

Some(null) != None

val optStr: Option[String] = None

val optStr = Option.empty[String]

val name: Option[String] =
  request.getParameter("name")
val upper = name.map {
  _.trim
} filter {
  _.length != 0
} map {
  _.toUpperCase
}
println(upper.getOrElse(""))

val upper = for {
  name <- request.getParameter("name")
  trimmed <- Some(name.trim)
    if trimmed.length != 0
  upper <- Some(trimmed.toUpperCase)
} yield upper
println(upper.getOrElse(""))

option.map(f(_))

option match {
  case Some(x) => Some(f(x))
  case None    => None
}

option.flatMap(f(_))

option match {
  case Some(x) => f(x)
  case None    => None
}

optionOfOption.flatten

optionOfOption match {
  case Some(Some(x)) => Some(x)
  case _             => None
}

option.foreach(f(_))

option match {
  case Some(x) => f(x)
  case None    => ()
}

option.fold(y)(f(_))

option match {
  case Some(x) => f(x)
  case None    => y
}

option.collect {
  case x => ...
}

option match {
  case Some(x) if f.isDefinedAt(x) => ...
  case Some(_)                     => None
  case None                        => None
}

option.isDefined

option match {
  case Some(_) => true
  case None    => false
}

option.isEmpty

option match {
  case Some(_) => false
  case None    => true
}

option.nonEmpty

option match {
  case Some(_) => true
  case None    => false
}

option.size

option match {
  case Some(_) => 1
  case None    => 0
}

option.orElse(Some(y))

option match {
  case Some(x) => Some(x)
  case None    => Some(y)
}

option.getOrElse(y)

option match {
  case Some(x) => x
  case None    => y
}

option.get

option match {
  case Some(x) => x
  case None    => throw new Exception
}

option.orNull

option match {
  case Some(x) => x
  case None    => null
}

option.filter(f)

option match {
  case Some(x) if f(x) => Some(x)
  case _               => None
}

option.filterNot(f(_))

option match {
  case Some(x) if !f(x) => Some(x)
  case _                => None
}

option.exists(f(_))

option match {
  case Some(x) if f(x) => true
  case Some(_)         => false
  case None            => false
}

option.forall(f(_))

option match {
  case Some(x) if f(x) => true
  case Some(_)         => false
  case None            => true
}

option.contains(y)

option match {
  case Some(x) => x == y
  case None    => false
}