Add alternative stack version

flat.rb

# Allow iteration on a flattened Enumerable.
# e.g. [1,[2,3],[[4]]].flat.map { |x| x * 2 }
#
module Enumerable
  def stack_flat_wip(&block)
    return to_enum(__method__) unless block_given?
    idx = [0]
    curr = self
    while idx.any? && curr
      puts idx.inspect
      puts curr.inspect
      puts '---'
      if idx.last >= curr.length
        idx.pop
        return if idx.empty?
        idx[-1] += 1
        curr = self
        puts 'popping'
        idx.each { |i| puts i, curr.inspect; curr = curr[i] }
      else
        val = curr[idx.last]
        if val.is_a?(Enumerable)
          curr = val
          idx << 0
        else
          yield val
          idx[-1] += 1
        end
      end
    end
  end
  
  def stack_flat(&block)
    return to_enum(__method__) unless block_given?
    stack = [self.each]
    while enum = stack.last
      begin
        val = enum.next
        if val.is_a?(Enumerable)
          stack << val.each
        else
          yield val
        end
      rescue StopIteration
        stack.pop
      end
    end
  end

  def recursive_flat(level = -1, &block)
    return to_enum(__method__, level) unless block_given?
    each do |val|
      if val.is_a?(Enumerable)
        val.recursive_flat(level - 1, &block)
      else
        yield val
      end
    end
  end
end