Convenience function for streams where the elements have a Functor instance

[L7R7]

I was wondering if it makes sense to have a convenience map-like function on Streams for when the elements have a Functor instance.

This could make mapping things less boilerplatey. For example:

val example: Stream[Pure, Option[Int]] = Stream.emits(List(Some("one"), Some("two"), None))
  .map(_.map(_.length))

What I don't really like is the .map(_.map(...)) part. If instead I had something along the lines of:

implicit class StreamFunctorOps[F[_], G[_], O](s: Stream[F, G[O]])(implicit f: Functor[G]) {
  def mapF[O2](f: O => O2): Stream[F, G[O2]] = s.map((value: G[O]) => value.map(f))
}

I could write:

val example2: Stream[Pure, Option[Int]] = Stream.emits(List(Some("one"), Some("two"), None))
  .mapF(_.length)

I'm wondering if this is a good idea and I'm curious to hear your thoughts on that.

(For context: we're doing something like that https://iravid.com/posts/using-cats-with-reactive-kafka.html, so we're kinda forced to always carry around the Message type in our stream)

[rossabaker]

Would Cats' Nested help? It's a good solution for repeated double maps, but you have to wrap and unwrap.

[L7R7]

Hmm. Would Nested work with a fs2.Stream as one of the type parameters?
I used it when I have two HKDs inside the stream, like Stream[List[Option[A]]] would be easier as Stream[Nested[List, Option]]

[rossabaker]

With kind-projector, Nested[Stream[F, *], Option]?