Wie kann ich in Haskell aus einer Schleife ausbrechen?

Question

The current version of the Pipes tutorial, verwendet die folgenden zwei Funktionen in einem des Beispiels:

stdout ::() -> Consumer String IO r 
stdout() = forever $ do 
    str <- request() 
    lift $ putStrLn str 

stdin ::() -> Producer String IO() 
stdin() = loop 
    where 
    loop = do 
     eof <- lift $ IO.hIsEOF IO.stdin 
     unless eof $ do 
      str <- lift getLine 
      respond str 
      loop 

Wie im tutorial buchbar! Selbst, P.stdin etwas komplizierter ist aufgrund der Notwendigkeit, das Ende der Eingabe zu überprüfen .

Gibt es irgendwelche schönen Möglichkeiten, um P.stdin umschreiben zu können, um keine manuelle Tail-rekursive Schleife zu benötigen und Steuerfluss-Kombinatoren höherer Ordnung zu verwenden, wie es Pstdout tut? In einer imperativen Sprache würde ich eine strukturierte verwenden while-Schleife oder eine break-Anweisung, das Gleiche zu tun:

while(not IO.isEOF(IO.stdin)){ 
    str <- getLine() 
    respond(str) 
} 

forever(){ 
    if(IO.isEOF(IO.stdin)){ break } 
    str <- getLine() 
    respond(str) 
} 

Answer 1

wie ein Job Sucht whileM_:

stdin() = whileM_ (lift . fmap not $ IO.hIsEOF IO.stdin) (lift getLine >>= respond) 

oder, do-Notation ähnlich das ursprüngliche Beispiel:

stdin() = 
    whileM_ (lift . fmap not $ IO.hIsEOF IO.stdin) $ do 
     str <- lift getLine 
     respond str 

das monad-loops Paket bietet whileM auch die eine Liste von Zwischenergebnissen statt igno zurück klingeln Sie die Ergebnisse der wiederholten Aktion und andere nützliche Kombinatoren.

Answer 2

Da es keinen impliziten Fluss gibt, gibt es keine solche "Pause". Außerdem ist Ihr Beispiel bereits ein kleiner Block, der in einem komplizierteren Code verwendet wird.

Wenn Sie aufhören wollen "Strings herzustellen", sollte es von Ihrer Abstraktion unterstützt werden. I.e. einige "Managment" von "Pfeifen" mit speziellen Monaden in Consumer und/oder andere Monaden, die mit diesem verbunden sind.

Answer 3

ziehe ich folgendes:

import Control.Monad 
import Control.Monad.Trans.Either 

loop :: (Monad m) => EitherT e m a -> m e 
loop = liftM (either id id) . runEitherT . forever 

-- I'd prefer 'break', but that's in the Prelude 
quit :: (Monad m) => e -> EitherT e m r 
quit = left 

Sie verwenden es wie folgt aus:

import Pipes 
import qualified System.IO as IO 

stdin ::() -> Producer String IO() 
stdin() = loop $ do 
    eof <- lift $ lift $ IO.hIsEOF IO.stdin 
    if eof 
    then quit() 
    else do 
     str <- lift $ lift getLine 
     lift $ respond str 

this blog post Sehen Sie, wo ich diese Technik erklären.

Der einzige Grund, warum ich das nicht im Tutorial verwende, ist, dass ich es für weniger anfängerfreundlich halte.

Answer 4

Sie können einfach Import System.exit, und verwenden Sie exitWith ExitSuccess

Eg. if (input == 'q') dann exitWith ExitSuccess sonst drucken 5 (alles)