Wie man mit einem IO (Vielleicht (IO (Vielleicht t))) Typ umgehen?

Question

Ich habe es mit einer Bibliothek (ghcjs-dom) zu tun, in der jede Funktion eine IO (Maybe T) zurückgibt.

Ich habe eine Funktion a mit Renditen eine IO (Maybe x) und Funktion b die x als Argument und gibt eine IO (Maybe y).

Ist ein Operator, der mich a ??? b tun und eine IO (Maybe y) bekommen kann. Meine Hoogle-Suche ergab nichts.

Ich suche etwas wie join, die für IO (Maybe (IO (Maybe t))) statt IO (IO t) oder Maybe (Maybe t) funktioniert.

Answer 1

Von dem, was ich verstehe, Sie haben:

a :: IO (Maybe X) 
b :: X -> IO (Maybe Y) 

Es besteht eine enge Beziehung zwischen IO (Maybe a) und MaybeT IO a, nämlich MaybeT wandelt einen zum anderen:

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

und die inverse Operation ist nur runMaybeT:

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

Im MaybeT Monade der Zusammensetzung Sie ausführen wollen, ist nur die Bindeoperation:

MaybeT a >>= (\x -> MaybeT (b x)) :: MaybeT IO Y 

Daraus ergibt sich ein Wert vom Typ MaybeT IO Y. Um es zurück zu IO (Maybe Y) zu konvertieren, verwenden Sie einfach runMaybeT.

aktualisieren

Hier ist ein Operator zu "komponieren" eine und b:

andThen :: IO (Maybe a) -> (a -> IO (Maybe b)) -> IO (Maybe b) 
andThen a b = runMaybeT $ MaybeT a >>= (\x -> MaybeT (b x)) 

jedoch, wenn Sie sich mit diesem Operator viel finden, vielleicht Sie sollten überarbeiten Sie Ihre Funktionen, so dass Sie in erster Linie in der MaybeT IO Monade arbeiten, und dann können Sie einfach >>= mit einer einzigenverwenden auf der Außenseite.

Answer 2

Wenn Sie nicht MaybeT verwenden möchten, benötigen Sie sequenceA oder traverse von Data.Traversable.

Prelude Data.Traversable Control.Monad> :t fmap join . join . fmap sequenceA 

fmap join . join . fmap sequenceA 
    :: (Traversable m, Control.Applicative.Applicative f, Monad m, 
     Monad f) => 
     f (m (f (m a))) -> f (m a) 

In Ihrem Fall ist f IO und m Vielleicht.