Expressions & Control

In Java or C, if is a statement: it does something but has no value, so you declare a variable first and assign it inside each branch. In Scala, if is an expression: it evaluates to the value of whichever branch ran, and you can put that value straight into a val. The same is true of blocks, match, try and for ... yield. This one idea is why Scala code needs so few vars.

@main def run(): Unit =
  val temp = 31
  val feel = if temp > 30 then "hot" else "fine"
  println(feel)

  val bmi =
    val weightKg = 70.0
    val heightM = 1.75
    weightKg / (heightM * heightM)
  println(f"$bmi%.1f")

  println(if temp % 2 == 0 then "even" else "odd")

hot
22.9
odd

@main def run(): Unit =
  val stock = 0
  val label: String = if stock > 0 then "in stock"
  println(label)

-- [E007] Type Mismatch Error: Main.scala:3:22
3 |  val label: String = if stock > 0 then "in stock"
  |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  |                   Found:    Unit
  |                   Required: String
  |
  |                   Maybe you are missing an else part for the conditional?
1 error found
Compilation failed

@main def run(): Unit =
  val stock = 0
  val label: String = if stock > 0 then "in stock" else "sold out"
  println(label)

Scala 3 writes a condition as if cond then a else b. The older form with parentheses, if (cond) a else b, still compiles and is what you will see in Scala 2 and Spark code — both mean exactly the same thing. Chain more cases with else if. Conditions must be a real Boolean: Scala has no "truthy" values, so if count then or if name then will not compile.

@main def run(): Unit =
  val score = 78
  val grade =
    if score >= 90 then "A"
    else if score >= 75 then "B"
    else if score >= 60 then "C"
    else "F"
  println(s"$score -> $grade")

  val old = if (score > 50) "pass" else "fail"
  println(old)

  if score > 70 then
    println("well done")
    println("certificate unlocked")

78 -> B
pass
well done
certificate unlocked

If the branches return different types, the compiler picks the closest common type. if ok then 1 else 2.5 is a Double (the Int widens). if ok then 1 else "one" compiles too, but the result is a type so general you can do almost nothing with it — a hint that the two branches should really return the same type.

Unit is the type of an expression that is evaluated only for what it does — print, write a file, change a var — not for a result. It has exactly one value, written (). println returns Unit, an assignment returns Unit, and a for loop with do returns Unit. It plays the role of Java's void, with one difference: Unit is a real value, so it can be stored and printed.

@main def run(): Unit =
  var n = 0
  val a = println("side effect")
  val b = { n = 5 }
  val c = for i <- 1 to 3 do n += i
  println(a)
  println(b)
  println(c)
  println(n)
  println(a == ())

side effect
()
()
()
11
true

That is also why a method written for its effect declares : Unit — like @main def run(): Unit in every example here. If you write : Unit and the body ends in a String, the compiler keeps the side effects and throws the string away; since Scala 3 it warns you when that looks accidental.

match is Scala's switch, but far more capable and — like if — an expression. The value on the left is compared against each case from top to bottom; the first one that fits wins and its right-hand side becomes the result. There is no fall-through and no break. _ is the "anything else" case, and | lets one case accept several values.

@main def run(): Unit =
  val day = 6
  val kind = day match
    case 6 | 7 => "weekend"
    case 1     => "Monday"
    case _     => "weekday"
  println(kind)

  val temp = -4
  val band = temp match
    case t if t < 0  => "freezing"
    case t if t < 20 => "mild"
    case _           => "warm"
  println(band)

  for text <- List("42", "4x2") do
    text.toIntOption match
      case Some(n) => println(s"number $n")
      case None    => println(s"'$text' is not a number")

weekend
freezing
number 42
'4x2' is not a number

while cond do body repeats the body as long as the condition is true. It returns Unit and needs a var to make progress, which is why idiomatic Scala uses it less than Java does — collection methods (Module 07) usually say the same thing more clearly. It is still the right tool for "keep going until something happens" loops like reading input or retrying.

@main def run(): Unit =
  var n = 9471
  var digitSum = 0
  while n > 0 do
    digitSum += n % 10
    n /= 10
  println(digitSum)

  var attempts = 0
  while
    attempts += 1
    attempts < 3
  do ()
  println(s"stopped after $attempts attempts")

21
stopped after 3 attempts

There is no break or continue keyword. To stop early, wrap the loop in scala.util.boundary and call break(value): the boundary block immediately ends with that value. If the loop finishes normally, the block's last expression is the result.

import scala.util.boundary, boundary.break

@main def run(): Unit =
  val readings = List(3, 8, -2, 5, -9)
  val firstNegative = boundary:
    for r <- readings do
      if r < 0 then break(r)
    0
  println(firstNegative)

  for r <- readings do
    if r >= 0 then
      println(s"ok $r")

