Haskell binden mit mehreren Monaden

Question

Im Moment sieht mein Code wie folgt aus:

postUser :: ServerPart Response 
postUser = do 
    -- parseBody :: ServerPart (Maybe User) 
    parsedUser <- parseBody 
    case parsedUser of 
    Just user -> do 
     -- saveUser :: User -> ServerPart (Maybe (Key User)) 
     savedUser <- saveUser user 
     case savedUser of 
     Just user -> successResponse 
     Nothing -> errorResponse "user already exists" 
    Nothing -> errorResponse "couldn't parse user" 

Welche funktioniert, aber ich weiß, gibt es eine Möglichkeit, die verschachtelte Pattern-Matching zu vermeiden. Ich dachte, das war es, was binden würde für mich tun, also habe ich versucht

parseUser :: ServerPart (Maybe User) 
addUser :: User -> ServerPart (Maybe()) 
case parseUser >>= saveUser of 
    Just _ -> success 
    Nothing -> error 

und

savedUser <- (parseUser >>= saveUser) 
case savedUser of 
    Just _ -> success 
    Nothing -> error 

Aber ich erhalte den folgenden Fehler:

Couldn't match type ‘Maybe a0’ with ‘User’ 
    Expected type: Maybe a0 -> ServerPartT IO (Maybe (Key User)) 
     Actual type: User -> ServerPart (Maybe (Key User)) 
    In the second argument of ‘(>>=)’, namely ‘saveUser’ 
    In the expression: parseBody >>= saveUser 

, die ich nehmen zu bedeuten >>= ist Anwendung saveUser auf die Maybe User anstelle der User, die ich brauche, und ich bin mir nicht sicher, wie die Typen zu finagle passen. Wie kann ich dies umschreiben, um die Verschachtelung von verschachtelten Mustern zu vermeiden?

Answer 1

Während ich argumentieren würde, dass die ursprüngliche Art, wie Sie es geschrieben haben, der lesbarste Ansatz ist, dies als eine Übung zu nehmen, ist der MaybeT Monade Transformator, was Sie suchen.

Das Problem, auf das Sie stoßen, ist, dass Sie versuchen, zwischen der ServerPart-Monade und der Maybe-Monade zu springen. Deshalb können Sie parseBody und saveUser nicht direkt binden. Mit Monad-Transformatoren können Sie Monaden kombinieren, um dieses Problem zu vermeiden.

import Control.Monad.Trans.Maybe 

postUser :: ServerPart Response 
postUser = do 
    -- parseBody :: MaybeT ServerPart User 
    -- saveUser :: User -> MaybeT ServerPart (Key User) 
    user <- runMaybeT $ parseBody >>= saveUser 
    case user of 
    Just _ -> successResponse 
    Nothing -> errorResponse "Error saving user" 

Sie müssen Ihre parseBody- und saveUser-Funktionen umgestalten, um die MaybeT-Monade zu verwenden. Da ich diese Funktionen nicht sehen kann, kann ich Ihnen nicht helfen, aber es kann normalerweise einfach mit lift von Control.Applicative getan werden.

Nützliche Links Monade Transformatoren:

https://en.wikibooks.org/wiki/Haskell/Monad_transformers https://www.schoolofhaskell.com/user/commercial/content/monad-transformers

EDIT: MaybeT für parseBody

parseBody :: FromJSON a => MaybeT ServerPart a 
parseBody = MaybeT $ fmap A.decode getBody 

Und nur als allgemeine Tipp: bar >>= (return . f) entspricht fmap f bar. Letzteres ist sauberer und allgemeiner, da es die Monadeninstanz nicht erfordert.