是否有可能有一个 state-either 混合 monad？

Question

目标

我正在尝试编写解释器的内部结构，并且出于人体工程学的目的，我想我想要一个既像状态又像任一 monad 一样工作的 monad。

例如，我想用其中一种风格做一些事情：

checkedAddress :: Integer -> Interpreter Int
checkedAddress n = if (n < toInteger (minBound :: Int))
                      then fail $ "Address " ++ show n ++ " is too low"
                   else if (n > toInteger (maxBound :: Int))
                      then fail $ "Address " ++ show n ++ " is too high"
                   else return $ fromInteger n

我想用 state 风格做其他事情：

setInstructionPointer :: Int -> Interpreter ()
setInstructionPointer ip (Machine _ mem) = ((), Machine ip mem)

getInstructionPointer :: Interpreter Int
getInstructionPointer m@(Machine ip mem) = (ip, m)

问题

是否可以像这样创建一个 state-either 混合 monad？

如果不可能，为什么不可能？是否有一种替代方案具有良好的人体工程学，并且我认为，提前终止（例如通过 Left m >>= _ = Left m 停止进一步处理）这种方法的效率？

如果可能的话，我该如何编写该类型的 monad 实例？我试过了，但是我在写 (>>=) 时卡住了，因为在不知道运行时 Machine 值的情况下，我无法找到一种方法来知道要生成什么构造函数。

data Interpreter a = Running      (Machine -> (a, Machine))
                   | Halted       (Machine -> Machine)
                   | Error String (Machine -> Machine)

instance Monad Interpreter where
  return = Running . (,)
  Running f     >>= g = DontKnowWhich $ \ m -> let (a, m') = f m
                                               in  case g a of
                                                        Running h ->
                                                        Halted  h ->
                                                        Error s h ->
  h@(Halted  _) >>= _ = h
  e@(Error _ _) >>= _ = e

Answer 1

合并后的 monad 应如下所示：

newtype Interpreter a
  = Interpreter { runInterpreter :: Machine -> (Machine, Either String a) }

它需要一个状态，Machine，returns 修改后的状态，returns 成功或失败。

deriving instance Functor Interpreter
instance Monad Interpreter where
    return x = _exercise
    Interpreter x >>= f = _exercise
instance Applicative Interpreter where pure = return; (<*>) = ap
liftEither :: Either String a -> Interpreter a
liftState :: State Machine a -> Interpreter a

一般来说，要将 monad 放在一起，您可以将一个 "inside" 另一个：

Interpreter a <~> State Machine (Either String a)

你可以用另一种方式来做，s -> Either String (s, a)，但是这样你就不会在出错时恢复状态。（请注意，Either String (State Machine a) 不起作用：是否失败将不允许取决于状态。它只是一个 Applicative。）

您不必自己编写 Monad Interpreter 实例。 transformers 包（与 GHC 一起提供）提供 "monad transformers" 用于组合构建 monad。一个 monad 转换器是一个 T :: (Type -> Type) -> (Type -> Type) 以一个 monad 作为参数并且 returns 一个新的 monad。

type Interpreter = <a href="https://hackage.haskell.org/package/transformers-0.5.6.2/docs/Control-Monad-Trans-Except.html#t:ExceptT" rel="noreferrer">ExceptT</a> String (<a href="https://hackage.haskell.org/package/transformers-0.5.6.2/docs/Control-Monad-Trans-State-Lazy.html#t:State" rel="noreferrer">State</a> Machine)
liftEither = <a href="https://hackage.haskell.org/package/transformers-0.5.6.2/docs/Control-Monad-Trans-Except.html#v:except" rel="noreferrer">except</a>
liftState = <a href="https://hackage.haskell.org/package/transformers-0.5.6.2/docs/Control-Monad-Trans-Class.html#v:lift" rel="noreferrer">lift</a>

ExceptT String是一个monad转换器，State Machine是一个monad，所以Interpreter = ExceptT String (State Machine)也是一个monad。我之前提到的另一种方式是 StateT Machine (Either String).

下一步是使用mtl。这个库在 transformer 类型之上提供了类，这样像 throwError 和 get 这样的特定于 monad 的动作就会被重载，以根据需要自动提升自己通过尽可能多的 monad 转换器。使用 mtl，您可以在 monad 堆栈中保留您自己的多态函数：

checkedAddress :: MonadExcept String m => Integer -> m Int
checkedAddress n = do
  -- you don't need to branch, failure short-circuits!
  when (n < toInteger (minBound :: Int)) $ <a href="https://hackage.haskell.org/package/mtl-2.2.2/docs/Control-Monad-Except.html#v:throwError" rel="noreferrer">throwError</a> _
  when (n > toInteger (maxBound :: Int)) $ throwError _
  pure (fromInteger n)

setInstructionPointer :: MonadState Machine m => Int -> m ()
setInstructionPointer ip = <a href="https://hackage.haskell.org/package/mtl-2.2.2/docs/Control-Monad-State-Lazy.html#v:modify" rel="noreferrer">modify</a> \(Machine _ mem) -> (Machine ip mem)

getInstructionPointer :: MonadState Machine m => m Int
getInstructionPointer = <a href="https://hackage.haskell.org/package/mtl-2.2.2/docs/Control-Monad-State-Lazy.html#v:gets" rel="noreferrer">gets</a> \(Machine i _) -> i

-- combined:
checkedOffsetJump :: (MonadState Machine m, MonadExcept String m) => Integer -> m ()
checkedOffsetJump off = setInstructionPointer =<< checkedAddress =<< (off +) <$> toInteger <$> getInstructionPointer
-- read: setInstructionPointer(checkedAddress(off + toInteger(getInstructionPointer())))

您可以稍后确定它们，通常是在最后：

<a href="https://hackage.haskell.org/package/transformers-0.5.6.2/docs/Control-Monad-Trans-State-Lazy.html#v:runState" rel="noreferrer">runState</a> $ <a href="https://hackage.haskell.org/package/transformers-0.5.6.2/docs/Control-Monad-Trans-Except.html#v:runExceptT" rel="noreferrer">runExceptT</a> $ checkedOffsetJump 0x8000 :: Machine -> (Either String (), Machine)

是否有可能有一个 state-either 混合 monad？

Is it possible to have a state-either hybrid monad?

haskell

monads

state-monad

either

目标

问题