在这个最近的 Stack Overflow 问题中，作者想要将某种类型的解析器列表更改为返回该类型列表的解析器。我们可以想象用 Scalaz's sequencefor applicative functors 来做这件事：
import scala.util.parsing.combinator._
import scalaz._
import Scalaz._
object parser extends RegexParsers {
val parsers = List(1, 2, 3).map(repN(_, """\d+""".r))
def apply(s: String) = parseAll(parsers.sequence, s)
}
在这里，我们获取一个包含三个返回整数列表的解析器的列表，并将其转换为一个返回整数列表的解析器。不幸的是，Scalaz 没有为 提供Applicative实例Parser，因此这段代码无法编译，但这很容易修复：
import scala.util.parsing.combinator._
import scalaz._
import Scalaz._
object parser extends RegexParsers {
val parsers = List(1, 2, 3).map(repN(_, """\d+""".r))
def apply(s: String) = parseAll(parsers.sequence, s)
implicit def ParserPure: Pure[Parser] = new Pure[Parser] {
def pure[A](a: => A) = success(a)
}
implicit def ParserFunctor: Functor[Parser] = new Functor[Parser] {
def fmap[A, B](p: Parser[A], f: A => B) = p.map(f)
}
implicit def ParserBind: Bind[Parser] = new Bind[Parser] {
def bind[A, B](p: Parser[A], f: A => Parser[B]) = p.flatMap(f)
}
}
这可以按预期工作：例如，parser("1 2 3 4 5 6")给我们List(List(1), List(2, 3), List(4, 5, 6))。
（我知道我可以只给出一个Apply实例，但Bind实例更简洁。）
每次我们都可以不必这样做 extend 会很好Parsers，但我不清楚如何更普遍地获取Applicative实例。Parsers#Parser以下幼稚的方法当然行不通，因为我们需要Parsers相同的实例：
implicit def ParserBind: Bind[Parsers#Parser] = new Bind[Parsers#Parser] {
def bind[A, B](p: Parsers#Parser[A], f: A => Parsers#Parser[B]) = p.flatMap(f)
}
我很清楚这应该是可能的，但我对 Scala 的类型系统不够熟悉，不知道如何去做。我缺少一些简单的东西吗？
回应以下答案：我确实尝试了这-Ydependent-method-types条路线，并走到了这一步：
implicit def ParserApplicative(g: Parsers): Applicative[g.Parser] = {
val f = new Functor[g.Parser] {
def fmap[A, B](parser: g.Parser[A], f: A => B) = parser.map(f)
}
val b = new Bind[g.Parser] {
def bind[A, B](p: g.Parser[A], f: A => g.Parser[B]) = p.flatMap(f)
}
val p = new Pure[g.Parser] {
def pure[A](a: => A) = g.success(a)
}
Applicative.applicative[g.Parser](p, FunctorBindApply[g.Parser](f, b))
}
问题（正如didierd指出的那样）是不清楚如何implicit启动。所以这种方法确实有效，但您必须在语法中添加以下内容：
implicit val applicative = ParserApplicative(this)
在这一点上，mixin 方法显然更具吸引力。
（作为旁注：我希望能够简单地写Applicative.applicative[g.Parser]在上面，但这给出了一个错误，说编译器无法找到Pure[g.Parser]- 即使一个人坐在它旁边的隐含值。所以很明显有一些不同的东西隐含的方式适用于依赖方法类型。）
感谢retroonym指出了一个实现我想要的技巧。我从他的代码中提取了以下内容：
implicit def parserMonad[G <: Parsers with Singleton] =
new Monad[({ type L[T] = G#Parser[T] })#L] {
def pure[A](a: => A): G#Parser[A] = {
object dummy extends Parsers
dummy.success(a).asInstanceOf[G#Parser[A]]
}
def bind[A, B](p: G#Parser[A], f: (A) => G#Parser[B]): G#Parser[B] =
p.flatMap(f)
}
Parser如果你在范围内有这个，你会在任何扩展的对象中获得一个 monad 实例Parsers。由于演员阵容，这有点作弊，但仍然很整洁。