Cartesian builder for OptionT

Question

I want to join 2 Future[Option[_]]:

def foo: Future[Option[Int]] = ???
def baz: Future[Option[Int]] = ???

It is possible to join pair of Future:

foo |@| baz map( (fooOpt, bazOpt) => ???)

And possible to join pair of Option:

Option(1) |@| Option(2) map ( (a, b) => ???)

How to join pair of OptionT? Doesn't work like that:

OptionT(foo) |@| OptionT(baz) map ( (a, b) => ???)

UPD - here is my imports:

import cats.data.OptionT
import cats.instances.future._
import cats.instances.option._
import cats.syntax.cartesian._

import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.Future

I don't have time to look into exact types to give you a full answer (I'm not even using cats, but scalaz). But here's a hint: there's no existing implicit that would construct an applicative builder out of OptionT monad transformers. If you invoke .run on your foo and baz (actually in cats it could be `.value`, I don't remember) then you'll wind up with Future[Option[Int]] on both sides and it will be fine. — slouc, Sep 06 '17 at 10:48
@slouc, I think you are right. I already using something like that `foo |@| baz map ( (fooOpt, bazOpt) => fooOpt |@| bazOpt map (_ + _))`. I'm wondering if there is way to do it with single Cartesian builder. — EnverOsmanov, Sep 06 '17 at 11:00
Yeah I see. I fav'd the question, I'm interested in the answer as well. — slouc, Sep 06 '17 at 11:04
@EnverOsmanov please note the edit to my original answer, turns out there is a very simple fix! — blouerat, Sep 06 '17 at 12:29

blouerat · Accepted Answer · 2017-09-06T12:26:04.263

EDIT

Turns out, it's a very well known issue, it is caused by SI-2712. If you add the sbt-partial-unification plugin to your project, your original code will work just fine.

As I said, |@| is deprecated, you should change for the following syntax:

import cats.syntax.apply._
(OptionT(foo), OptionT(bar)).mapN(_ + _)

There seems to be an implicit resolution issue. OptionT has a Monad instance, and Monad extends Apply which extends Cartesian so your code should work indeed. It does work if you help the compiler a little bit:

import scala.concurrent.{ExecutionContext, Future}

import cats.data.OptionT
import cats.syntax.cartesian._
import cats.instances.future._

trait CartesianOptionTs  {

  implicit def ec: ExecutionContext

  def foo: Future[Option[Int]]
  def bar: Future[Option[Int]]

  (catsSyntaxCartesian[({type λ[α] = OptionT[Future, α]})#λ, Int](OptionT(foo)) |@| OptionT(bar)).map(_ + _)
}

but if you don't specify the types for catsSyntaxCartesian you get an interesting error:

[error]  found   : cats.data.OptionT[scala.concurrent.Future,Int]
[error]  required: ?F[?A]
[error] Note that implicit conversions are not applicable because they are ambiguous:
[error]  both method ArrowAssoc in object Predef of type [A](self: A)ArrowAssoc[A]
[error]  and method Ensuring in object Predef of type [A](self: A)Ensuring[A]
[error]  are possible conversion functions from cats.data.OptionT[scala.concurrent.Future,Int] to ?F[?A]
[error]       (catsSyntaxCartesian(OptionT(foo)) |@| OptionT(bar)).map(_ + _)

Note that |@| is now deprecated but it looks like you will have the same issue with its replacement mapN.

I can think of two workarounds. If you want to use OptionT, then bring its Apply instance in scope and use map2 directly (you might want to use a type alias instead of a type lambda):

  import cats.Apply
  Apply[({type λ[α] = OptionT[Future, α]})#λ].map2(OptionT(foo), OptionT(bar))(_ + _)

Alternatively, you can drop OptionT altogether and use Apply.compose:

  import cats.instances.option._
  Apply[Future].compose[Option].map2(foo, bar)(_ + _)

The future will be executed in parallel in that case though, so watch out if that's not what you want.

Cartesian builder for OptionT

1 Answers1