Início / coding / Perguntas / 79311051
Accepted
Enlico
Asked: 2024-12-27 14:16:31 +0800 CST

Nada gerado pela execução de uma pilha de transformadores de mônadas não é == Nada?

  • 772

Reproduções:

cabal repl --build-depends=mtl-prelude,transformers

λ> import Data.Mayb
λ> import Control.Monad
λ> import Control.Monad.Trans.Identity
λ> import MTLPrelude
λ> :{
ghci| maybeQuit :: MonadPlus m => Maybe Char -> MaybeT m (Maybe Char)
ghci| maybeQuit key = do
ghci|   case key of
ghci|     Just 'q' -> mzero
ghci|     Just '\ESC' -> mzero
ghci|     _ -> return key
ghci| :}
λ> runIdentityT $ runMaybeT $ maybeQuit (Just 'c')
Just (Just 'c')
λ> runIdentityT $ runMaybeT $ maybeQuit (Just 'q')
Nothing

Até agora tudo bem.

Mas então:

λ> (runIdentityT $ runMaybeT $ maybeQuit (Just 'q')) == Nothing 
False
λ> isNothing (runIdentityT $ runMaybeT $ maybeQuit (Just 'q'))
False

O que?!

Eu vejo que a expressão é um pouco polimórfica,

λ> :t runIdentityT $ runMaybeT $ maybeQuit (Just 'q')
runIdentityT $ runMaybeT $ maybeQuit (Just 'q')
  :: MonadPlus f => f (Maybe (Maybe Char))

mas não tenho certeza de como isso pode implicar que algo impresso como Nothingpoderia ser diferente de (==) Nothing.

Para contextualizar, estou executando maybeQuitem uma pilha monádica (há MaybeTe outros transformadores nela) com um IOna parte inferior, e está funcionando como esperado, mas suas implementações, portanto o tipo, não requerem o poder de IO, então eu estava tentando testá-lo em uma mônada diferente de IO, e foi assim que cheguei a fazer essa pergunta.

Em retrospecto, começo a ver outra coisa que não entendo muito bem: vejo :t runMaybeT $ maybeQuit (Just 'q')is MonadPlus m => m (Maybe (Maybe Char)), que é o que espero, mas, ao aplicar runIdentityTa isso, obtenho o tipo MonadPlus f => f (Maybe (Maybe Char), que é a mesma coisa, então devo estar entendendo mal o significado/propósito de IdentityT, e não consigo deixar de pensar que essa é a razão pela qual não obtenho o que acho que deveria obter no exemplo original.

À luz do raciocínio acima, tentei forçar m === []a expressão runMaybeT $ maybeQuit (Just 'c')aplicando- heada a ela, e o resultado é mais o que eu esperava:

λ> isNothing (head $ runMaybeT $ maybeQuit (Just 'q'))
True
λ> isNothing (head $ runMaybeT $ maybeQuit (Just 'c'))
False

mas ainda não entendi o que há de errado em usar runIdentityT.

haskell

1 respostas

  1. Best Answer

    Para entender o que está acontecendo, considere este exemplo muito mais simples:

    ghci> import Data.Maybe
ghci> weird = return Nothing
ghci> weird
Nothing
ghci> weird == Nothing
False
ghci> isNothing weird
False
ghci> :t weird
weird :: Monad m => m (Maybe a)
ghci>

    Quando você apenas insere weird, o GHCi assume como padrão mser IO(então o tipo geral é IO (Maybe a)), e então avalia a ação de IO para você, o que resulta em Nothing. Quando você insere weird == Nothingou isNothing weird, mé forçado a ser Maybe(então o tipo geral é Maybe (Maybe a)), então return Nothingse torna Just Nothing, o que é diferente de Nothing.

    Seu exemplo tem algumas camadas extras de indireção, mas no final das contas, a mesma coisa está acontecendo. runIdentityTera uma pista falsa; sua expressão é tão polimórfica que não faz nada onde está.

    Se você está confuso sobre o porquê de sua expressão ser basicamente a mesma que return Nothing, lembre-se de que o que mzerovocê está usando é definido assim:

    instance (Monad m) => MonadPlus (MaybeT m) where
    mzero = MaybeT (return Nothing)

    Não isso: 

    instance (MonadPlus m) => MonadPlus (MaybeT m) where
    mzero = MaybeT mzero
    • 4

relate perguntas