Add foldMap alternative that uses scan, scanMonoid

[kubukoz]

Something along the lines of:

def scanMap[O2](f: (O2, O) => F[O2])(implicit O2: Monoid[O2], F: Functor[F]): fs2.Stream[F, O2] =
  stream.evalScan(O2.empty)((acc, el) => F.map(f(acc, el))(O2.combine(acc, _)))

Not sure about the naming of it, could be evalScanMonoid or something like that, but it looks similar to foldMap to me (apart from the Functor[F] requirement). Maybe it's possible to write it with pull and without the Functor bound?

Also, scanMonoid resembling foldMonoid:

def scanMonoid(implicit O: Monoid[O]): fs2.Stream[F, O]

[kubukoz]

As mentioned in the gitter channel, I'll gladly implement these ;)

[mpilquist]

@kubukoz Do you still want to implement these? The signatures look good to me.

[kubukoz]

Yeah, I haven't had much time lately so if someone wants to do them soon I'm good with that, but hopefully I'll have some time after the weekend, in case nobody picks this up :)

…

On Thu, Sep 6, 2018, 14:05 Michael Pilquist ***@***.***> wrote: @kubukoz <https://github.com/kubukoz> Do you still want to implement these? The signatures look good to me. — You are receiving this because you were mentioned. Reply to this email directly, view it on GitHub <#1184 (comment)>, or mute the thread <https://github.com/notifications/unsubscribe-auth/AA2npBxc3gJKJOXRlFGSLkMeBCDiO0Zeks5uYQ-EgaJpZM4VbUOv> .

[mpilquist]

Sounds good to me. Looking forward to it.

[kubukoz]

I'm on it! Should be done this week. I saw that scanMap is already a thing in 1.0, but in a slightly different form.

What I'd be looking for now is:

def evalScanMonoid[F2[x] >: F[x], O2](f: O => F2[O2])(implicit O2: Monoid[O2],
                                                        F: Functor[F2]): Stream[F2, O2] =
  evalScan[F2, O2](O2.empty) { (acc, o) =>
    f(o).map(O2.combine(acc, _))
  }

Maybe def scanMap[O2](f: (O2, O) => F[O2])(implicit O2: Monoid[O2], F: Functor[F]) is also a good thing to have though, in which case the evalScanMonoid could be implemented in terms of that.

Edit: Now that I think about it, I think having the (f: (O2, O) => F[O2])(implicit O2: Monoid[O2], F: Functor[F]) variant would be confusing - since the O2 value passed to f would still be combined with the result of f, but could also be used in f itself. If someone wants that level of control, it might be better for them to call evalScan directly.

[tabdulradi]

I saw that scanMap is already a thing in 1.0, but in a slightly different form.

I couldn't find that method in the code base, only from old commits from 2013, seems it didn't make it at the end. So I defined it myself like:

    def scanMap[O2](f: O => O2)(implicit O2: Monoid[O2]): Stream[F, O2] =
      self.scan(O2.empty)((acc, el) => acc |+| f(el))

    def scanMonoid(implicit O: Monoid[O]): Stream[F, O] =
      self.scanMap(identity)

Happy to PR the snippet above if it's useful to others.

[mpilquist]

@tabdulradi Sounds good, PR is definitely welcome!