Scala：ForComprehension是一种功能性方法还是命令式？

Question

My collections:

val l1 = List(1, 2, 3)
val l2 = List("A", "B", "C")

Here is an imperative approach:

for {
    e1 <- l1
    e2 <- l2
  } {
    println(s"$e1 - $e2")
  }

And FP approach:

l1 foreach { 
  a => l2 foreach { 
    b => println { 
      s"$a - $b" 
    } 
  } 
}

However, classic for loop represents a purely imperative style, I have some doubts about imperativeness of For Comprehension loop. So my question is: am I right that For Comprehension loop is from imperative style or not?

Answer 1

A for-comprehension is a functional way of writing "imperative-looking" code.

I'll cite Paul Chiusano and Runar Bjarnason from "Functional Programming in Scala" because I could never put it better:

Page 89

Aren't imperative and functional programming opposites?

Absolutely not. Remember, functional programming is simply programming without side effects. Imperative programming is about programming with statements that modify some program state, and as we've seen, it's entirely reasonable to maintain state without side effects.

Functional programming has excellent support for writing imperative programs, with the added benefit that such programs can be reasoned about equationally because they're referentially transparent.

---

An example from the same page:

val ns: Rand[List[Int]] =
  int.flatMap(x =>
    int.flatMap(y =>
      ints(x).map(xs =>
        xs.map(_ % y))))

It's not clear what's going on here. But since we have map and flatMap defined, we can use a for-comprehension to recover the imperative style:

val ns: Rand[List[Int]] = for {
  x <- int
  y <- int
  xs <- ints(x)
} yield xs.map(_ % y)

This code is much easier to read (and write), and it looks like what it is—an imperative program that maintains some state. But it's the same code. We get the next Int and assign it to x , get the next Int after that and assign it to y , then generate a list of length x , and finally return the list with all of its elements modulo y . To facilitate this kind of imperative programming with for-comprehensions (or flatMaps ), we really only need two primitive State combinators—one for reading the state and one for writing the state.

---

One more from page 203:

We can see that a chain of flatMap calls (or an equivalent for-comprehension) is like an imperative program with statements that assign to variables, and the monad specifies what occurs at statement boundaries .