Haskell 梅贝特的伦梅贝特参数

我明白了

然后将

MaybeT

作为单子实例化：

instance Monad m => Monad (MaybeT m) where
  return  = MaybeT . return . Just

  -- The signature of (>>=), specialized to MaybeT m:
  -- (>>=) :: MaybeT m a -> (a -> MaybeT m b) -> MaybeT m b
  x >>= f = MaybeT $ do maybe_value <- runMaybeT x
                        case maybe_value of
                           Nothing    -> return Nothing
                           Just value -> runMaybeT $ f value

instance Monad m=>Monad（MaybeT m）其中
return=MaybeT。返回。只是
--（>>=）的签名，专用于MaybeT m：
--（>>=）：：maybetma->（a->maybetmb）->maybetmb
x>>=f=MaybeT$do maybe\u值不返回任何内容
Just value->runMaybeT$f value

---

我不理解

runMaybeT x

中的arg

x

。

runMaybeT

不应该使用与

a

对应的arg吗？但是它被赋予了

x

，这是整个

MonadT

monad

runMaybeT

是一个getter。它是一个函数，它接受一个

maybetma

对象，并返回一个

m（可能是a）

对象，因此它具有签名

maybetma->m（可能是a）

但是，如果我们使用一种模式来解包值，可能更容易理解：

instance Monad m => Monad (MaybeT m) where
  return  = MaybeT . return . Just
  MaybeT rm >>= f = MaybeT $ do
                        maybe_value <- rm
                        case maybe_value of
                            Nothing -> return Nothing
                            Just value -> runMaybeT $ f value

instance Monad m=>Monad（MaybeT m）其中
return=MaybeT。返回。只是
MaybeT rm>>=f=MaybeT$do
也许你的价值一无所获
Just value->runMaybeT$f value

这只是标准的记录语法。在类型定义中，例如

data Foo = Foo { a :: Int, b :: String }

我们自动获得函数

a:：Foo->Int

和

b:：Foo->String

，这大概不会让您感到惊讶

这与

MaybeT

完全没有区别。（它确实使用了

newtype

而不是

data

，但这在这里并不重要，如果定义使用了

data

，情况也是如此）

这为我们提供了一个函数

runMaybeT:：MaybeT ma->m（可能是a）

，原因与我们在上面的简单示例中得到函数

a

和

b

完全相同。这正是记录语法的作用

特别是在这种情况下，与使用记录语法定义的

newtype

一样，

runMaybeT

函数允许我们“展开”一元值，从抽象的

MaybeT MA

到更“具体”的表示形式，作为

m（可能是a）

类型的值

---

这是在

>=

的

MaybeT m

的实现中使用的：由于它的第一个参数（

x

在您的代码片段中）是

MaybeT ma

类型，我们首先需要

runMaybeT

来获取类型

m（可能是a）

的“unwrapped”值，然后使用“base monad”

m

的

=/code>（这里用
do
符号显示）来“提取”类型
可能是a
的值，然后以通常的方式进行模式匹配。
x
是a
maybetma
，
f
具有类型
a->maybetmb
。
runMaybeT
是一个getter，因此
runmaybetx
将“展开”包装在
MaybeT
数据构造函数中的项。
data Foo = Foo { a :: Int, b :: String }

newtype MaybeT m a = MaybeT { runMaybeT :: m (Maybe a) }