Scala：从标准输入读取时扫描落后一项

Question

如果我用scanLeft 处理来自stdin 的输入，则结果输出总是比我的最后一个输入晚一行：

io.Source.stdin
  .getLines
  .scanLeft("START:")((accu, line) => accu + " " + line)
  .foreach(println(_))

结果（我的手动输入前面是>）：

> first
START:
> second
START: first
> third
START: first second

我想要的合理输出是：

> first
START: first
> second
START: first second
> third
START: first second third

如您所见，第一个输入行之后的输出应该已经包含了第一个输入行的字符串。

我已经尝试过使用.scanLeft(...).drop(1).foreach(...)，但这会导致以下结果：

> first
> second
START: first
> third
START: first second

如何正确省略纯种子以获得所需的结果？

[更新] 目前，我对 Andrey Tyukin 的巧妙解决方法感到满意。非常感谢您的建议。

当然，如果有任何替代 scanLeft 的替代方案不会将种子作为第一项发送到以下迭代链中，我会更喜欢该解决方案。

[更新]

用户 jwvh 了解我的目标并为此提供了出色的解决方案。为了完善他们的建议，我寻求一种在将行发送到累积回调之前对其进行预处理的方法。因此，readLine 命令不应在累积回调中调用，而应在我可以预先添加的不同链链接中调用。

Answer 1

编辑摘要：添加了map 以证明getLines 返回的行的预处理同样简单。

---

您可以将println 移动到scanLeft 本身的主体中，以强制立即执行而没有延迟：

io.Source.stdin
  .getLines
  .scanLeft("START:") {
    (accu, line) => accu + " " + line
    val res = accu + " " + line
    println(res)
    res
  }.foreach{_ => }

但是，这似乎与更短且更直观的foldLeft 的行为完全相同：

io.Source.stdin
  .getLines
  .foldLeft("START:") {
    (accu, line) => accu + " " + line
    val res = accu + " " + line
    println(res)
    res
  }

交互示例：

first
START: first
second
START: first second
third
START: first second third
fourth
START: first second third fourth
fifth
START: first second third fourth fifth
sixth
START: first second third fourth fifth sixth
seventh
START: first second third fourth fifth sixth seventh
end
START: first second third fourth fifth sixth seventh end

---

编辑

您当然可以添加一个map-step 来预处理这些行：

io.Source.stdin
  .getLines
  .map(_.toUpperCase)
  .foldLeft("START:") {
    (accu, line) => accu + " " + line
    val res = accu + " " + line
    println(res)
    res
  }

示例交互（输入小写，打印大写）：

> foo
START: FOO
> bar
START: FOO BAR
> baz
START: FOO BAR BAZ

Answer 2

您可以使用Stream.iterate() 代替scanLeft() 和StdIn.readLine 代替stdin.getLines 获得非常相似的结果。

def input = Stream.iterate("START:"){prev =>
  val next = s"$prev ${io.StdIn.readLine}"
  println(next)
  next
}

由于 Stream 的评估是惰性的，您需要一些方法来实现它。

val inStr = input.takeWhile(! _.contains("quit")).last
START: one                //after input "one"<return>
START: one two            //after input "two"<return>
START: one two brit       //after input "brit"<return>
START: one two brit quit  //after input "quit"<return>
//inStr: String = START: one two brit

---

如果需要，您实际上不必放弃 getLines 迭代器。

def inItr = io.Source.stdin.getLines

def input = Stream.iterate("START:"){prev =>
  val next = s"$prev ${inItr.next}"
  println(next)
  next
}

---

不确定这是否针对您的 cmets。很多取决于可能的错误可能来自哪里以及如何确定。

Stream.iterate(document()){ doc =>
  val line = io.StdIn.readLine  //blocks here
                     .trim
                     .filterNot(_.isControl)
                     //other String or Char manipulations
  doc.update(line)
  /* at this point you have both input line and updated document to play with */
  ... //handle error and logging requirements
  doc //for the next iteration
}

我假设.update() 修改了源文档并且不返回任何内容（返回Unit）。这是update() 方法的常用签名。

其中大部分可以在调用链中完成（_.method1.method2. 等），但有时这只会让事情变得更加复杂。

不返回感兴趣值的方法仍然可以通过使用称为kestrel pattern 的东西添加到调用链中。