从Monad状态上下文中解包值并连接两个状态上下文

Question

我试图为我的简单命令式语言解析器编写一个eval函数，但是当我使用Control.Monad和State编写它时，我遇到了一些问题。

在evalComm 让我需要打开类型（ m Int ）以仅传递Int来更新函数，有没有办法做到这一点？

同样在evalComm的Seq情况下 ，当递归以两种方式打开时，我需要连接两个evalComm函数。 在这种情况下， liftM可以替代？

type Env = [(Variable,Int)]

initState :: Env
initState = []

newtype State a = State { runState :: Env -> (a, Env) }

instance Monad State where
    return x = State (\s -> (x, s))
    m >>= f = State (\s -> let (v, s') = runState m s in
                           runState (f v) s')

instance Functor State where
    fmap = liftM

instance Applicative State where
    pure   = return
    (<*>)  = ap      

class Monad m => MonadState m where
    lookfor :: Variable -> m Int
    update :: Variable -> Int -> m ()

instance MonadState State where
    lookfor v = State (\s -> (lookfor' v s, s))
                where lookfor' v ((u, j):ss) | v == u = j
                                             | v /= u = lookfor' v ss
    update v i = State (\s -> ((), update' v i s))
                 where update' v i [] = [(v, i)]
                       update' v i ((u, _):ss) | v == u = (v, i):ss
                       update' v i ((u, j):ss) | v /= u = (u, j):(update' v i ss)

eval :: Comm -> Env
eval p = snd (runState (evalComm p) initState)

evalComm :: MonadState m => Comm -> m ()
evalComm c = case c of
                  Skip          -> return ()
                  Let v i       -> update v (evalIntExp i)
                  Seq c1 c2     -> return (liftM2 (:) (evalComm c2) (evalComm c1))

evalIntExp :: MonadState m => IntExp -> m Int
evalIntExp v = case v of
                    Const x             -> return (fromInteger x)
                    Var x               -> lookfor x
                    UMinus x            -> liftM (*(-1)) (evalIntExp x)
                    Plus x y            -> liftM2 (+) (evalIntExp x) (evalIntExp y)
                    Minus x y           -> liftM2 (-) (evalIntExp x) (evalIntExp y)
                    Times x y           -> liftM2 (*) (evalIntExp x) (evalIntExp y)
                    Div x y             -> liftM2 div (evalIntExp x) (evalIntExp y)


evalBoolExp :: MonadState m => BoolExp -> m Bool
evalBoolExp b = case b of
                     BTrue        -> return True
                     BFalse       -> return False
                     Eq x y       -> liftM2 (==) (evalIntExp x) (evalIntExp y)
                     Lt x y       -> liftM2 (<) (evalIntExp x) (evalIntExp y)
                     Gt x y       -> liftM2 (>) (evalIntExp x) (evalIntExp y)
                     And b0 b1    -> liftM2 (&&) (evalBoolExp b0) (evalBoolExp b1)
                     Or b0 b1     -> liftM2 (||) (evalBoolExp b0) (evalBoolExp b1)
                     Not b        -> liftM not (evalBoolExp b)

请注意，evalComm的代码不起作用，并且可能不正确。

这是我的抽象语法树：

type Variable = String

data IntExp = Const Integer
            | Var Variable
            | UMinus IntExp
            | Plus IntExp IntExp
            | Minus IntExp IntExp
            | Times IntExp IntExp
            | Div IntExp IntExp
            | Quest BoolExp IntExp IntExp
 deriving Show

data BoolExp = BTrue
             | BFalse
             | Eq IntExp IntExp
             | Lt IntExp IntExp
             | Gt IntExp IntExp
             | And BoolExp BoolExp
             | Or BoolExp BoolExp
             | Not BoolExp
 deriving Show

data Comm = Skip
          | Let Variable IntExp
          | Seq Comm Comm
          | Cond BoolExp Comm Comm
          | While BoolExp Comm
          | Repeat Comm BoolExp
 deriving Show

Answer 1

让事例

正如Zigmond和Wagner所说， (>>=)是完成这项工作的正确工具。 让我们看一下类型：

(>>=) :: m a -> (a -> m b) -> m b
update :: Variable -> Int -> m ()
evalIntExp i :: m Int
v :: Variable

您能想到一种将它们组合为预期类型m ()吗？ 请记住，您可以部分应用函数以取回需要较少参数的函数。

Seq情况

让我们再次查看类型。

我们有两个类型为m ()值（ evalComm c1和evalComm c2 ），并希望将它们组合成一个类型为m ()的值。 我们可以通过创建一个忽略其参数的函数来再次使用>>= ：

Seq c1 c2  -> (evalComm c1) >>= (\x -> (evalComm c1))

但是，这是一种常见的情况，因此已经有一个内置函数：

(>>) :: m a -> m b -> m b

Seq c1 c2  -> evalComm c1 >> evalComm c1

---

让我们看看您之前的代码

liftM2 (:) :: m a -> m [a] -> m [a]

您没有列表，因此没有用。

liftM2 :: (a -> b -> c) -> m a -> m b -> m c

如果a = b = c = ()可以使用它，但是与仅使用>>相比，它不必要地复杂。 但是，我鼓励您尝试一下作为练习。 类型() -> () -> ()的函数的外观如何？

return :: a -> m a

当您有一个纯值并且需要将其转换为单价时，可以使用此函数，因此无需在此处使用它。 结果将具有双重包装类型m (m ()) ，这不是您想要的类型。

最后的话

如您所见，在编写Haskell程序时，这些类型非常有用。 每当您想知道可以将哪些内容组合在一起时，请查看它们的类型。 您可以通过在GHCi中键入:t <expression>来检查表达式的类型。

Answer 2

两件事情。

首先，我认为您的更新功能是错误的，因为您两次对同一件事进行模式匹配。 为什么不？：

update v i = State (\s -> ((), update' v i s))
             where update' v i [] = [(v, i)]
                   update' v i ((u, j):ss) | v == u = (v, i):ss
                                           | v /= u = (u, j):(update' v i ss)

此更新功能正在创建对列表。 正如@Hjulle发布的那样，使用>>运算符将执行以下操作： 计算第一个结果，然后计算第二个结果 。 在这种情况下，使用evalComm计算结果最终将更新状态或return () 。 因此，您的代码应类似于：

evalComm :: MonadState m => Comm -> m ()
evalComm c = case c of
                  Skip          -> return ()
                  Let v i       -> evalIntExp i >>= \o -> update v o
                  Seq c1 c2     -> evalComm c1 >> evalComm c2

evalIntExp i >>= \\o -> update vo意思是： 计算evalIntExp i ，将得到的Int传递给update函数

此实现返回：

let exp1 = Seq (Seq (Let "string1" (Const 1)) (Let "string2" (Const 2))) Skip 

> eval exp1
[("string1",1),("string2",2)]

但在其他示例中失败。