Вэтот недавний вопрос переполнения стекаавтор хотел изменить список анализаторов некоторого типа на анализатор, который возвращает списки этого типа. Мы можем представить, что делаем это с помощью Скалазаsequence для аппликативных функторов:

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)
}

Здесь мы берем список из трех парсеров, которые возвращают списки целых чисел, и превращаем его в парсер, который возвращает списки целых чисел. К сожалению, Скалаз не предоставляет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 пример более лаконичен.)

Было бы неплохо не делать это каждый раз, когда мы расширяем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)

На этом этапе смешанный подход, очевидно, гораздо более привлекателен.

(Как примечание: я ожидал, что смогу написать простоApplicative.applicative[g.Parser] выше, но это дает ошибку о том, что компилятор не может найти неявное значение дляPure[g.Parser]- хотя кто-то сидит рядом с ним. Ясно, что в способах работы зависимых типов методов есть что-то другое.)

Благодаряретроним для указания на трюк, который выполняет то, что я хочу здесь. Я абстрагировал следующее отего код:

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 в любом расширяющемся объектеParsers, Это вид обмана из-за актеров, но все еще довольно опрятный.