Scala Quick Reference

Declare immutable bindings with val and mutable ones with var — val x: Int = 5 fixes x forever, while var y = 5; y += 1 allows reassignment; Scala's type inference means you can usually drop the type annotation, val x = 5 infers Int, except on public method signatures, where explicit return types are considered good practice for readability and faster compilation. Functions are declared with def name(params): ReturnType = body, and because the last expression in a block is automatically its return value, there's no return keyword needed in idiomatic code — def square(n: Int): Int = n * n is a complete, valid method, and default parameter values, def greet(name: String = "World"): String = s"Hello, $name!", let callers omit arguments that have sensible defaults.

List is Scala's default immutable singly-linked sequence, List(1, 2, 3), Vector gives effectively constant-time random access and updates for larger collections, Set stores unique elements, Set(1, 2, 2, 3) becomes Set(1, 2, 3), and Map[K, V] stores key-value pairs, Map("a" -> 1, "b" -> 2); all four have both immutable, default, scala.collection.immutable, and mutable, scala.collection.mutable, variants. The core transformation methods to memorize are map, transform each element, filter, keep elements matching a predicate, flatMap, transform and flatten, fold/foldLeft/foldRight, reduce to a single value with a starting accumulator, sortBy/sorted, order elements, and groupBy, partition into a Map[K, List[A]] by a key function — nearly every everyday data-wrangling task in Scala is some composition of these six operations.

match is Scala's structural switch and the single most-used control construct beyond simple if: value match { case pattern => result } can match literals, types, case s: String => ..., case class shapes with destructuring, case Point(x, y) => ..., and can add a boolean guard, case n if n > 0 => "positive"; an underscore case _ => ... catches anything unmatched, and omitting it causes a MatchError at runtime if no case fits. for-comprehensions provide a uniform syntax for iterating, for (x <- list) println(x), filtering, for (x <- list if x > 0) yield x, and composing multiple monadic values, for { a <- optionA; b <- optionB } yield a + b, which short-circuits to None if either is empty — remembering that any for with a yield desugars to map/flatMap/withFilter calls demystifies most 'why doesn't this compile' questions.