Question

我正在研究Scala中的函数式编程的第9章（Paul Chiusano和RúnarBjarnason撰写的有关Manning的书籍）。本章中有一些内联示例，例如在练习9.1之后提供的以下示例：

char('a').many.slice.map(_.size) ** char('b').many1.slice.map(_.size)

到目前为止，已经实现了方法，因此我无法在scala repl中运行此示例。可以找到代码here。

我执行了以下操作来启动副本：

./sbt
> ~exercises/console
scala> import fpinscala.parsing._

仅运行char('a')会给我以下错误：

scala> char('a')
<console>:18: error: not found: value char
       char('a')
       ^

我是scala的新手，所以我可能错过了一些东西。我是否应该能够在repl上使用类似特征运行方法？如果是这样，我想念什么？在其他各章中，我试图尽快修改代码，以便对概念有所了解并尝试使用API。但是，目前我无法运行最简单的内联示例。

Answer 1

几乎整个章节的类型参数Parser[+_]都是抽象的。仅在练习9.12中，您才应该尝试提出自己的实现，并且仅在9.6.2中提供了可能的解决方案。

在此之前，如果要尝试针对某些类型Parser[A]生成A的方法，请尝试几种方法：

将它们直接添加到Parsers特性中。在那里，您可以使用所有其他方法，例如char。
在所有可能的类型构造函数Parser[+_]上参数化代码，如9.4第158页所示。本节以免责声明开始，即“我们还没有代数的实现” ，但这不是必需的，因为假定实现是一个稍后将提供的参数：< / p>
```
def jsonParser[Err, Parser[+_]](P: Parsers[Err, Parser]): Parser[JSON] = {
  import P._ // now `char` is available.
  ???
}
```
这与您的代码一起使用：
```
def myParser[P[+_]](P: Parsers[P]) = {
  import P._
  char('a').many.slice.map(_.size) **
  char('b').many1.slice.map(_.size)
}
```

或者，将Parsers扩展另一个特征，仍然保留Parser[+_]抽象：

trait MyParser[Parser[+_]] extends Parsers[Parser] {
  def ab = 
    char('a').many.slice.map(_.size) **
    char('b').many1.slice.map(_.size)
}

这是您自己的代码，其中有两个绝对可以编译的示例：

import language.higherKinds
import language.implicitConversions 

trait Parsers[Parser[+_]] { self => // so inner classes may call methods of trait
  def run[A](p: Parser[A])(input: String): Either[ParseError,A]

  implicit def string(s: String): Parser[String]
  implicit def operators[A](p: Parser[A]) = ParserOps[A](p)
  implicit def asStringParser[A](a: A)(implicit f: A => Parser[String]):
    ParserOps[String] = ParserOps(f(a))

  def char(c: Char): Parser[Char] =
    string(c.toString) map (_.charAt(0))

  def or[A](s1: Parser[A], s2: Parser[A]): Parser[A]
  def listOfN[A](n: Int, p: Parser[A]): Parser[List[A]]

  def many[A](p: Parser[A]): Parser[List[A]]
  def slice[A](p: Parser[A]): Parser[String]

  def many1[A](p: Parser[A]): Parser[List[A]] =
    map2(p, many(p))(_ :: _)


  def product[A,B](p: Parser[A], p2: Parser[B]): Parser[(A,B)]

  def map[A,B](a: Parser[A])(f: A => B): Parser[B]

  def map2[A,B,C](p: Parser[A], p2: Parser[B])(f: (A,B) => C): Parser[C] =
    map(product(p, p2))(f.tupled)


  def succeed[A](a: A): Parser[A] =
    string("") map (_ => a)

  case class ParserOps[A](p: Parser[A]) {
    def |[B>:A](p2: Parser[B]): Parser[B] = self.or(p,p2)
    def or[B>:A](p2: => Parser[B]): Parser[B] = self.or(p,p2)
    def many = self.many(p)

    def map[B](f: A => B): Parser[B] = self.map(p)(f)

    def slice: Parser[String] = self.slice(p)
    def many1: Parser[List[A]] = self.many1(p)

    def **[B](p2: => Parser[B]): Parser[(A,B)] =
      self.product(p,p2)

    def product[A,B](p: Parser[A], p2: Parser[B]): Parser[(A,B)] = self.product(p, p2)
    def map2[A,B,C](p: Parser[A], p2: Parser[B])(f: (A,B) => C): Parser[C] = self.map2(p, p2)(f)
  }

}

case class Location(input: String, offset: Int = 0) {

  lazy val line = input.slice(0,offset+1).count(_ == '\n') + 1
  lazy val col = input.slice(0,offset+1).reverse.indexOf('\n')

  def toError(msg: String): ParseError =
    ParseError(List((this, msg)))

  def advanceBy(n: Int) = copy(offset = offset+n)

  /* Returns the line corresponding to this location */
  def currentLine: String = 
    if (input.length > 1) input.lines.drop(line-1).next
    else ""
}

case class ParseError(stack: List[(Location,String)] = List(),
                      otherFailures: List[ParseError] = List()) {
}

object Parsers {

}

def myParser[P[+_]](P: Parsers[P]) = {
  import P._
  char('a').many.slice.map(_.size) **
  char('b').many1.slice.map(_.size)
}

trait MyParser[P[+_]] extends Parsers[P] {
  def ab = 
    char('a').many.slice.map(_.size) **
    char('b').many1.slice.map(_.size)
}

请注意，ParserOps已被修改：您在几种方法中具有冗余参数A和p。

Scala中的Functional Programming一书：如何运行第9章中的内联示例？

1 个答案: