Stateful Schleife mit verschiedenen Arten von Brüchen

Question

Ich versuche, den folgenden Stateful Imperativ-Code in Haskell zu konvertieren.

while (true) { 
    while (get()) { 
    if (put1()) { 
     failImmediately(); 
    } 
    } 
    if (put2()) { 
    succeedImmediately(); 
    } 
} 

Sowohl die put1 und put2 lesen einen Zustand des Systems und ändern. get kann der Einfachheit halber nur den Zustand ablesen. failImmediately sollte aus der Endlosschleife ausbrechen und eine Art Ergebnis anzeigen, succeedImmediately sollte ebenfalls ausbrechen aber ein anderes Ergebnis ergeben.

Was ich versucht war zu verwenden State Env Result wo Env den Zustand der Umwelt dargestellt und Result war so etwas wie Either Failure Success für einige benutzerdefinierte Failure und Success.

Ich kämpfe mit der Anforderung, dass der gesamte resultierende Ausdruck in die Failure/Success einstürzen sollte, sobald einer von ihnen produziert wird (die Schleife zu brechen) und ansonsten weitermachen.

Eine Idee war ich Either Exit() wo data Exit = Success | Failure verwenden hatte und verwenden StateT irgendwie auf Left der Either als ob Either wurde die Monade ist gekettet, das heißt ignoriert alle nachfolgenden Aktionen zu verhalten.

Ich würde wirklich jede Inspiration oder ein Beispiel von Haskell-Code schätzen, der das gleiche Verhalten wie das obige Snippet erreichen würde.

Bearbeiten: verfeinerte Version verschoben, um eine separate Frage "Stateful computation with different types of short-circuit (Maybe, Either)".

Answer 1

das Kit von @ Antwort des chi verwenden, nur hervorheben, dass Sie den direkten die volle Leistung des ContT, nicht brauchen Semantik von EitherT -kurzes Schließen genügt:

import Control.Monad.Trans.Either 

data Result a = Failure | Success a 

foo :: EitherT (Result Int) IO Int 
foo = forever $ do 
    whileM get $ do 
     whenM put1 $ do 
      left Failure 
    whenM put2 $ do 
     left $ Success 42 

run :: (Monad m) => EitherT (Result a) m a -> m (Maybe a) 
run act = do 
    res <- runEitherT act 
    return $ case res of 
     Left Failure -> Nothing 
     Left (Success x) -> Just x 
     Right x -> Just x 

-- whenM/whileM and get/put1/put2 as per @chi's answeer 

Answer 2

Eine fast wörtliche, nicht elegante, aber effektive Übersetzung.

Wir nutzen die ContT Monade Transformator, um den Effekt von "frühe Rückkehr" zu erreichen. Das heißt, wir wollen unsere Schleifen jederzeit aufbrechen können. Dies wird erreicht, indem callCC $ \exit -> ... verwendet wird, was ungefähr exit unsere magische Funktion macht, die uns sofort aus den inneren Blöcken entkommen lässt.

import Control.Monad.Cont 

action :: IO String 
action = flip runContT return $ callCC $ \exit -> 
    forever $ do     -- while (true) 
     let loop = do 
      r1 <- lift $ get  -- if (get()) 
      when r1 $ do 
       r2 <- lift $ put1 
       when r2 $   -- if (put1()) 
        exit "failImmediately" 
       loop    -- "repeat while" 
     loop 
     r3 <- lift $ put2 
     when r3 $ 
     exit "succeedImmediately" 

get :: IO Bool 
get = readLn 

put1 :: IO Bool 
put1 = putStrLn "put1 here" >> readLn 

put2 :: IO Bool 
put2 = putStrLn "put2 here" >> readLn 

main :: IO() 
main = action >>= putStrLn 

Wir haben auch einige benutzerdefinierte Helfer definieren können, um den Code zu beschönigen:

action2 :: IO String 
action2 = flip runContT return $ callCC $ \exit -> 
    forever $ do    -- while (true) 
     whileM get $    -- while(get()) 
     whenM put1 $   -- if (put1()) 
      exit "failImmediately" 
     whenM put2 $    -- if (put2()) 
     exit "succeedImmediately" 

whenM :: (MonadTrans t, Monad m, Monad (t m)) => m Bool -> t m() -> t m() 
whenM condition a = do 
    r <- lift condition 
    when r a 

whileM :: (MonadTrans t, Monad m, Monad (t m)) => m Bool -> t m() -> t m() 
whileM condition a = whenM condition (a >> whileM condition a)