[ruby-core:51415] [ruby-trunk - Bug #7690] Enumerable::Lazy#flat_map should not call each

Issue #7690 has been updated by shugo (Shugo Maeda).


marcandre (Marc-Andre Lafortune) wrote:
> shugo (Shugo Maeda) wrote:
> > [1].lazy.flat_map{|i| [i].lazy } should flatten nested lazy enumerators, because Enumerable::Lazy is a monad and flat_map is the monad's bind operator.
> 
> Thanks for the explanation.
> 
> The idea is neat.
> 
> The problem is that:
> 1) This is documented nowhere
> 2) Most people think of flat_map as a shortcut to map.flatten(1), but flatten doesn't flatten Lazy enumerators (or Enumerables in general)

Agreed, but 2) should be solved by documentation.

> 3) As Matz stated [ruby-core:26301], flat_map is "taken from flatMap from Scala or concatMap from Haskell". I'm not familiar with either, but I read that Scala's flatMap is not a monadic bind, right?

Where did you read that?  I guess Scala's flatMap is also bind.

Ruby's Enumerable#flat_map is also bind.
Because Enumerable#flat_map returns an Array, Enumerable#flat_map takes a block which returns an Array.
Because Enumerator::Lazy#flat_map returns an Enumerator::Lazy, Enumerator::Lazy#flat_map takes a block which returns an Enumerator::Lazy.
They are consistent in that sense.

> 4) The argument about flat_map being a monadic bind applies only to monads (i.e. lazy enumerators). It should only flatten those, not arbitrary Enumerables

I feel difficulty about it because duck typing is preferred in Ruby.

> > Do you have any use case of [1].flat_map{|i| {i => i} }?
> 
> It's not just hashes, it could be a Range, or any Enumerable, or even any class that implements #each, even if it doesn't include Enumerable!
> 
> So yes, I can think of many use cases, but instead of inventing them, here's one in Rails:
> 
> https://github.com/rails/rails/blob/master/activerecord/lib/active_record/relation/query_methods.rb#L841

Technically, this code should be written as follows:

      order_query.flat_map do |o|
        case o
        when Arel::Nodes::Ordering
          o.reverse
        when String
          o.to_s.split(',').collect do |s|
            s.strip!
            s.gsub!(/\sasc\Z/i, ' DESC') || s.gsub!(/\sdesc\Z/i, ' ASC') || s.concat(' DESC')
          end
        when Symbol
          [{ o => :desc }]
        when Hash
          [o.each_with_object({}) do |(field, dir), memo|
             memo[field] = (dir == :asc ? :desc : :asc )
           end]
        else
          [o]
        end
      end

> In summary, I see the following 2 possibilities:
> 1) Lazy#flat_map only flattens arrays, or
> 2) Lazy#flat_map flattens Array and Enumerator::Lazy (using `is_a? Enumerator::Lazy` instead of `respond_to? :each`) and the documentation reflects this

I prefer 2), but am not sure whether `is_a? Enumerable::Lazy' is a neat solution.
However, if I don't come up with a better solution, I will fix Lazy#flat_map using it.

----------------------------------------
Bug #7690: Enumerable::Lazy#flat_map should not call each
https://bugs.ruby-lang.org/issues/7690#change-35394

Author: marcandre (Marc-Andre Lafortune)
Status: Assigned
Priority: High
Assignee: shugo (Shugo Maeda)
Category: core
Target version: 2.0.0
ruby -v: r38794


I would expect that

    array.flat_map{...} == array.lazy.flat_map{...}.force

This is not always the case:

    [1].flat_map{|i| {i => i} } # => [{1 => 1}], ok
    [1].lazy.flat_map{|i| {i => i} }.force # => [[1, 1]], expected [{1 => 1}]

Note that Matz confirmed that it is acceptable to return straight objects instead of arrays for flat_map [ruby-core:43365]

It looks like this was intended for nested lazy enumerators:

    [1].lazy.flat_map{|i| [i].lazy }.force # => [1]

I don't think that's the correct result, and it is different from a straight flat_map:

    [1].flat_map{|i| [i].lazy } # => [#<Enumerator::Lazy: [1]>]

This is caused by Lazy#flat_map calls each (while Enumerable#flat_map only looks for Arrays/object responding to to_ary).





-- 
http://bugs.ruby-lang.org/