Simplify Loops with for-Comprehensions

You already know that for loops in Python iterate over sequences. But when you start nesting loops, filtering conditions, and collecting results, your code can quickly spiral into indentation soup. In Scala, the for-comprehension is a powerful construct that lets you express, flatten, and transform loops in a clean, functional way — all while keeping your code concise and readable. This lesson is your unlock: by the end of it, you'll reach for for-comprehensions to simplify even the most tangled loops, just like a seasoned Scala developer.

The problem this lesson solves

Nested loops are a rite of passage, but they also bring pain: deep indentation, hard-to-track variables, and error-prone bookkeeping. In Python, you might write:

result = []
for x in range(3):
    for y in range(3):
        if (x + y) % 2 == 0:
            result.append((x, y))
print(result)

That's five lines of imperative logic just to collect a filtered set of pairs. Now multiply that by real-world data — multiple lists, conditions, transformations — and your code becomes a dense thicket. The real problem isn't the loop; it's the clutter that hides your intent.

In Scala, the for-comprehension dissolves this clutter. It turns nested loops and filtering into a single, readable block that reads like a specification: "for every x, for every y, only when the sum is even, yield the pair." No temporary lists, no manual append.

Core concept / mental model

Think of a for-comprehension as a flattened loop with a built-in output channel. In Python, a list comprehension does something similar — [ (x,y) for x in range(3) for y in range(3) if (x+y)%2==0 ]. Scala's for takes that same idea and makes it a first-class language feature that works with any type that supports map, flatMap, and filter — not just lists.

Here's the mental model: every <- in a for-comprehension is a source of values. Each source is like a nested loop, but the indentation stays flat. A if after a generator acts as a filter. The yield clause collects each result into a new collection. If you omit yield, the for becomes a loop that runs for side effects only (like a Python for without a list comprehension).

In Scala, a for-comprehension is actually syntactic sugar — the compiler rewrites it into flatMap, map, and filter calls. That's why it works with options, futures, and other monadic types, not just collections. This is a powerful idea we'll unpack as you go.

How it works step by step

Let's break down the anatomy of a for-comprehension:

1. Generators — every x <- source introduces a new variable. The source can be a list, a set, an option, or anything that has flatMap, map, filter (such as a custom monad).
2. Filters — an if (without parentheses) after a generator restricts values flowing downstream.
3. Yield — the final expression after yield produces the value that gets collected into the result collection.
4. Omit yield — when you don't need a result, you can drop yield to run the loop for side effects (e.g., printing).

The order matters: generators are nested in the order they appear, so the first generator becomes the outer loop. This matches how a Python list comprehension works, but the syntax reads more like a sentence.

For example:

val pairs = for {
  x <- 1 to 3
  y <- 1 to 3
  if (x + y) % 2 == 0
} yield (x, y)

This produces the same result as the Python snippet: Vector((1,1), (1,3), (2,2), (3,1), (3,3)). Notice how the filter is inlined and the indentation is consistent — no deep nesting.

Hands-on walkthrough

Let's get our hands dirty. Fire up a Scala REPL (or use a worksheet in IntelliJ) and follow along.

Example 1: Flattening nested loops

// Coordinates on a 3x3 grid, only where x + y is even
val coords = for {
  x <- 0 until 3
  y <- 0 until 3
  if (x + y) % 2 == 0
} yield (x, y)

println(coords)
// Output: Vector((0,0), (0,2), (1,1), (2,0), (2,2))

Wait — that's different from the earlier example because we started at 0 until 3 (exclusive). That's the kind of subtlety you'll want to remember.

Example 2: Combining two lists

val colors = List("red", "green")
val sizes = List("S", "M", "L")

val combinations = for {
  c <- colors
  s <- sizes
} yield s"$c in $s"

println(combinations)
// List(red in S, red in M, red in L, green in S, green in M, green in L)

Notice how colors is the outer loop — the resulting list starts with all sizes for red, then all for green.

Example 3: Loops with side effects — no yield

for {
  i <- 1 to 3
  j <- 1 to 3
  if i != j
} println(s"Pair: $i, $j")
// Outputs every ordered pair (i, j) where i != j

Here we don't collect results — we just print. Use this when you're interacting with the outside world, like logging or writing to a file.

Example 4: With options (a taste of monads)

val maybeX: Option[Int] = Some(2)
val maybeY: Option[Int] = Some(3)

val sum = for {
  x <- maybeX
  y <- maybeY
} yield x + y

println(sum) // Some(5)
// If either is None, the result is None — no null checks!

This works because Option also supports flatMap and map.

Try running these in your REPL. Experiment by adding more filters, changing sequences, and mixing types.

Compare options / when to choose what

You now have several tools in your belt. Let's compare them side by side:

When you're dealing with many steps (generators, filters, transformations), a for-comprehension beats both nested loops and chained flatMap calls in readability. However, if you only need a single map or filter, calling the method directly is more idiomatic — you don't need the extra machinery. As a rule of thumb: if you're nesting loops in Python, you probably should use a for-comprehension in Scala.

Troubleshooting & edge cases

You might encounter a few quirks. Let's fix them before they bite you.

• Syntax error: missing yield? If you write for { x <- xs } x * 2 without yield, you'll get a compile error. yield is essential when you want a result collection. If you forget it, you're running a side-effect loop, and the expression x * 2 is invalid there.

• Fix: add yield before the expression.

• Type mismatch: the result isn't what you expected. Remember, the result type is determined by the first generator. If xs is a List, you get a List; if it's a Range, you get a Vector (or IndexedSeq). Don't assume it'll be a List — it depends on the source.

• Filtering with if — no parentheses needed. In Scala, you write if x > 0 without parentheses, unlike Python's if (x > 0). The compiler is forgiving with parentheses in many cases, but it's standard to omit them.

• Nested for vs. single for — a common confusion. Consider:

for {
  x <- xs
  for { y <- ys } yield y
} yield x

This usually isn't what you want. The inner for is treated as a value, but you're not using it. Instead, you should flatten: for { x <- xs; y <- ys } yield x — that gives you the cross product.

• yield with side effects? Don't mix pure yields with side effects. If you need to print and collect, consider two separate loops or a map with a println inside (which is a side-effect — not ideal, but possible). Better: collect everything with yield, then foreach the collection to print.

• Edge case: empty collections. If any generator source is empty, the whole comprehension yields an empty collection. That's correct — no iterations happen. This makes your code unexpectedly safe from IndexOutOfBounds errors when dealing with options.

What you learned & what's next

You've learned that for-comprehensions in Scala aren't just a fancy loop — they're a readable, composable way to flatten nested iterators, apply filters, and yield results. You can now take the messiest nested loops from your Python days and rewrite them as a flat, intention-revealing block. You've also seen the monadic side: the same syntax handles Options, which is your first step into functional error handling.

The next lesson in this track builds on this superpower by showing how to use pattern matching inside for-comprehensions. You'll learn to destructure tuples, case classes, and even collections directly in the generator — unlocking a whole new level of expressiveness.

Now, before you move on, try this mini-exercise: rewrite a nested loop that builds a multiplication table (from 1 to 5) using a for-comprehension. Print it or yield it as a list of strings. You'll see how quickly it comes together — and you'll never want to go back to deep indentation again.