Integration with cats Parallel

[SystemFw]

cats has recently added a Parallel typeclass which relates types such as Either and Validation, and lets you do (fa, fb).parMap(foo), which will use the "related" Applicative, while keeping consistent <*> and flatMap, and without requiring any explicit tagging by the user.
This gives us an opportunity to provide an Applicative Api in addition to start for parallel F (I like start so I want to keep it regardless). Should we:

• Do nothing
• Add a Parallel instance for any F[_]: Effect. This will be an orphan so perhaps unadvisable, but it will mean we can remove parSequence and parTraverse (already defined for every Parallel)
• Add a ParIO newtype, and add a Parallel[IO, ParIO] instance

More info on Parallel: typelevel/cats#1837

[mpilquist]

👍

I like the idea of a parallel instance for any effect. Is there a way we could do this as a newtype so as to avoid the orphan?

[SystemFw]

I don't think we can do it for any effect without orphans without introducing explicit tagging, which would make it moot. I haven't really thought about it that much yet though

…

On 6 Nov 2017 12:37, "Michael Pilquist" ***@***.***> wrote: 👍 I like the idea of a parallel instance for any effect. Is there a way we could do this as a newtype so as to avoid the orphan? — You are receiving this because you authored the thread. Reply to this email directly, view it on GitHub <#969 (comment)>, or mute the thread <https://github.com/notifications/unsubscribe-auth/AHaN7ubDXq-c5NJD_nKa-r7mXjciXTl0ks5szv2PgaJpZM4QTJxG> .

[mpilquist]

Why can't we do something like:

case class Par[F[_],A](value: F[A])
object Par {
  implicit def parallelInstanceForEffect[F[_]](implicit F: Effect[F]): Parallel[F, Par[F,?]] = new Parallel[F,Par[F,?]] {
    def applicative: Applicative[Par[F,?]] = Par.applicativeInstance
    def monad: Monad[F] = F
  }
  def applicativeInstance[F[_]](implicit F: Effect[F]): Applicative[F] = ...
}

[SystemFw]

I'm actually thinking we will have the same problem regardless of whether we do it for IO or for F (and therefore we should prefer a solution like the one you propose), namely that we would need an import or a type annotation to make the syntax work:
(ioA, ioB).parMap((x,y) => ...)
parMap would need an instance for Parallel[F, Par[F, ?]], which will only be in scope if we put it in the companion object of F (and let the "functional dependency" trigger), or if we specify parMap[IO, ParIO]((x,y) => ) or if we bring it into scope with an import.
However I haven't written any code to try, so I might well be wrong.

[SystemFw]

I think the only way to avoid an orphan (or in any case something that would require an import to be usable) would be to newtype IO, not ParIO...which I'm definitely not sure it's a good idea. But once more, I'll need to spend some time on this

[mpilquist]

Right, gotcha.

[LukaJCB]

You're right sadly, Scala can't figure out the M if the parallel instance is defined on the companion of F(I've tried this in the past), so there will have to be an import :/
In that case I think it makes sense to provide it for any Effect.

[SystemFw]

Another approach would be typelevel/cats-effect#83