Semplificare espressioni Forse

Question

Ho il seguente codice, e penso che è brutto:

loginCheck = do 
    ml <- getPostParam "login" -- ml and mp :: Maybe ByteString 
    mp <- getPostParam "password" 
    if isJust ml && isJust mp 
    then authAs (fromJust ml) (fromJust mp) 
    else render "Msg" [("text", "Form incomplete")] 

Questo codice sembra essere molto imperativo. Posso semplificarlo in qualche modo?

Answer 1

Come altri hanno suggerito, Applicative potrebbe essere bello qui, così come MaybeT a seconda del contesto. Una terza cosa da tenere a mente è che un errore di corrispondenza del modello in un blocco do chiama il numero fail.

Questo è quello che vorrei fare:

loginCheck = do 
    ml <- getPostParam "login" 
    mp <- getPostParam "password" 
    fromMaybe (render "Msg" [("text", "Form incomplete")]) $ 
      authAs <$> ml <*> mp 

o una soluzione con MaybeT, anche se uno con un valore di ritorno diverso (di nuovo più contesto potrebbe mostrare che questo è un buon approccio o no):

getPostParamT = MaybeT . getPostParam 
loginCheckT = do 
    ml <- getPostParamT "login" -- ml and mp :: Maybe ByteString 
    mp <- getPostParamT "password" 
    liftIO $ authAs ml mp 
    <|> (liftIO $ render "Msg" [("text", "Form incomplete")]) 

... in realtà quanto sopra è piuttosto hokey, ora che lo guardo

Answer 2

ne dite:

loginCheck = do 
    ml <- getPostParam "login" -- ml and mp :: Maybe ByteString 
    mp <- getPostParam "password" 
    case (ml,mp) of 
    (Just l, Just p) -> authAs l p 
    _ -> render "Msg" [("text", "Form incomplete")] 

codice che utilizza isJust e/o fromJust è quasi sempre cattivo stile e un po 'pericoloso se si ottiene il controllo isJust prima fromJust sbagliato.

Questo può essere essere migliorata

• pattern matching, come sopra. Ma se questo è annidato diventa brutto.
• Gli abbinatori, come da Mayay, possono essere più concisi.
• L'uso di Maybe (e MaybeT) come Applicative o Monad può evitare il brutto nidificazione.

Answer 3

loginCheck = case (,) <$> getPostParam "login" <*> getPostParam "password" of 
    Just (l, p) -> authAs l p 
    Nothing  -> render "Msg" [("text", "Form incomplete")] 

forse? No. Oops.

loginCheck = do 
    x <- (,) <$> getPostParam "login" <*> getPostParam "password" of 
    case x of 
    Just (l, p) -> authAs l p 
    Nothing  -> render "Msg" [("text", "Form incomplete")] 

Quanto è fastidioso.

Answer 4

Non so se questo è un miglioramento qui, ma forse in alcuni casi ...

import Control.Monad 
import Control.Monad.Trans.Class 
import Control.Monad.Trans.Maybe 

getPostParam' = MaybeT . getPostParam 
render' x y = lift (render x y) 
authAs' x y = lift (authAs x y) 

loginCheck = runMaybeT $ 
     go `mplus` render' "Msg" [("text", "Form incomplete")] 
    where 
     go = do 
      ml <- getPostParam' "login" 
      mp <- getPostParam' "password" 
      authAs' ml mp 

Answer 5

loginCheck = do 
    [ml,mp] <- mapM getPostParam ["login","password"] 
    case liftM2 authAs ml mp of 
    Nothing   -> render "Msg" [("text", "Form incomplete")] 
    Just authorize -> authorize 

questo potrebbe sembrare strano, perché pattern corrisponde a un Maybe (IO()), ma questo è perfettamente sana. Oppure, utilizzando maybe:

loginCheque = mapM getPostParam ["login","password"] >>= \[ml,mp] -> 
       maybe message id (liftM2 authAs ml mp) 
    where message = render "Msg" [("text", "Form incomplete")] 

Answer 6

loginCheck = do 
    res <- return$ getPostParam "login" >>= \l -> -- ml and mp :: Maybe ByteString 
        getPostParam "password" >>= \p-> 
        Just (l,p) 
    case res of Nothing -> render "Msg" [("text", "Form incomplete")] 
       (Just (l,p)) -> authAs l p