在 Haskell 中管理有状态计算系统

Question

因此，我有一个链接在一起的有状态处理器系统。例如，处理器可能会输出最后 10 个输入的平均值。它需要状态来计算这个平均值。

我想向系统提交值并获取输出。我也想跳回来，恢复过去随时的状态。 IE。我通过系统运行了 1000 个值。现在我想将系统“移”回到发送第 500 个值后的状态。然后我想从那时起再次“重播”系统。

我还需要能够将历史状态保存到磁盘，以便我可以在将来的某个时间再次恢复整个事情（并且仍然可以回退和重播功能）。当然，我需要使用千兆字节的数据来完成此操作，并且速度非常快:)

我一直在使用闭包来保持状态来接近它。但我想知道使用 monad 是否更有意义。我只读过 3 或 4 个 monad 的类比，所以还不太理解它们，所以请随意教育我。

如果每个处理器以保留其历史记录的方式修改其在 monad 中的状态，并且将其与每个处理步骤的 id 绑定在一起。然后，monad 能够以某种方式将其状态切换到过去的步骤 ID，并在该状态下以 monad 运行系统。并且 monad 将具有某种机制来将自身序列化（反序列化）以进行存储。

（考虑到数据的大小......它实际上不应该全部都在内存中，这意味着 monad 需要映射到磁盘、缓存等......）

是否有现有的库/机制/已经完成或协助完成我想做的事情的方法/概念？

Answer 1

所以，我有一个链接在一起的有状态处理器系统。例如，处理器可能会输出最后 10 个输入的平均值。它需要状态来计算这个平均值。

首先，听起来您所拥有的不仅仅是“有状态处理器”，而是类似于有限状态机和/或传感器。这可能是一个很好的研究起点。

我想向系统提交值并获取输出。我也想跳回来，恢复过去随时的状态。 IE。我通过系统运行了 1000 个值。现在我想将系统“移”回到发送第 500 个值后的状态。然后我想再次从该点“重播”系统。

当然，这里最简单的方法是简单地保留所有先前状态的日志。但由于听起来您拥有大量数据，因此所需的存储很容易变得令人望而却步。我建议考虑如何以可以避免这种情况的方式构建处理器，例如：

• 如果可以从前面几步的邻居状态轻松重建处理器的状态，则可以避免直接记录它
• 如果处理器是在某些情况下很容易逆转，您不需要立即记录这些情况；可以直接计算倒带，并且可以将日志记录作为定期快照来完成。
• 如果您可以将处理器固定为非常少量的状态，请务必这样做。
• 如果处理器在某些类型的输入上以非常可预测的方式运行，您可以这样记录——例如，如果它在低于某个截止值的数字输入上空闲，而不是记录每个值，只是记录“空闲 N 个步骤”。

我还需要能够将历史状态保存到磁盘，以便我可以在将来的某个时间再次恢复整个内容（并且仍然可以回退和重播功能）。当然，我需要使用千兆字节的数据来完成此操作，并且速度非常快:)

显式状态是您的朋友。函数是表示活动状态机的便捷方法，但它们不能以任何简单的方式序列化。您希望将（基本上静态的）处理器网络与每个处理器用于计算下一步的一系列内部状态完全分离。

是否已经有一个现有的库/机制/方法/概念来完成我想要做的事情？ monad 方法有意义吗？是否有其他更好/特殊的方法可以帮助它有效地完成此操作，特别是考虑到我必须管理大量数据？

如果您的大多数处理器类似于有限状态传感器，并且您需要拥有接受各种类型的输入并产生不同类型的输出的处理器，那么您可能想要的实际上是 具有基于 Arrows 的结构，它为您提供了组成事物的抽象从某种意义上说，“类似功能”，例如，将一个处理器的输入连接到另一处理器的输出。

此外，只要您避免使用 ArrowApply 类并确保您的状态机模型仅返回输出值和新状态，就可以保证避免隐式状态，因为（与函数不同）< code>箭头不会自动更高阶。

考虑到数据的大小...它实际上不应该全部都在内存中，这意味着 monad 需要映射到磁盘、缓存等...

考虑到处理器网络的静态表示，它应该提供一个增量输入/输出系统来读取数据、序列化/反序列化状态以及写入任何输出也不是太困难。

---

作为一个快速、粗略的起点，下面是我上面概述的可能是最简单版本的示例，暂时忽略日志记录问题：

data Transducer s a b = Transducer { curState :: s
                                   , runStep  :: s -> a -> (s, b)
                                   }

runTransducer :: Transducer s a b -> [a] -> [b]
runTransducer t [] = (t, [])
runTransducer t (x:xs) = let (s, y) = runStep t (curState t) x
                             (t', ys) = runTransducer (t { curState = s }) xs
                         in (t', y:ys)

它是一个简单的通用处理器，具有 s，输入类型为 a，输出类型为 b。 runTransducer 函数推送输入列表，手动更新状态值，并收集输出列表。

---

PS——既然你问的是单子，你可能想知道我给出的例子是否是单子。事实上，它是多个常见单子的组合，尽管具体是哪一个取决于你如何看待它。 但是，我故意避免将其视为单子！问题是，单子仅捕获在某种意义上非常强大的抽象，但同样的能力也使它们在某些方面更能抵抗优化和静态分析。需要排除的主要问题是采用其他处理器作为输入并运行它们的处理器，这（正如您可以想象的）可以创建几乎无法分析的复杂逻辑。

因此，虽然处理器可能是单子，并且在某种逻辑意义上本质上是单子，但假装它们不是单子可能更有用；施加人为限制以使静态分析更简单。