Haskell IO et la fermeture des fichiers

Quand j'ouvre un fichier pour la lecture en Haskell, j'ai constaté que je ne peux pas utiliser le contenu du fichier après sa fermeture. Par exemple, ce programme permettra d'imprimer le contenu d'un fichier:

main = do inFile <- openFile "foo" ReadMode
          contents <- hGetContents inFile
          putStr contents
          hClose inFile

Je m'attendais à ce interchanger l' putStr ligne avec la hClose ligne aurait aucun effet, mais ce programme imprime rien:

main = do inFile <- openFile "foo" ReadMode
          contents <- hGetContents inFile
          hClose inFile
          putStr contents

Pourquoi cela se produit? Je suppose qu'il a quelque chose à voir avec l'évaluation différée, mais j'ai pensé que ces expressions obtenir séquencé donc il ne serait pas un problème. Comment voulez-vous mettre en œuvre une fonction comme readFile?

InformationsquelleAutor Jay Conrod | 2008-11-17

37

Comme d'autres l'ont dit, c'est en raison de l'évaluation différée. La poignée est à moitié fermé après cette opération, et se ferme automatiquement une fois toutes les données sont lues. Les deux hGetContents et readFile sont paresseux de cette façon. Dans le cas où vous rencontrez des problèmes avec poignées ouvertes, généralement vous venez de force de la lire. Voici le moyen le plus facile:
```
import Control.Parallel.Strategies (rnf)
-- rnf means "reduce to normal form"
main = do inFile <- openFile "foo" 
          contents <- hGetContents inFile
          rnf contents `seq` hClose inFile -- force the whole file to be read, then close
          putStr contents
```
Ces jours-ci, cependant, personne n'est à l'aide de cordes pour les e/S de fichier plus. La nouvelle façon est d'utiliser des Données.ByteString (disponible sur le hackage), et de Données.ByteString.Paresseux quand vous voulez paresseux lit.
```
import qualified Data.ByteString as Str

main = do contents <- Str.readFile "foo"
          -- readFile is strict, so the the entire string is read here
          Str.putStr contents
```
ByteStrings sont la voie à suivre pour les grandes chaînes de caractères (comme le contenu du fichier). Ils sont beaucoup plus rapide et plus efficace en terme de mémoire de la Chaîne (= [Char]).

Notes:

J'ai importé le frr de Contrôle.En parallèle.Des stratégies uniquement pour des raisons de commodité. Vous pouvez écrire quelque chose comme vous-même assez facilement:
```
  forceList [] = ()
  forceList (x:xs) = forceList xs
```
- Ce juste une des forces de la traversée de la colonne vertébrale (pas les valeurs) de la liste, ce qui aurait pour effet de la lecture du fichier.

Paresseux I/O est en train de devenir considéré comme mauvais par des experts; je recommande l'utilisation stricte bytestrings pour la plupart des e/S de fichier pour le moment. Il y a quelques solutions dans le four qui tentent de ramener composable différentiels lit, le plus prometteur de ce qui est appelé "Iteratee" par Oleg.
- Deux commentaires. Tout d'abord, beaucoup de gens utilisent encore des chaînes pour les e / s de fichier. Ils sont parfaitement bien, quand ce que vous voulez obtenir d'un fichier est une chaîne de caractères! Deuxièmement, Paresseux IO n'est pas considéré comme mauvais par beaucoup de gens, mais il est considéré comme difficile. Il nous permet de faire toutes sortes de choses intéressantes avec un très faible syntaxique de la surcharge, le coût du maintien d'un nombre limité de types de logiques d'exploitation aux côtés général paramétré par le raisonnement.
- Suis tombé sur cette réponse et merci, @liqui! Je voulais simplement faire remarquer (3 ans plus tard) que votre rnf devrait être: rnf contents 'seq' hClose inFile, avec les backticks autour de seq. Aussi, rnf a été déplacé à Control.DeepSeq.
- Je pense que nous parlions lazy IO, que votre commentaire n'est pas de l'adresse.
- "Paresseux IO grave, programmation côté serveur n'est pas professionnel" – Oleg Kiselyov
InformationsquelleAutor luqui
4

