使用 Scalaz Stream 解析任务（替换 Scalaz Iteratees）

Question

简介

我在许多项目中使用Scalaz 7 的迭代器，主要用于处理大型文件。我想开始切换到 Scalaz streams，它旨在替换 iteratee 包（坦率地说，它缺少很多部分，使用起来有点痛苦）。

Streams 基于 machines（迭代思想的另一个变体），在 Haskell 中有 also been implemented。我使用了一点 Haskell 机器库，但是机器和流之间的关系并不完全明显（至少对我而言），流库的文档是 still a little sparse。

这个问题是关于一个简单的解析任务，我希望看到它使用流而不是迭代器来实现。如果没有其他人超过我，我会自己回答这个问题，但我确信我不是唯一一个正在进行（或至少考虑）这种转变的人，因为无论如何我都需要完成这个练习，我我想我不妨在公共场合这样做。

任务

假设我有一个文件，其中包含已标记化并用词性标记的句子：

no UH
, ,
it PRP
was VBD
n't RB
monday NNP
. .

the DT
equity NN
market NN
was VBD
illiquid JJ
. .

每行一个记号，单词和词性用一个空格隔开，空行代表句子边界。我想解析这个文件并返回一个句子列表，我们不妨将其表示为字符串元组的列表：

List((no,UH), (,,,), (it,PRP), (was,VBD), (n't,RB), (monday,NNP), (.,.))
List((the,DT), (equity,NN), (market,NN), (was,VBD), (illiquid,JJ), (.,.)

像往常一样，我们希望在遇到无效输入或文件读取异常时优雅地失败，我们不想担心手动关闭资源等。

迭代解决方案

首先是一些通用的文件读取内容（它确实应该是 iteratee 包的一部分，它目前不提供任何远程这个高级别的东西）：

import java.io.{ BufferedReader, File, FileReader }
import scalaz._, Scalaz._, effect.IO
import iteratee.{ Iteratee => I, _ }

type ErrorOr[A] = EitherT[IO, Throwable, A]

def tryIO[A, B](action: IO[B]) = I.iterateeT[A, ErrorOr, B](
  EitherT(action.catchLeft).map(I.sdone(_, I.emptyInput))
)

def enumBuffered(r: => BufferedReader) = new EnumeratorT[String, ErrorOr] {
  lazy val reader = r
  def apply[A] = (s: StepT[String, ErrorOr, A]) => s.mapCont(k =>
    tryIO(IO(Option(reader.readLine))).flatMap {
      case None       => s.pointI
      case Some(line) => k(I.elInput(line)) >>== apply[A]
    }
  )
}

def enumFile(f: File) = new EnumeratorT[String, ErrorOr] {
  def apply[A] = (s: StepT[String, ErrorOr, A]) => tryIO(
    IO(new BufferedReader(new FileReader(f)))
  ).flatMap(reader => I.iterateeT[String, ErrorOr, A](
    EitherT(
      enumBuffered(reader).apply(s).value.run.ensuring(IO(reader.close()))
    )
  ))
}

然后是我们的句子阅读器：

def sentence: IterateeT[String, ErrorOr, List[(String, String)]] = {
  import I._

  def loop(acc: List[(String, String)])(s: Input[String]):
    IterateeT[String, ErrorOr, List[(String, String)]] = s(
    el = _.trim.split(" ") match {
      case Array(form, pos) => cont(loop(acc :+ (form, pos)))
      case Array("")        => cont(done(acc, _))
      case pieces           =>
        val throwable: Throwable = new Exception(
          "Invalid line: %s!".format(pieces.mkString(" "))
        )

        val error: ErrorOr[List[(String, String)]] = EitherT.left(
          throwable.point[IO]
        )

        IterateeT.IterateeTMonadTrans[String].liftM(error)
    },
    empty = cont(loop(acc)),
    eof = done(acc, eofInput)
  )
  cont(loop(Nil))
}

最后是我们的解析动作：

val action =
  I.consume[List[(String, String)], ErrorOr, List] %=
  sentence.sequenceI &=
  enumFile(new File("example.txt"))

我们可以证明它有效：

scala> action.run.run.unsafePerformIO().foreach(_.foreach(println))
List((no,UH), (,,,), (it,PRP), (was,VBD), (n't,RB), (monday,NNP), (.,.))
List((the,DT), (equity,NN), (market,NN), (was,VBD), (illiquid,JJ), (.,.))

我们已经完成了。

我想要什么

使用 Scalaz 流而不是迭代器实现的程序或多或少是相同的。

Answer 1

scalaz-stream 解决方案：

import scalaz.std.vector._
import scalaz.syntax.traverse._
import scalaz.std.string._

val action = linesR("example.txt").map(_.trim).
  splitOn("").flatMap(_.traverseU { s => s.split(" ") match {
    case Array(form, pos) => emit(form -> pos)
    case _ => fail(new Exception(s"Invalid input $s"))
  }})

我们可以证明它有效：

scala> action.collect.attempt.run.foreach(_.foreach(println))
Vector((no,UH), (,,,), (it,PRP), (was,VBD), (n't,RB), (monday,NNP), (.,.))
Vector((the,DT), (equity,NN), (market,NN), (was,VBD), (illiquid,JJ), (.,.))

我们完成了。

traverseU 函数是一个常见的 Scalaz 组合子。在这种情况下，它被用来在Process monad 中遍历splitOn 生成的句子Vector。相当于map 后跟sequence。