From: "shugo (Shugo Maeda)" <redmine@...>
Date: 2013-01-14T16:53:35+09:00
Subject: [ruby-core:51423] [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:
> > > 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.

Thanks for the information.
I guess the comment said "Scala's flatMap is indeed not a monadic bind" because Scala's flatMap is extended to accept functions which returns another type of container.

  scala> List(1, 2, 3, 4) flatMap {x => Some(x)}
  res0: List[Int] = List(1, 2, 3, 4)

Here, the function {x => Some(x)} returns Some(x), which is not a List, but flatMap unwrap values from them.
In this case, flatMap is not a bind operator.

However, it can be used as a bind operator if a given function returns a List.

  scala> List("foo bar", "baz") flatMap {x => x.split(" ")}
  res6: List[java.lang.String] = List(foo, bar, baz)

That's why I said Lazy#flat_map should flatten lazy enumerators.
It's not a pure bind operator, but should be able to be used as a bind operator.

> > > 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...

Yes, that's the problem I was thinking of.

I was thinking of having a predicate like lazy_enumerator?, but your idea of checking each and force sounds better,
because it's too late to introduce a new method for Ruby 2.0.0.


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

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/