Haskell MaybeT计算中的类型

在一个IO计算中，我最终得到了一个

case mbValue为…

s的阶梯，并发现我应该使用

Maybe

monad来简化代码。因为它在

IO

计算中，我需要得到

IO

值，所以我使用了

MaybeT

monad转换器，这样我就可以

将
IO
计算提升到
Maybe

现在，我一直认为在一个
值之后，值被“剥离”了
可能
的属性。简言之：用
MaybeT
构造函数替换
lift

注意

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

及

在中使用
lift

x <- lift lol

这就是为什么
x
将再次成为
可能是Int
。
lift
添加了一个新的
MaybeT
层，该层独立于您已有的
Maybe
事件

但是

相反，就像

x <- MaybeT lol

做正确的事。
当专门用于
MaybeT
，
lift:：Monad m=>ma->MaybeT ma
。由于
lol:：IO（可能是Int）
，
m
是
IO
，
a
是
可能是Int
，因此
提升lol:：MaybeT IO（可能是Int）

IO（maybea a）
只是
maybetio a
newtype包装中包含的值，因此无需提起它；而是使用
MaybeT
构造函数，例如在
MaybeT lol
中

但这不是人们倾向于使用单子变压器的方式。相反，只需使用
MaybeT
值并根据需要提升：

import Control.Monad
import Control.Monad.Trans (lift)
import Control.Monad.Trans.Maybe (runMaybeT, MaybeT)

lol :: MaybeT IO Int
lol = return 3

lal :: MaybeT IO String
lal = return "8"

foo :: IO (Maybe Bool)
foo = 
  runMaybeT $ do
    x <- lol
    y <- lal

    _ <- lift getLine -- lift (IO String) to MaybeT IO String
    _ <- return 100   -- lift any pure value    
    _ <- mzero        -- use the MonadPlus instance to get a lifted Nothing.

    return (x < (read y)) 

main = foo >>= print

import-Control.Monad
进口控制单体变速器（提升）
import Control.Monad.Trans.Maybe（runMaybeT，MaybeT）
lol:：MaybeT IO Int
lol=返回3
lal:：MaybeT IO字符串
lal=返回“8”
foo：：IO（可能是Bool）
foo=
runMaybeT$do
x
x <- lift lol

lift :: IO (Maybe Int) -> MaybeT IO (Maybe Int)

MaybeT :: m (Maybe a) -> MaybeT m a

x <- MaybeT lol

MaybeT :: IO (Maybe a) -> MaybeT IO a

import Control.Monad
import Control.Monad.Trans (lift)
import Control.Monad.Trans.Maybe (runMaybeT, MaybeT)

lol :: MaybeT IO Int
lol = return 3

lal :: MaybeT IO String
lal = return "8"

foo :: IO (Maybe Bool)
foo = 
  runMaybeT $ do
    x <- lol
    y <- lal

    _ <- lift getLine -- lift (IO String) to MaybeT IO String
    _ <- return 100   -- lift any pure value    
    _ <- mzero        -- use the MonadPlus instance to get a lifted Nothing.

    return (x < (read y)) 

main = foo >>= print