如何编写一个可以进行错误处理的状态单子？

Question

我需要编写一个也可以支持错误处理的状态单子。我正在考虑使用 Either monad 来实现此目的，因为它还可以提供有关导致错误的原因的详细信息。我使用 Maybe monad 找到了状态 monad 的定义，但是我无法修改它以使用 Either，而不是 Maybe。这是代码：

newtype StateMonad a = StateMonad (State -> Maybe (a, State))

instance Monad StateMonad where
(StateMonad p) >>= k = StateMonad (\s0 -> case p s0 of 
                                 Just (val, s1) -> let (StateMonad q) = k val in q s1
                                 Nothing -> Nothing)
return a = StateMonad (\s -> Just (a,s))

data State = State
{ log  :: String
, a    :: Int}

Answer 1

考虑使用 Control.Monad.Trans.Except 中的 ExceptT （而不是使用 Either）。

import Control.Monad.State
import Control.Monad.Trans.Except
import Control.Monad.Identity

data MyState = S

type MyMonadT e m a = StateT MyState (ExceptT e m) a

runMyMonadT :: (Monad m) => MyMonadT e m a -> MyState -> m (Either e a)
runMyMonadT m = runExceptT . evalStateT m

type MyMonad e a = MyMonadT e Identity a
runMyMonad m = runIdentity . runMyMonadT m

如果您对 Monad 和 Monad 转换器感到不舒服，那么我会先这样做！它们对程序员的生产力和性能提升有巨大的帮助。

Answer 2

有两种可能的解决方案。与您上面提供的代码最接近的一个是：

newtype StateMonad e a = StateMonad (State -> Either e (a, State))

instance Monad (StateMonad e) where
    (StateMonad p) >>= k =
        StateMonad $ \s0 ->
            case p s0 of
                Right (val, s1) ->
                    let (StateMonad q) = k val
                     in q s1
                Left e -> Left e
    return a = StateMonad $ \s -> Right (a, s)

data State = State
    { log  :: String
    , a    :: Int
    }

另一种形式将错误处理移至状态处理中：

newtype StateMonad e a = StateMonad (State -> (Either e a, State))

instance Monad (StateMonad e) where
    (StateMonad p) >>= k =
        StateMonad $ \s0 ->
            case p s0 of
                (Right val, s1) ->
                    let (StateMonad q) = k val
                     in q s1
                (Left e, s1) -> (Left e, s1)
    return a = StateMonad $ \s -> (Right a, s)

data State = State
    { log  :: String
    , a    :: Int
    }

Answer 3

你需要一个 monad 转换器。 Monad 转换器库，例如 mtl 允许您组合不同的 monad 来制作新版本。使用 mtl，您可以定义

type StateMonad e a = StateT State (Either e) a

允许您访问 StateMonad 中的状态和错误处理。

Answer 4

我没有看到这里有人提到这篇论文 Monad Transformers Step by Step by Martin Grabmüller

我发现它对于学习组合 monad 非常有帮助。

Answer 5

的例子

type StateMonad e a = StateT State (Either e) a

刚刚看到了像and 之类

type MyMonadT e m a = StateT MyState (ExceptT e m) a

，但据我了解，如果出现错误，您将丢失状态，因为在这里您在 Either/Except 中添加状态，因此状态只能在 Right 中访问。
如果您需要处理错误并获取状态（截至错误发生时刻计算的状态），您可以使用 ExceptT e (State s) 堆栈：

type StateExcept e s a = ExceptT e (State s) a

test :: Int -> StateExcept String String ()
test limit =  do
    modify (succ . head >>= (:)) -- takes first char from state and adds next one in alphabet to state
    s <- get
    when (length s == limit) (throwError $ "State reached limit of " ++ show limit)

runTest :: ExceptT String (State String) () -> (Either String (), [Char])
runTest se = runState (runExceptT se) "a"


λ: runTest (forever $ test 4)
(Left "State reached limit of 4","dcba")
λ: runTest (replicateM_ 2 $ test 4)
(Right (),"cba")

Answer 6

您始终可以使用内部带有 State monad 的 ErrorT monad 转换器（反之亦然）。
查看所有关于 monad 的转换器部分。

哈特哈，