List[OptionT[Future, Int]] to OptionT[Future, List[A]] - scala

Question

I'm building a List of Int using an an async computation for retrieving element:
(1 to n).map(anAsyncThingy).toList
where anAsyncThingy returns OptionT[Future, Int]
The result is hence of type List[OptionT[Future, Int]]
What I'd like to get now is an OptionT[Future, List[A]]
Here's my best attempt so far (I'll add some stubs, so that it can run in a REPL)
import scalaz._; import Scalaz._
import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global
def anAsyncThingy(x: Int): OptionT[Future, Int] = x.point[Future].liftM[OptionT]
val res = OptionT {
Future.sequence {
(1 to 3).map(anAsyncThingy(_).run).toList
}.map(_.sequence)
}
res.map(println) // List(1, 2, 3)
The above works as expected, but I feel there's a lot of room for improvement using the proper scalaz constructs, instead of jumping in and out from monad transfomers.
How can I achieve the same result a in a more straightforward way?

Answer 1

I found the answer myself, after some experimenting:
val res = (1 to 3).map(anAsyncThingy).toList.sequenceU
res.map(println) // List(1, 2, 3)
Yay for scalaz!
By the way, sequenceU is needed instead of sequence because scala isn't smart enough to figure out when you have
OptionT[M, A]
if you fix a type parameter (M to Future for instance)
OptionT[Future, A]
it has the shape of M[_]
The compiler keeps believing it has a M[_, _] shape, unless spoonfed (with a nasty type lambda)
Here's where scalaz's sequenceU kicks in and works around this issue using Unapply. More on the subject here.
Update
As per phadej's comment, sequence ∘ map ≡ traverse, so this can be made even more concise with traverseU:
(1 to 3).toList.traverseU(anAsyncThingy)
The same idea of sequence vs sequenceU applies to traverse vs traverseU, of course.