Scala “

To augment Dave’s answer, here is a translation schema for ‘for-comprehensions’ from Scala language specification:

A comprehension for (enums) yield e evaluates expression e for each binding generated by the enumerators enums. An enumerator sequence always starts with a generator; this can be followed by further generators, value definitions, or guards.

A generator p <- e produces bindings from an expression e which is matched in some way against pattern p. A value definition val p = e binds the value name p (or several names in a pattern p) to the result of evaluating the expression e. A guard if e contains a boolean expression which restricts enumerated bindings.

The precise meaning of generators and guards is defined by translation to invocations
of four methods: map, filter, flatMap, and foreach. These methods can be implemented in different ways for different carrier types.

The translation scheme is as follows. In a first step, every generator p <- e, where p is not irrefutable (§8.1) for the type of e is replaced by

 p <- e.filter { case p => true; case _ => false }

Then, the following rules are applied repeatedly until all comprehensions have been
eliminated.

• A for-comprehension for (p <- e) yield e0 is translated to e.map { case p => e0 }.

• A for-comprehension for (p <- e) e0 is translated to e.foreach { case p => e0 }.

• A for-comprehension for (p <- e; p0 <- e0 . . .) yield e00, where . . . is a (possibly empty) sequence of generators or guards, is translated
  to:
  e.flatMap { case p => for (p0 <- e0 . . .) yield e00 }.

• A for-comprehension for (p <- e; p0 <- e0 . . .) e00 where . . . is a (possibly empty) sequence of generators or guards, is translated to:
  
  e.foreach { case p => for (p0 <- e0 . . .) e00 } .

• A generator p <- e followed by a guard if g is translated to a single generator:
  p <- e.filter((x1, . . . , xn) => g )
  where x1, . . . , xn are the free variables
  of p.

• A generator p <- e followed by a value definition val p0 = e0 is translated
  to the following generator of pairs of values, where x and x0 are fresh names:

  val (p, p0) <- 
    for(x@p <- e) yield { val x0@p0 = e0; (x, x0) }