In Haskell, voglio leggere un file e poi scriverci sopra. Ho bisogno di annotazioni sulla severità?

Question

Ancora abbastanza nuovo per Haskell ..

Voglio leggere il contenuto di un file, fare qualcosa con esso possibilmente coinvolgendo IO (usando putStrLn per ora) e quindi scrivere nuovi contenuti nello stesso file.

mi si avvicinò con:

doit :: String -> IO() 
doit file = do 
    contents <- withFile tagfile ReadMode $ \h -> hGetContents h 
    putStrLn contents 
    withFile tagfile WriteMode $ \h -> hPutStrLn h "new content" 

Tuttavia questo non funziona a causa di pigrizia. Il contenuto del file non viene stampato. Ho trovato this post che lo spiega bene.

la soluzione proposta non è quella di includere all'interno del putStrLnwithFile:

doit :: String -> IO() 
doit file = do 
    withFile tagfile ReadMode $ \h -> do 
     contents <- hGetContents h 
     putStrLn contents 
    withFile tagfile WriteMode $ \h -> hPutStrLn h "new content" 

Questo funziona, ma non è quello che voglio fare. L'operazione in I sostituirà eventualmente putStrLn potrebbe essere lunga, non voglio mantenere il file aperto tutto il tempo. In generale, voglio solo essere in grado di estrarre il contenuto del file e poi chiuderlo prima di lavorare con quel contenuto.

La soluzione mi è venuta è la seguente:

doit :: String -> IO() 
doit file = do 
    c <- newIORef "" 
    withFile tagfile ReadMode $ \h -> do 
     a <- hGetContents h 
     writeIORef c $! a 
    d <- readIORef c 
    putStrLn d 
    withFile tagfile WriteMode $ \h -> hPutStrLn h "Test" 

Tuttavia, ritengo che questo lungo e un po 'offuscato. Non penso che avrei bisogno di un IORef solo per ottenere un valore, ma avevo bisogno di "posizionare" per mettere il contenuto del file. Inoltre, non funzionava ancora senza l'annotazione di rigore $! per writeIORef. Immagino che gli IORef non siano rigorosi per natura?

Qualcuno può consigliare un modo migliore e più breve per farlo mantenendo la semantica desiderata?

Grazie!

Answer 1

Il motivo per cui il primo programma non funziona è che withFile chiude il file dopo l'esecuzione dell'azione IO inoltrata. Nel tuo caso, l'azione IO è hGetContents che fa non legge il file subito, ma solo come il suo contenuto è richiesto. Nel momento in cui si tenta di stampare il contenuto del file, withFile ha già chiuso il file, quindi la lettura non riesce (automaticamente).

È possibile risolvere questo problema da non reinventare la ruota e semplicemente utilizzando readFile e writeFile:

doit file = do 
    contents <- readFile file 
    putStrLn contents 
    writeFile file "new content" 

Ma supponiamo che si desidera che il nuovo contenuto dipendere il vecchio contenuto. Quindi non si può, in genere, è sufficiente fare

doit file = do 
    contents <- readFile file 
    writeFile file $ process contents 

perché il writeFile possono influenzare ciò che i rendimenti readFile (ricordate, non ha effettivamente letto il file ancora). In alternativa, a seconda del sistema operativo in uso, potrebbe non essere possibile aprire lo stesso file per la lettura e la scrittura su due manici separati.La soluzione semplice ma brutto è

doit file = do 
    contents <- readFile file 
    length contents `seq` (writeFile file $ process contents) 

che costringerà readFile per leggere l'intero file e chiuderlo prima che l'azione writeFile può iniziare.

Answer 2

È brutto ma è possibile forzare la lettura del contenuto chiedendo il length dell'input e seq 'it con la successiva istruzione nel proprio blocco. Ma in realtà la soluzione è utilizzare una versione rigorosa di hGetContents. Non sono sicuro di come si chiama.

Answer 3

Penso che il modo più semplice per risolvere questo problema è useing rigorosa IO:

import qualified System.IO.Strict as S 
main = do 
    file <- S.readFile "filename" 
    writeFile "filename" file 

Answer 4

è possibile duplicare il file Maniglia, scriva pigro con quello originale (fino alla fine del file) e di lettura pigra con un altro . Quindi nessuna annotazione di rigore coinvolta in caso di aggiunta al file.

import System.IO 
import GHC.IO.Handle 

main :: IO() 
main = do 
    h <- openFile "filename" ReadWriteMode 
    h2 <- hDuplicate h 

    hSeek h2 AbsoluteSeek 0 
    originalFileContents <- hGetContents h2 
    putStrLn originalFileContents 

    hSeek h SeekFromEnd 0 
    hPutStrLn h $ concatMap ("{new_contents}" ++) (lines originalFileContents) 

    hClose h2 
    hClose h 

La funzione hDuplicate è fornito dal modulo GHC.IO.Handle.

Restituisce un duplicato dell'impugnatura originale, con il proprio buffer. I due manici condivideranno comunque un puntatore di file. Il buffer della maniglia originale viene svuotato, incluso lo scarto di qualsiasi dato di input, prima che l'handle venga duplicato.

Con hSeek è possibile impostare la posizione della maniglia prima di leggere o scrivere.

Ma non sono sicuro di quanto sarebbe affidabile utilizzare "AbsoluteSeek 0" anziché "SeekFromEnd 0" per la scrittura, ovvero sovrascrivere i contenuti. Generalmente suggerisco di scrivere prima su un file temporaneo, ad esempio utilizzando openTempFile (da System.IO), e quindi sostituire l'originale.