我正在尝试为我的简单命令式语言解析器编写一个eval函数，但是当我使用 Control.Monad 和 State < / strong>。
在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
答案 0 :(得分：3)
正如Zigmond和Wagner所说，(>>=)是完成这项工作的正确工具。让我们看一下类型：
(>>=) :: m a -> (a -> m b) -> m b
update :: Variable -> Int -> m ()
evalIntExp i :: m Int
v :: Variable
您能想到一种将它们组合为预期类型m ()的方法吗？请记住，您可以部分应用函数以取回需要较少参数的函数。
让我们再次查看类型。
我们有两个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>来检查表达式的类型。
答案 1 :(得分：3)
两件事。
首先，我认为您的更新功能是错误的，因为您两次对同一件事进行模式匹配。为什么不呢？：
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计算结果最终是更新状态或返回() 。因此，您的代码应类似于：
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 v o的意思是：计算evalIntExp i，将得到的Int传递给update函数
此实现返回：
let exp1 = Seq (Seq (Let "string1" (Const 1)) (Let "string2" (Const 2))) Skip
> eval exp1
[("string1",1),("string2",2)]
但在其他示例中失败。