Scala：以功能方式迭代 CSV 文件？

我有 CSV 文件，其中包含给出列名称的注释，其中列在整个文件中发生变化：

#c1,c2,c3
a,b,c
d,e,f
#c4,c5
g,h
i,j

我想提供一种方法来迭代（仅）文件的数据行作为列名到值（所有字符串）的映射。所以上面的内容就变成了：

Map(c1 -> a, c2 -> b, c3 -> c)
Map(c1 -> d, c2 -> e, c3 -> f)
Map(c4 -> g, c5 -> h)
Map(c4 -> i, c5 -> j)

文件非常大，因此无法将所有内容读入内存。现在我有一个Iterator类之间保持一些丑陋的状态hasNext() and next();我还提供了当前行号和实际最后一行的访问器以及读取的注释（以防消费者关心字段顺序）。我想尝试以更实用的方式做事。

我的第一个想法是 for 理解：我可以迭代文件的行，使用过滤子句跳过注释行。我可以yield包含地图、行号等的元组。问题是我需要记住最后看到的列名，以便我可以从中创建地图。 For 循环试图阻止保持状态，这是可以理解的，只让你设置新的vals。我从中学到了这个问题 https://stackoverflow.com/questions/7087353/can-a-scala-for-loop-modify-variables-outside-its-scope我可以更新成员变量yield阻止，但就在那时我don't我想更新它们！

我可以在迭代子句中调用一个更新状态的函数，但这看起来很脏。那么，以函数式风格实现此目的的最佳方法是什么？滥用理解力？黑客scanLeft https://stackoverflow.com/questions/4469538/maintaining-a-state-throughout-a-scala-fold-operation？使用图书馆？拿出来解析器组合器 https://stackoverflow.com/questions/5063022/use-scala-parser-combinator-to-parse-csv-files大枪？或者函数式风格并不能很好地解决这个问题？

状态 Monad FTW！

事实上，我很讨厌 State monad。我花了很长时间写这篇文章，我有一种强烈的感觉，它可以做得更好。特别是，在我看来traverse这是要走的路，但是...

// Get Scalaz on the job
import scalaz._
import Scalaz._

// Some type aliases to make stuff clearer
type Input         = Stream[String]
type Header        = String
type InternalState = (Input, Header)
type Output        = Option[(Header, String)]
type MyState       = State[InternalState, Output]

// Detect headers
def isHeader(line: String) = line(0) == '#'

// From a state, produce an output
def makeLine: (InternalState => Output) = {
    case (head #:: _, _) if isHeader(head) => None
    case (head #:: _, header)              => Some(header -> head)
    case _                                 => None
}

// From a state, produce the next state
def nextLine: (InternalState => InternalState) = {
    case (head #:: tail, _) if isHeader(head) => tail -> head
    case (_ #:: tail, header)                 => tail -> header
    case _                                    => Stream.empty -> ""
}

// My state is defined by the functions producing the next state
// and the output
val myState: MyState = state(s => nextLine(s) -> makeLine(s))    

// Some input to test it. I'm trimming it to avoid problems on REPL
val input = """#c1,c2,c3
a,b,c
d,e,f
#c4,c5
g,h
i,j""".lines.map(_.trim).toStream

// My State/Output Stream -- def to avoid keeping a reference to the head
def stateOutputStream = Stream.iterate(myState(input, "")){ 
        case (s, _) => myState(s) 
    } takeWhile { case ((stream, _), output) => stream.nonEmpty || output.nonEmpty }

// My Output Stream -- flatMap gets rid of the None from the headers
def outputStream = stateOutputStream flatMap { case (_, output) => output }

// Now just get the map
def outputToMap: (Header, String) => Map[String, String] = {
    case (header, line) =>
        val keys = header substring 1 split ","
        val values = line split ","
        keys zip values toMap
}

// And this is the result -- note that I'm still avoiding "val" so memory
// won't leak
def result = outputStream map outputToMap.tupled