Я пытаюсь понять, как реорганизовать программу, которую я раньше написал бы как последовательность переходов состояний:
У меня есть бизнес-логика:
type In = Long
type Count = Int
type Out = Count
type S = Map[Int, Count]
val inputToIn: String => Option[In]
= s => try Some(s.toLong) catch { case _ : Throwable => None }
def transition(in: In): S => (S, Out)
= s => { val n = s.getOrElse(in, 0); (s + (in -> n+1), n+1) }
val ZeroOut: Out = 0
val InitialState: S = Map.empty
С их помощью я хочу создать программу для передачи некоторого начального состояния (пустая карта), чтения ввода из stdin , преобразования его In
, запуска перехода между состояниями и вывода текущего состояния S
и вывода Out
на стандартный вывод .
Раньше я бы сделал что-то вроде этого:
val runOnce = StateT[IO, S, Out](s => IO.readLn.map(inputToIn) flatMap {
case None => IO((s, ZeroOut))
case Some(in) => val (t, o) = transition(in)(s)
IO.putStrLn(t.toString) |+| IO.putStrLn(o.toString) >| IO((t, o))
})
Stream.continually(runOnce).sequenceU.eval(InitialState)
Однако мне действительно сложно понять, как связать этот подход (поток переходов состояний) с scalaz-stream . Я начал с этого:
type Transition = S => (S, Out)
val NoTransition: Transition = s => (s, 0)
io.stdInLines.map(inputToIn).map(_.fold(NoTransition)(transition))
Это типа: Process[Task, Transition]
. Я действительно не знаю, что делать дальше.
- Как мне "передать" мою
InitialState
и запустить программу,S
распределяя вывод на каждом шаге в качестве вводаS
для следующего? - Как мне получить значения
S
иOut
на каждом этапе и распечатать их в стандартный вывод (при условии, что я могу преобразовать их в строки)?
Пытаясь использовать единственное for-понимание, я тоже застреваю:
for {
i <- Process.eval(Task.now(InitialState))
l <- io.stdInLines.map(inputToIn)
...
Любая помощь приветствуется!
У меня теперь немного больше.
type In_ = (S, Option[In])
type Out_ = (S, Out)
val input: Process[Task, In_]
= for {
i <- Process.emit(InitialState)
o <- io.stdInLines.map(inputToIn)
} yield (i, o)
val prog =
input.pipe(process1.collect[In_, Out_]) {
case (s, Some(in)) => transition(in)(s)
}).to(io.stdOutLines.contramap[Out_](_.toString))
потом
prog.run.run
Это не работает: похоже, что состояние не передается через поток. Скорее, на каждом этапе передается начальное состояние.
Пол Кьюзано предложил использовать подход process1.scan
. Итак, теперь я делаю это:
type In_ = In
type Out_ = (S, Out)
val InitialOut_ = (InitialState, ZeroOut)
val program =
io.stdInLines.collect(Function.unlift(inputToIn)).pipe(
process1.scan[In_, Out_](InitialOut_) {
case ((s, _), in) => transition(in)(s)
}).to(io.stdOutLines.contramap[Out_](_.shows))
Здесь есть проблема: в этом конкретном примере мой Out
тип - моноид , поэтому мое начальное состояние может быть создано с использованием его идентификатора, но обычно это может быть не так. Что бы я тогда делал? (Думаю, я мог бы использовать, Option
но это кажется ненужным.)