Acquisizione/dirottamento stdout in haskell

Question

Come si può definire 'catchOutput' in modo che le uscite principali in esecuzione siano solo 'bar'?

Cioè, come posso accedere separatamente al flusso di uscita (stdout) e all'effettiva uscita di un'azione io?

catchOutput :: IO a -> IO (a,String) 
catchOutput = undefined 

doSomethingWithOutput :: IO a -> IO() 
doSomethingWithOutput io = do 
    (_ioOutp, stdOutp) <- catchOutput io 
    if stdOutp == "foo" 
     then putStrLn "bar" 
     else putStrLn "fail!" 

main = doSomethingWithOutput (putStr "foo") 

La migliore "soluzione" ipotetica che ho trovato finora comprende la deviazione standard output, inspired by this, ad un flusso di file e quindi la lettura dal file (Oltre ad essere super-brutto non sono stato in grado di leggere direttamente dopo aver scritto da un file. È possibile creare un "flusso buffer personalizzato" che non deve essere archiviato in un file?). Anche se sembra un po 'come una traccia laterale.

Un altro angolo sembra utilizzare 'hGetContents stdout' se si suppone che faccia ciò che penso dovrebbe. Ma non mi è stato dato il permesso di leggere dallo stdout. Sebbene su Google, sembra mostrare che è stato used.

Answer 1

Perché non utilizzare invece una monade writer? Ad esempio,

import Control.Monad.Writer 

doSomethingWithOutput :: WriterT String IO a -> IO() 
doSomethingWithOutput io = do 
    (_, res) <- runWriterT io 
    if res == "foo" 
     then putStrLn "bar" 
     else putStrLn "fail!" 

main = doSomethingWithOutput (tell "foo") 

In alternativa, è possibile modificare la vostra azione interiore per prendere un Handle di scrivere al posto di stdout. È quindi possibile utilizzare qualcosa come knob per creare un handle di file in memoria che è possibile passare all'azione interna e controllarne il contenuto in seguito.

Answer 2

Come @hammar sottolineato, è possibile utilizzare una manopola per creare un file in memoria, ma è anche possibile utilizzare hDuplicate e hDuplicateTo cambiare stdout al file di memoria, e viceversa. Qualcosa come il seguente codice di completamente non testato:

catchOutput io = do 
    knob <- newKnob (pack []) 
    let before = do 
     h <- newFileHandle knob "<stdout>" WriteMode 
     stdout' <- hDuplicate stdout 
     hDuplicateTo h stdout 
     hClose h 
     return stdout' 
     after stdout' = do 
     hDuplicateTo stdout' stdout 
     hClose stdout' 
    a <- bracket_ before after io 
    bytes <- Data.Knob.getContents knob 
    return (a, unpack bytes) 

Answer 3

ho usato la seguente funzione di una prova di unità di una funzione che consente di stampare su stdout.

import GHC.IO.Handle 
import System.IO 
import System.Directory 

catchOutput :: IO() -> IO String 
catchOutput f = do 
    tmpd <- getTemporaryDirectory 
    (tmpf, tmph) <- openTempFile tmpd "haskell_stdout" 
    stdout_dup <- hDuplicate stdout 
    hDuplicateTo tmph stdout 
    hClose tmph 
    f 
    hDuplicateTo stdout_dup stdout 
    str <- readFile tmpf 
    removeFile tmpf 
    return str 

io non sono sicuro circa l'approccio di file in memoria, ma funziona bene per una piccola quantità di output con un file temporaneo.

Answer 4

Ci sono alcuni pacchetti su Hackage che promettono di farlo: io-capture e silenziosamente. silenziosamente sembra essere mantenuto e funziona anche su Windows (io-capture funziona solo su Unix). Con in silenzio, si utilizza la cattura:

import System.IO.Silently 

main = do 
    (output, _) <- capture $ putStr "hello" 
    putStrLn $ output ++ " world" 

Nota che funziona reindirizzando l'output in un file temporaneo e poi leggerlo ... Ma finché funziona!