[Mise À Jour: Prélude.readFile provoque des problèmes comme décrit ci-dessous, mais le passage à l'aide de Données.ByteString versions de tout ce qui fonctionne: je n'ai plus l'exception.]

Haskell newbie, mais actuellement je n'ai pas acheter de la revendication que "readFile est stricte et ferme le fichier quand c'est fini":
```
go fname = do
   putStrLn "reading"
   body <- readFile fname
   let body' = "foo" ++ body ++ "bar"
   putStrLn body' -- comment this out to get a runtime exception.
   putStrLn "writing"
   writeFile fname body'
   return ()
```
Qui fonctionne comme il se dresse sur le fichier que j'ai été le tester, mais si vous commentez la putStrLn puis apparemment le writeFile échoue. (Intéressant de voir comment boiteux Haskell des messages d'exception sont, manque les numéros de ligne etc.)?
```
Test> go "Foo.hs"
reading
writing
Exception: Foo.hs: openFile: permission denied (Permission denied)
Test> 
```
?!?!?
- J'ai juste couru votre code. GHCi dit: openFile: resource busy (file is locked). Qui serait compatible avec readFile être paresseux.
InformationsquelleAutor
2

C'est parce que hGetContents ne rien faire pour le moment: il est paresseux I/O. Uniquement lorsque vous utilisez la chaîne de résultat le fichier est lu (ou la partie de celle-ci est nécessaire). Si vous voulez forcer la lecture, vous pouvez calculer sa longueur, et d'utiliser la fonction de séquenceur à la force de la longueur d'évaluation. Paresseux I/O peut être cool, mais il peut aussi être source de confusion.

Pour plus d'informations, voir la partie sur les paresseux I/O dans Real World Haskell, par exemple.

InformationsquelleAutor Erik Hesselink
1

Comme indiqué précédemment, hGetContents est paresseux. readFile est stricte et ferme le fichier quand c'est fait:
```
main = do contents <- readFile "foo"
          putStr contents
```
les rendements de la suite dans les Étreintes
```
> main
blahblahblah
```
où foo est
```
blahblahblah
```
Il est intéressant de noter, seq garantit uniquement que une partie de l'entrée est lu, pas tout cela:
```
main = do inFile <- openFile "foo" ReadMode
          contents <- hGetContents $! inFile
          contents `seq` hClose inFile
          putStr contents
```
rendements
```
> main
b
```
Une bonne ressource est: Faire Haskell programmes plus rapides et les plus petits: hGetContents, hClose, readFile
- readFile utilise hGetContents et ne ferme pas le fichier. Son paresseux, selon Real World Haskell et le code source lui-même.
- Tout d'abord, readFile n'est pas stricte, comme mentionné, d'autre part, l'utilisation de $! avec hGetContents est entièrement redondant.
InformationsquelleAutor Chris Conway
1

Si vous voulez garder votre IO paresseux, mais le faire en toute sécurité, de sorte que des erreurs comme cela ne se produit pas, l'utilisation d'un package conçu pour cela, comme coffre-paresseux-io. (Cependant, coffre-paresseux-io ne prend pas en charge bytestring I/O.)

InformationsquelleAutor Robin Green
0

L'explication est assez longue pour figurer ici. Pardonnez-moi pour la distribution d'une courte pointe seulement: vous devez lire à propos de "semi-fermé les descripteurs de fichiers" et "unsafePerformIO".

En bref - ce comportement est un compromis entre d'une sémantique de la clarté et de l'évaluation différée. Vous devriez différer hClose jusqu'à ce que vous êtes absolument sûr de woudnt faire quoi que ce soit du contenu du fichier (comme l'appellent dans le gestionnaire d'erreur, ou somesuch), ou d'utiliser quelque chose de plus hGetContents pour obtenir le contenu du fichier non paresseusement.
- Pourriez-vous le lien entre toutes bonnes choses à lire sur ces sujets? Je n'ai pas pu trouver beaucoup d'autres que rare documentation et liste de diffusion des messages sur des problèmes spécifiques.
- Je ne pense pas que unsafePerformIO est pertinente ici. Peut-être unsafeInterleaveIO.
InformationsquelleAutor ADEpt

Vous devez vous connecter pour publier un commentaire.