From: "marcandre (Marc-Andre Lafortune)" Date: 2013-01-14T13:15:27+09:00 Subject: [ruby-core:51416] [ruby-trunk - Bug #7690] Enumerable::Lazy#flat_map should not call each Issue #7690 has been updated by marcandre (Marc-Andre Lafortune). shugo (Shugo Maeda) wrote: > > 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. "Scala's flatMap is indeed not a monadic bind" here http://igstan.ro/posts/2012-08-23-scala-s-flatmap-is-not-haskell-s.html but I only scanned this quickly and I'm don't know if that's correct. > 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. Right. Except that both also accept straight objects. > > 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. Right, but the core of Ruby relies more on conversions than pure duck typing. In particular, Enumerable#flat_map uses `to_ary`. For the lazy flat_map, there is no "to_lazy" or similar... > Technically, this code should be written as follows: > ... It indeed could be written with [{...}], but it does not have to, as confirmed by Matz [ruby-core:43365]. > > 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. Sounds good. ---------------------------------------- Bug #7690: Enumerable::Lazy#flat_map should not call each https://bugs.ruby-lang.org/issues/7690#change-35395 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 } # => [#] 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/