Interestingly since Enumerable#slice_when was added to Ruby I haven't seen a usecase for Enumerable#chunk that wasn't more clearly solved using Enumerable#slice_before, Enumerable#slice_when or Enumerable#slice_after. Do you have anything that can't be solved with one of them or where Enumerable#chunk leads to clearer code?

In any case if we decide to accept this, docs a crucial for such a complex method.

Enumerable#slice_before, Enumerable#slice_when or Enumerable#slice_after not so obvious to use (strange name, strange behavior), chunk is clear for me.

Note that while we don't have Enumerator we do have Iterator, which is the similar concept.

iterator need to implement next function, but how to implement it, if you only have each function from enumerable?

i trying to implement iterator, but have error with code:

class A(T)
  def initialize(@collection : Enumerable(T))
    @iterator = @collection.each
  end
end

a = A(Int32).new([1,2,3])

Enumerable(T) is not a generic class, it's a generic module

  def initialize(@collection : Enumerable(T))

We can probably have chunk in Enumerable like you did, and chunk in Iterator to be lazy. Check how iterators are created there. There's no way right now to have an instance variable of type "generic module", but you can work around that like this:

module Iterator
  def chunk
    Chunk(typeof(self), T).new(self)
  end

  class Chunk(I, T)
    @iterator : I

    def initialize(@iterator : Iterator(T))
    end
  end
end 

iterator added

@kostya Cool! Do you still have the non-iterator version? We could have both. Not all Enumerable have each without block, so the version that returns arrays can still be useful.

what classes without each? may be implement for them each on channels?

@kostya The standard library provides each for most collection classes, but we can't expect it to be in user-defined collections.

In the future I'd like to have something like Enumerator in Crystal if it can be done efficiently with fibers... but plain old iterators are always faster.

how add two methods chunk for each with block and without? different names?

added chunks method

@kostya I'll review the code and we'll eventually add this to the standard library :-)

One thing: instead of using nil, :_separator and :_alone for special meaning, we could maybe two marker types:

module Enumerable
  module Chunk
    record Drop
    record Alone
  end
end

So one can do:

enumerable.chunk { Enumerable::Chunk::Alone }

It's a bit more verbose, but this way nil and any symbol can participate in chunk methods.

@kostya don't worry about the nil case, if it can be done because of a compiler bug we can wait until that bug is fixed

funny that this code give error:

./bin/crystal eval 'p [1,2,3].chunk { Enumerable::Chunk::Drop }.to_a'

instantiating 'Enumerable::Chunk::Accumulator(Int32, Enumerable::Chunk::Drop:Class)#initialize()'

in ./src/enumerable.cr:106: can't use Object as a Proc argument type yet, use a more specific type

        @key = uninitialized U
        ^~~~

but this not:

./bin/crystal eval 'p [1,2,3].chunk { rand >= 0 ? Enumerable::Chunk::Drop : 1 }.to_a'
[]

This is done. Code is much readable now.

@kostya Thank you for this! And sorry for the long delay. I'll merge this and add a few more comments and do some small changes.