IO i Być może interakcja z monadą

Question

Mam następujący kod, ale uważam, że jest zbyt brzydki i konieczny. Czy ktoś mógłby ją przeformułować, aby był bardziej funkcjonalny? (Pomieszałem z MaybeT, ale nie mogłem sprawić, żeby to działało) Odpowiedzi na aprobaty również są mile widziane.

getString :: IO String 

pred :: String -> Bool 

f :: String -> String 

result :: IO (Maybe String) 
result = do 
    s <- getString 
    if pred s 
    then return $ Just $ f s 
    else return Nothing 

EDIT: a follow-up pytanie: co, jeśli zarówno pred if również zwracać wyniki w ciągu IO (należy podzielić na to uwagę w osobnym pytaniu?)

getString :: IO String 

pred :: String -> IO Bool 

f :: String -> IO String 

result :: IO (Maybe String) 
result = do 
    s <- getString 
    b <- pred s 
    if b 
    then Just <$> f s 
    else return Nothing 

Answer 1

bym zacznij od przyjęcia logiki tutaj z monady IO. Czynność można następnie zapisać jako

result :: IO (Maybe String) 
result = foo <$> getString 

foo :: String -> Maybe String 
foo s | pred s = Just (f s) 
     | otherwise = Nothing 

Można chyba napisać foo na różne sposoby za pomocą wymyślnej kombinatorów, ale nie sądzę, że jest to konieczne tutaj. Najważniejsze jest, aby logika została usunięta z IO, aby łatwiej ją było przetestować.

Answer 2

import Control.Monad 

result = getString >>= (return . fmap f . (mfilter pred . Just)) 

Answer 3

nie można łatwo uciec z przylegający if-then-else, ale można uciec z nadmiarowa returns:

import Control.Monad 

result :: IO (Maybe String) 
result = go <$> getString where 
    go s | pred s = Just $ f s 
     | otherwise = Nothing 

Answer 4

Oczywistym transformacja z kodu jest czynnik return operacje:

result = do 
    s <- getString 
    return $ if pred s 
      then Just (f s) 
      else Nothing 

Dzięki temu wzoru bardziej pozorna

result = liftM g getString 
g s | pred s = Just (f s) 
    | otherwise = Nothing 

Stosując f z zewnątrz, możemy zrobić następny wzór pozorny:

g s = liftM f $ if pred s then Just s else Nothing 

który pozwala nam remplace blok if:

g = liftM f . mfilter pred . return 

Reasumując:

result = liftM (liftM f . mfilter pred . return) getString 

Answer 5

Oto miły mały kombinator:

ensure :: MonadPlus m => (a -> Bool) -> (a -> m a) 
ensure p x = guard (p x) >> return x 

Teraz możemy napisać funkcję, która sprawdza czystego swoje orzeczenie i stosuje f gdy właściwe:

process :: String -> Maybe String 
process = fmap f . ensure pred 

podnoszenia to działania IO jest po prostu inny fmap:

result = fmap process getString 

Osobiście bym prawdopodobnie inline process i napisz w ten sposób:

result = fmap (fmap f . ensure pred) getString 

... który jest względnie czystym opisem tego, co się dzieje.