-2
ok 3
ok 8
ok 5

@main def run(): Unit =
  var i = 0
  while i < 3
    println(i)
    i += 1

-- [E040] Syntax Error: Main.scala:5:9
5 |    i += 1
  |         ^
  |         'do' expected, but integer literal found
-- [E008] Not Found Error: Main.scala:4:4
3 |  while i < 3
4 |    println(i)
  |        ^
  |        value println is not a member of Boolean.
  |        Note that `println` is treated as an infix operator in Scala 3.
  |        If you do not want that, insert a `;` or empty line in front
  |        or drop any spaces behind the operator.
2 errors found
Compilation failed

@main def run(): Unit =
  var i = 0
  while i < 3 do
    println(i)
    i += 1

A for in Scala walks over anything iterable: a range, a list, a string, an Option. 1 to 5 is a range that includes 5; 1 until 5 stops before it; by sets the step. Add if after a generator to filter (a guard), and several generators to nest loops. End with do to run code for each item, or yield to build a new collection from the results.

@main def run(): Unit =
  for i <- 1 to 3 do println(s"tick $i")
  println((1 until 4).toList)
  println((10 to 0 by -5).toList)

  val evenSquares = for n <- 1 to 10 if n % 2 == 0 yield n * n
  println(evenSquares)

  val seats = for
    row <- 1 to 2
    col <- List("A", "B")
  yield s"$row$col"
  println(seats)

  val shout = for c <- "hey" yield c.toUpper
  println(shout)

tick 1
tick 2
tick 3
List(1, 2, 3)
List(10, 5, 0)
Vector(4, 16, 36, 64, 100)
Vector(1A, 1B, 2A, 2B)
HEY

Scala 3 lets you drop braces and use indentation to mark blocks, like Python. Every example in this handbook uses that style. But Scala 3 still accepts the braces style completely, and most existing Scala code — including Spark jobs, which run on Scala 2.12 and 2.13 — is written with braces. You need to read both. The two programs below compile to exactly the same thing.

@main def run(): Unit =
  val nums = List(4, 11, 7)
  for n <- nums do
    if n > 5 then
      println(s"$n is big")
    else
      println(s"$n is small")
  end for
  println("done")
end run

4 is small
11 is big
7 is big
done

object Main {
  def main(args: Array[String]): Unit = {
    val nums = List(4, 11, 7)
    for (n <- nums) {
      if (n > 5) {
        println(s"$n is big")
      } else {
        println(s"$n is small")
      }
    }
    println("done")
  }
}

4 is small
11 is big
7 is big
done

Module 01 introduced the s, f and raw interpolators. Because everything is an expression, anything can go inside ${ ... } — arithmetic, method calls, even an if or a match. Keep it short, though: if the expression needs more than a glance, give it a val with a good name first.

@main def run(): Unit =
  val items = List("pen", "book", "lamp")
  val total = 1234.5
  println(s"${items.size} item${if items.size == 1 then "" else "s"}")
  println(s"first: ${items.head.toUpperCase}, last: ${items.last}")
  println(f"total: $total%,.2f")
  println(f"${items.size}%03d | ${total / items.size}%8.2f |")
  println(raw"C:\new\table")
  println(s"price: $$${total.toInt}")

3 items
first: PEN, last: lamp
total: 1,234.50
003 |   411.50 |
C:\new\table
price: $1234

@main def run(): Unit =
  val name = "Asha"
  val score = 91.5
  println(f"$name%s scored $score%d points")

-- [E209] Interpolation Error: Main.scala:4:28
4 |  println(f"$name%s scored $score%d points")
  |                            ^^^^^
  |         Found: (score : Double), Required: Int, Long, Byte, Short, BigInt
1 error found
Compilation failed

@main def run(): Unit =
  val name = "Asha"
  val score = 91.5
  println(f"$name%s scored $score%.1f points")

Expression

Code that evaluates to a value. In Scala, if, match, blocks, try and for-yield are all expressions.

Block

A group of expressions (indented or in braces) whose value is the value of its last expression.

Unit / ()

The type and single value of an expression evaluated only for its side effect.

Guard

An if inside a for or a case that filters which values continue.

Generator

The x <- xs part of a for, which takes each value from a collection in turn.

yield

Ends a for-comprehension and collects each result into a new collection.

Range

A lazy sequence of numbers: 1 to 5 includes 5, 1 until 5 does not, by sets the step.

boundary / break

scala.util.boundary marks a block that break(value) can exit early with a result.

Optional braces

Scala 3 syntax that uses indentation, then and do instead of braces and parentheses.