Proposal: chunked(size) method.

[arnolddevos]

The idea is to materialise a generator in chunks. Here is a sketch of the proposed operation as a non-member method:

def chunked[R](input: Generator[R], size: Int): Generator[Iterable[R]] =
  new Generator[Iterable[R]]:
    def generate(f: Iterable[R] => Generator.Action): Generator.Action =
      val builder = Iterable.newBuilder[R]
      var n = 0
      var action: Generator.Action = Generator.Continue
      input.generate {
        r =>
          if n < size then 
            if n == 0 then builder.sizeHint(size)
            builder.addOne(r) 
            n += 1
            action
          else
            action = f(builder.result) 
            builder.clear
            n = 0
            action
      }
      if n > 0 && action == Generator.Continue then f(builder.result)
      else action

In comparison, toBuffer, toList etc materialise the whole of the stream. The standard collection operations Iterator.grouped and Iterable.grouped are similar. Chunking is a fairly common streaming operation so I think the need for this would arise often enough. The choice of type Iterable for the chunks might or might not be the best.