Haskell IO и закрытие файлов

Объяснение здесь довольно длинное. Простите меня за то, что дал только небольшой совет: вам нужно прочитать о «полузакрытых дескрипторах файлов» и «unsafePerformIO».

Короче говоря, такое поведение представляет собой компромисс между семантической ясностью и ленивой оценкой. Вам следует либо отложить hClose до тех пор, пока вы не будете абсолютно уверены, что не будете делать что-либо с содержимым файла (например, вызвать его в обработчике ошибок или что-то подобное), либо использовать что-то еще, кроме hGetContents, чтобы получить содержимое файла не лениво.

Это потому, что hGetContents еще ничего не делает: это ленивый ввод-вывод. Только когда вы используете результирующую строку, файл фактически считывается (или его часть, которая необходима). Если вы хотите принудительно прочитать его, вы можете вычислить его длину и использовать функцию seq для принудительного вычисления длины. Ленивый ввод-вывод может быть крутым, но также может сбивать с толку.

Для получения дополнительной информации, например, см. часть о ленивом вводе / выводе в Real World Haskell.

Как отмечалось ранее, hGetContents ленив. readFile строг и закрывает файл по завершении:

main = do contents <- readFile "foo"
          putStr contents

дает следующее в объятиях

> main
blahblahblah

где foo - это

blahblahblah

Интересно, что seq гарантирует только чтение некоторая часть ввода, а не все:

main = do inFile <- openFile "foo" ReadMode
          contents <- hGetContents $! inFile
          contents `seq` hClose inFile
          putStr contents

дает

> main
b

Хороший ресурс: Делаем программы на Haskell быстрее и меньше: hGetContents, hClose, readFile

Как утверждали другие, это из-за ленивой оценки. После этой операции ручка будет полузакрыта и закроется автоматически, когда будут прочитаны все данные. И hGetContents, и readFile в этом смысле ленивы. В случаях, когда у вас возникают проблемы с открытыми дескрипторами, обычно вы просто выполняете принудительное чтение. Вот простой способ:

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

Однако в наши дни никто больше не использует строки для файлового ввода-вывода. Новый способ - использовать Data.ByteString (доступно при взломе) и Data.ByteString.Lazy при ленивом чтении хочу.

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 - это способ использовать большие строки (например, содержимое файла). Они намного быстрее и эффективнее с точки зрения памяти, чем String (= [Char]).

Заметки:

Я импортировал rnf из Control.Parallel.Strategies только для удобства. Вы могли бы довольно легко написать что-то подобное:

  forceList [] = ()
  forceList (x:xs) = forceList xs

Это просто заставляет обойти корешок (а не значения) списка, что приведет к чтению всего файла.

Ленивый ввод-вывод становится экспертами злом; На данный момент я рекомендую использовать строгие байтовые строки для большинства операций ввода-вывода файлов. В духовке есть несколько решений, которые пытаются вернуть составные инкрементальные чтения, наиболее многообещающее из которых Олег назвал "Iteratee".

[Обновлять: Prelude.readFile вызывает проблемы, как описано ниже, но переключение на использование всех версий Data.ByteString работает: я больше не получаю исключения.]

Здесь новичок в Haskell, но в настоящее время я не верю утверждению, что "readFile является строгим и закрывает файл по завершении":

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 ()

Это работает, как и в случае с файлом, который я тестировал, но если вы закомментируете putStrLn, то, по-видимому, writeFile не работает. (Интересно, насколько хромают сообщения об исключениях Haskell, отсутствуют номера строк и т. д.?)

Test> go "Foo.hs"
reading
writing
Exception: Foo.hs: openFile: permission denied (Permission denied)
Test> 

?!?!?

Если вы хотите, чтобы ваш ввод-вывод был ленивым, но чтобы сделать это безопасно, чтобы не возникало подобных ошибок, используйте пакет, предназначенный для этого, например безопасный ленивый. (Однако safe-lazy-io не поддерживает ввод-вывод байтов.)