如何使用scalaz序列将T[G[A]]转换为G[T[A]]

Question

我有这样的代码，通过使用scalaz序列将List[Foret[Int]]转换为Future[List[Int]]。

import scalaz.concurrent.Future
val t = List(Future.now(1), Future.now(2), Future.now(3)) //List[Future[Int]]
val r = t.sequence //Future[List[Int]]

因为我使用的是来自scalaz的Future，所以它可能具有隐式分辨率，这对我来说很神奇，我只是想知道类型类是否是自定义类，而不是像Future那样预定义的类，我如何定义隐式分辨率来实现相同的结果

case class Foo(x: Int)
val t = List(Foo(1), Foo(2), Foo(3)) //List[Foo[Int]]
val r = t.sequence //Foo[List[Int]]

提前感谢

Answer 1

您需要创建一个隐式作用域中的Applicative[Foo]（或Monad[Foo]）。

你所要求的完全不起作用，因为你的Foo不是普遍量化的（所以你对r的期望类型与Foo[List[Int]]没有意义，因为Foo没有类型参数。

让我们以不同的方式定义Foo：

case class Foo[A](a: A)
object Foo {
  implicit val fooApplicative = new Applicative[Foo] {
      override def point[A](a: => A) = Foo(a)
      override def ap[A,B](fa: => Foo[A])(f: => Foo[A=>B]): Foo[B] = Foo(f.a(fa.a))
  } 
}

现在，如果我们确保这个隐式在范围内，我们可以排序：

scala> val t = List(Foo(1), Foo(2), Foo(3)) 
t: List[Foo[Int]] = List(Foo(1), Foo(2), Foo(3))
scala> t.sequence
res0: Foo[List[Int]] = Foo(List(1, 2, 3))