From: "zverok (Victor Shepelev) via ruby-core" <ruby-core@...>
Date: 2026-06-27T06:27:49+00:00
Subject: [ruby-core:125858] [Ruby Feature#22132] Scala-like for comprehensions

Issue #22132 has been updated by zverok (Victor Shepelev).


TBH, in all my years with Ruby, it felt for me as its deep characteristic that "you never need `for`, think in enumerables." 

I believe that introducing "`for` that is useful for some complex cases" will dilute this image. Ruby is almost the only mainstream language that doesn't use `for` for most of the cases, and it is the first thing to be taught to newcomers: "you'll hardly need `for`, try to think in Enumerable methods."

So, when met with a riddle like this, I prefer to start considering "what our Enumerables are missing, which would make it more convenient without introducing a new style."

For the first case in the ticket, the answer seems to be `#product`:

```ruby
def foo(n, v)
  (0...n).product(0...n).filter { _1 + _2 == v }.map { [_1, _2] }
end

p foo(10, 10)
#=> [[1, 9], [2, 8], [3, 7], [4, 6], [5, 5], [6, 4], [7, 3], [8, 2], [9, 1]]
```

With the second example (inner iteration depends on outer) `product` isn't relevant, so I'd probably kept it in the "produce the sequence, then filter it" form:

```ruby
(1..).lazy.flat_map { |z| (1..z).lazy.flat_map { |x| (x..z).lazy.map { |y| [x, y, z] } } }
  .filter { |x, y, z| x**2 + y**2 == z**2 }.take(3).force
```

I agree it is a bit cumbersome, but I believe that 3+ nested iterations is a rather rare/edge case; and still, we can have here a Ruby-ish "produce sequence, then filter sequence" structure, which is combinable to everything else (for example, filter condition can come here as a parameter/variable.

PS: As a side note, the `product` solution wouldn't work in a form I wrote it, because for some reason we don't have `Enumerable#product` or `Enumerator::Lazy#product`, and only `Enumerator.product`. Various forms were proposed several times (#19324, #17312, #14399), but it hasn't moved forward yet.

----------------------------------------
Feature #22132: Scala-like for comprehensions
https://bugs.ruby-lang.org/issues/22132#change-117782

* Author: shugo (Shugo Maeda)
* Status: Open
----------------------------------------
## Abstract

How about adding an expression form of `for` that desugars into nested `flat_map`/`map` and `filter` calls.

Here's an example, which computes all pairs of numbers between `0` and `n-1` whose sum is equal to a given value `v`:

```ruby
def foo(n, v)
  for i in 0...n,
      j in 0...n when i + j == v then
    [i, j]
  end
end

p foo(10, 10) #=> [[1, 9], [2, 8], [3, 7]...]
```

The above code is desugared as follows:

```ruby
def foo(n, v)
  (0...n).flat_map { |i|
    (0...n).filter { |j|
      i + j == v
    }.map { |j|
      [i, j]
    }
  }
end

p foo(10, 10)
```

## Background and Motivation

Some other languages have syntactic sugar that flattens nested code.

For example, Scala has for comprehensions:

```scala
def foo(n: Int, v: Int) =
   for i <- 0 until n
       j <- 0 until n if i + j == v
   yield (i, j)
```

Haskell has do notation:

```haskell
foo :: Int -> Int -> [(Int, Int)]
foo n v = do
  i <- [0 .. n-1]
  j <- [0 .. n-1]
  guard (i + j == v)
  pure (i, j)
```

Blocks are often nested deeply in Ruby, so such syntactic sugar is useful.

## Use cases

For comprehensions can be used to flatten nested blocks.

For example,

```ruby
(1..).lazy.flat_map { |z|
  (1..z).lazy.flat_map { |x|
    (x..z).lazy.filter { |y|
      x**2 + y**2 == z**2
    }.map { |y|
      [x, y, z]
    }
  }
}.take(3).force
```

can be flattened as follows:

```ruby
for z in (1..).lazy,
    x in (1..z).lazy,
    y in (x..z).lazy when x**2 + y**2 == z**2 then
  [x, y, z]
end.take(3).force
```

For comprehensions can be used not only for Enumerable objects, but also for other objects with lawful `flat_map` and `map` (i.e., any [monad](https://wiki.haskell.org/index.php?title=Monad) whose `map` is the functor map derived from `flat_map`). For example, `flat_map` and `map` must cohere so that nested calls can be flattened:

```ruby
m.flat_map(&f).map(&g) == m.flat_map { |x| f.(x).map(&g) }
```

## Why `then` and `when`?

Scala's `yield` conflicts with the existing `yield` keyword in Ruby, so I chose `then`.
While a bare `for ... then` (no guard) reads a little unnaturally in English, Ruby already gives `then` a value-producing meaning (e.g., `Kernel#then`), so I consider it acceptable.

The guard keyword is not `if` but `when`, because `if` after the source would be ambiguous with the modifier `if`.

## Limitations

The right operand of `in` is `arg_value`, not `expr_value`, to avoid conflicts, so unparenthesized method calls (command calls) must be parenthesized.

## Backward compatibility

* `for x in xs do ... end` (and the newline form) is unchanged: it still iterates via `each` and returns the collection.
* All of the new forms (`for ... then`, `for ... ,`, `for ... when`) were `SyntaxError` before, so no existing program changes meaning.

## Implementation

PoC: https://github.com/ruby/ruby/pull/17500

It's currently implemented only in `parse.y`, not in Prism yet, so requires `--parser=parse.y`.

## Open questions

* Variable scope: the loop variables currently leak, same as `for ... do`. Should a comprehension instead scope them like a block?




-- 
https://bugs.ruby-lang.org/
______________________________________________
 ruby-core mailing list -- ruby-core@ml.ruby-lang.org
 To unsubscribe send an email to ruby-core-leave@ml.ruby-lang.org
 ruby-core info -- https://ml.ruby-lang.org/mailman3/lists/ruby-core.ml.ruby-lang.org/