我实际上会倒着做这个问题：我将从一元解决方案开始，然后从它倒退到手动解决方案。如果您手动找到正确的解决方案，这将产生相同的代码。
一元解析器的典型类型签名是这样的：
type Parser a = String -> Maybe (a, String)
请注意与您的表单的细微差别，您在Maybe 的外部有最后的String。两者都有效，但我更喜欢这种形式，因为如果解析失败，我认为剩余的 String 无效。
这个类型其实是StateT的特例，定义为：
newtype StateT s m a = StateT { runStateT :: s -> m (a, s) }
请注意，如果我们选择：
s = String
m = Maybe
...我们返回 Parser 类型：
type Parser a = StateT String Maybe a
-- or: type Parser = StateT String Maybe
这很酷的是我们只需要手动定义一个解析器，也就是检索单个字符的解析器：
anyChar :: Parser Char
anyChar = StateT $ \str -> case str of
[] -> Nothing
c:cs -> Just (c, cs)
请注意，如果我们删除 StateT 包装器，anyChar 的类型将是：
anyChar :: String -> Maybe (Char, String)
当我们将它包裹在StateT 中时，它变成：
anyChar :: StateT String Maybe Char
...就是Parser Char。
一旦我们有了原始解析器，我们就可以使用StateT 的Monad 接口定义所有其他解析器。例如，让我们定义一个匹配单个字符的解析器：
import Control.Monad
char :: Char -> Parser ()
char c' = do
c <- anyChar
guard (c == c')
这很容易！ guard 需要我们的 monad 的 MonadPlus 实例，但我们已经有了一个。之所以会这样，要归功于以下两个MonadPlus实例：
instance (MonadPlus m) => MonadPlus (StateT s m) where ...
instance MonadPlus Maybe where ...
这两个实例的组合意味着StateT s Maybe自动实现MonadPlus，所以我们可以使用guard，它会神奇地做“正确的事”。
有了这两个解析器，你的最终解析器就变得很容易编写了：
data Wff = Or Char Char deriving (Show)
parseWff :: Parser Wff
parseWff = do
char '['
a <- anyChar
char '|'
b <- anyChar
char ']'
return (Or a b)
这更清楚，更容易理解发生了什么。它也有效：
>>> runStateT parseWff "[A|B]"
Just (Or 'A' 'B',"")
向后工作
这将我们带到您最初的问题：您如何手写相同的行为？我们将从Monad 和MonadPlus 实例向后推导它们在幕后为我们做了什么。
为此，我们必须推断StateT 的Monad 和MonadPlus 实例在其基本单子为Maybe 时会减少什么。让我们从StateT 的Monad 实例开始：
instance (Monad m) => Monad (StateT s m) where
return r = StateT (\s -> return (r, s))
m >>= f = StateT $ \s0 -> do
(a, s1) <- runStateT m s0
runStateT (f a) s1
请注意，它是在基本 monad 的一般术语中定义的。这意味着我们还需要 Maybe 的 Monad 实例来派生上述代码的作用：
instance Monad Maybe where
return = Just
m >>= f = case m of
Nothing -> Nothing
Just a -> f a
如果我们将 Maybe monad 实例替换为 StateT monad 实例，我们会得到：
instance Monad (StateT s Maybe) where
return r = StateT (\s -> Just (r, s))
m >>= f = StateT $ \s0 -> case runStateT m s0 of
Nothing -> Nothing
Just (a, s1) -> runStateT (f a) s1
我们可以做同样的事情来为StateT s Maybe 派生Monad 实例。我们只需要为StateT 和`Maybe:
获取
MonadPlus 实例
instance (MonadPlus m) => MonadPlus (StateT s m) where
mzero = StateT (\_ -> mzero)
mplus (StateT f) (StateT g) = StateT (\s -> mplus (f s) (g s))
instance MonadPlus Maybe where
mzero = Nothing
mplus m1 m2 = case m1 of
Just a -> Just a
Nothing -> case m2 of
Just b -> Just b
Nothing -> Nothing
...并将它们合二为一：
instance MonadPlus (StateT s Maybe) where
mzero = StateT (\_ -> Nothing)
mplus (StateT f) (StateT g) = StateT $ \s -> case f s of
Just a -> Just a
Nothing -> case g s of
Just b -> Just b
Nothing -> Nothing
现在我们可以推导出解析器在幕后所做的事情。让我们从char 解析器开始：
char c' = do
c <- anyChar
guard (c == c')
这意味着：
char c' = anyChar >>= \c -> guard (c == c')
我们刚刚导出了 (>>=) 对 StateT s Maybe 所做的事情，所以让我们将其替换为：
char c' = StateT $ \str0 -> case runStateT anyChar str0 of
Nothing -> Nothing
Just (a, str1) -> runStateT ((\c -> guard (c == c')) a) str1
我们已经知道anyChar 的定义，所以我们将其替换为：
char c' = StateT $ \str0 -> case runStateT (StateT $ \str -> case str of
[] -> Nothing
c:cs -> Just (c, cs) ) str0 of
Nothing -> Nothing
Just (a, str1) -> runStateT ((\c -> guard (c == c')) a) str1
我们也知道runStateT是StateT的倒数，所以：
char c' = StateT $ \str0 -> case (\str -> case str of
[] -> Nothing
c:cs -> Just (c, cs) ) str0 of
Nothing -> Nothing
Just (a, str1) -> runStateT ((\c -> guard (c == c')) a) str1
然后我们可以将 lambda 应用到str0：
char c' = StateT $ \str0 -> case (case str0 of
[] -> Nothing
c:cs -> Just (c, cs) ) of
Nothing -> Nothing
Just (a, str1) -> runStateT ((\c -> guard (c == c')) a) str1
现在我们将外部 case 语句分布在内部 case 语句之上：
char c' = StateT $ \str0 -> case str0 of
[] -> case Nothing of
Nothing -> Nothing
Just (a, str1) -> runStateT ((\c -> guard (c == c')) a) str1
c:cs -> case Just (c, cs) of
Nothing -> Nothing
Just (a, str1) -> runStateT ((\c -> guard (c == c')) a) str1
...并评估案例陈述：
char c' = StateT $ \str0 -> case str0 of
[] -> Nothing
c:cs -> runStateT ((\c -> guard (c == c')) c) cs
然后我们可以将 lambda 应用到c：
char c' = StateT $ \str0 -> case str0 of
[] -> Nothing
c:cs -> runStateT (guard (c == c')) cs
为了进一步简化，我们需要知道guard 做了什么。这是它的源代码：
guard pred = if pred then return () else mzero
我们已经知道StateT s Maybe 的return 和mzero 是什么，所以让我们将它们替换为：
guard pred = if pred then StateT (\s -> Just ((), s)) else StateT (\_ -> Nothing)
现在我们可以将它内联到我们的函数中：
char c' = StateT $ \str0 -> case str0 of
[] -> Nothing
c:cs -> runStateT (if (c == c')
then StateT (\s -> Just ((), s))
else StateT (\_ -> Nothing) ) cs
如果我们在上面分发runStateT，我们会得到：
char c' = StateT $ \str0 -> case str0 of
[] -> Nothing
c:cs -> (if (c == c')
then (\s -> Just ((), s))
else (\_ -> Nothing) ) cs
同样，我们可以将两个分支都应用到cs：
char c' = StateT $ \str0 -> case str0 of
[] -> Nothing
c:cs -> if (c == c') then Just ((), cs) else Nothing
如果我们根本不使用 Monad 或 MonadPlus 实例，这就是我们手动编写的等效代码。
最终解析器
我现在将对最后一个函数重复此过程，但将推导留作练习：
parseWff = do
char '['
a <- anyChar
char '|'
b <- anyChar
char ']'
return (Or a b)
parseWff = StateT $ \str0 -> case str0 of
[] -> Nothing
c1:str1 -> if (c1 == '[')
then case str1 of
[] -> Nothing
c2:str2 -> case str2 of
[] -> Nothing
c3:str3 -> if (c3 == '|')
then case str3 of
[] -> Nothing
c4:str4 -> case str4 of
[] -> Nothing
c5:str5 -> if (c5 == ']')
then Just (Or c2 c4, str5)
else Nothing
else Nothing
else Nothing
...但我们可以进一步简化为：
parseWff = StateT $ \str0 -> case str0 of
'[':c2:'|':c4:']':str5 -> Just (Or c2 c4, str5)
_ -> Nothing
请注意，与您编写的函数不同，它不使用任何部分函数，例如 tail 或不完整的模式匹配。此外，您编写的代码无法编译，但即使编译了，它仍然会给出错误的行为。