重复状态直到它不改变/稳定

Question

我正在尝试重复运行状态转换，直到状态不变。我已经searched Hoogle 为

Eq s => State s () -> State s ()

但没有找到任何看起来合适的东西。

如何重复运行状态转换直到它不改变？

Answer 1

您可以在State 中执行此操作，但没有特别的好处。为什么不：

idempotently :: Eq a => (a -> a) -> a -> a
idempotently f a = if a' == a then a else idempotently f a' where a' = f a

idempotentlyM :: Eq s => (s -> s) -> State s ()
idempotentlyM f = modify (idempotently f)

如果您以State s () 开头，您可以通过execState 来获取您的s -> s。

当然，不能保证f 不会发散，所以idempotently f 可能永远不会终止。

Answer 2

您正在计算状态转换的固定点。 但是我们不能使用fix，因为我们处于一元上下文中。 所以让我们改用一元定点组合器。 输入mfix：

import Control.Monad (unless)
import Control.Monad.State (MonadState, StateT, get, put)
import Control.Monad.Fix (mfix)
import Control.Monad.IO.Class (liftIO)

untilStable :: MonadState s m => (s -> s -> Bool) -> m a -> m ()
untilStable p = mfix $ \f st -> p <$> get <* st <*> get >>= (`unless` f)

我还冒昧地概括了您的函数，以便您可以提供用户提供的二进制谓词。

使用 ghci runState (untilStable (==) $ modify (+1)) 2 将永远不会终止。 但是：

comp :: StateT Int IO ()
comp = do
  s1 <- (+1) <$> get
  liftIO $ print s1
  let s2 = if s1 >= 3 then 3 else s1
  put s2

你得到：

> runStateT (untilStable (==) comp) 0
1
2
3
4
((),3)

这个untilStable可以进一步概括为：

untilStable :: MonadState s m => (s -> s -> Bool) -> m a -> m a
untilStable p = mfix $ \f st -> do
  before <- get
  a <- st
  after  <- get
  if p before after then pure a else f

现在我们已经释放了计算可以产生的类型。

修正你想用fix实现idempotently，你可以这样做：

import Data.Function (fix)

idempotently :: Eq a => (a -> a) -> a -> a
idempotently = fix $ \i f a ->
  let a' = f a
  in if a' == a then a else i f a'

Answer 3

您可以使用get 和unless 滚动您自己的更高级别的递归转换

untilStable :: Eq s => State s () -> State s ()
untilStable stateTransform = do
  before <- get
  stateTransform
  after <- get
  unless (before == after) $ untilStable stateTransform

Answer 4

扩展来自https://stackoverflow.com/a/44381834/1319998 的答案，因此将迭代排除在State 之外，但通过更清晰地使用until 来避免函数monad 魔法

untilStable :: Eq a => (a -> a) -> a -> a
untilStable f a = until (\w -> f w == w) f a

... 并类似地使用 execState 从状态中提取 s -> s

untilStable (execState stateTransformToRunRepeatedly) initialState

没有使用无点样式，但对我来说更清楚发生了什么。

另外，我想知道这是否揭示了 this 和 https://stackoverflow.com/a/44381834/1319998 的效率低下，其中 f a 可能会计算两次：一次在 until 内部私下计算，一次在用于测试是否停止的谓词中。

Answer 5

从https://stackoverflow.com/a/44378096/1319998 和https://stackoverflow.com/a/23924238/1319998 中汲取灵感，您可以在State 之外执行此操作，但使用一些函数单子魔法...

untilStable :: Eq a => (a -> a) -> a -> a
untilStable = until =<< ((==) =<<)

...从使用execState的状态中提取s -> s

untilStable (execState stateTransformToRunRepeatedly) initialState