Scala Quick Reference

Variables & Values

val name: String = "Alice"  // immutable
var age: Int = 28           // mutable
val pi = 3.14               // type inferred
lazy val heavy = compute()  // lazy evaluation

Pattern Matching

val result = value match {
  case 0           => "zero"
  case n if n < 0  => "negative"
  case n           => s"positive: $n"
}

// Matching on types
def describe(x: Any): String = x match {
  case i: Int    => s"int: $i"
  case s: String => s"string: $s"
  case _         => "unknown"
}

Case Classes & Sealed Traits

// Case class — auto equals/hashCode/copy
case class User(name: String, age: Int)
val alice = User("Alice", 28)
val older = alice.copy(age = 29)

// Sealed trait (ADT)
sealed trait Shape
case class Circle(r: Double) extends Shape
case class Rect(w: Double, h: Double) extends Shape

def area(s: Shape): Double = s match {
  case Circle(r)   => Math.PI * r * r
  case Rect(w, h)  => w * h
}

Collections

val list = List(1, 2, 3, 4, 5)
list.map(_ * 2)         // List(2, 4, 6, 8, 10)
list.filter(_ > 2)      // List(3, 4, 5)
list.foldLeft(0)(_ + _) // 15
list.groupBy(_ % 2)     // Map(0 -> List(2,4), 1 -> List(1,3,5))

val map = Map("a" -> 1, "b" -> 2)
map.getOrElse("c", 0)   // 0

// For comprehension
val pairs = for {
  x <- List(1, 2, 3)
  y <- List("a", "b")
} yield (x, y)

Option & Either

// Option — avoids null
val maybeUser: Option[User] = findUser(id)
maybeUser.map(_.name).getOrElse("Guest")
maybeUser.foreach(u => println(u.name))

// Either — error handling
def parse(s: String): Either[String, Int] =
  s.toIntOption.toRight(s"Not a number: $s")

parse("42")    // Right(42)
parse("foo")   // Left("Not a number: foo")