The thing is that in the memory leak example I took length of read file and appended it to accumulator, which was sent further in the tail call. And this accumulator was evaluated lazily! After adding strict sequencing operator, the memory leak gone.

So instead of tail call:

test fns $ acc + (B.length contents)

I should have used:

test fns $! acc + (B.length contents)

Things started to getting clearer. Here is a nice page explaining laziness during file read in Haskell (thanks to Vadim Platonov), section "hGetContents, hClose, readFile".
I have tried samples from that resource which should solve unwanted laziness, but memory leak still occurred. Moreover, those samples ran for ages on just several thousands of files and ate much more memory comparing to standard System.IO functions.

But my colleague just informed me, that the version which I posted previously runs without leaks on newer ghci version. I am too f*cked up after working day, so I hope to figure that out tomorrow.

I used Haskell for doing certain operations on big set of XML files: parsing XML files, running regular expressions etc. Set is not that big, but still -- 90000 XML files totalling 2.7GB.
I faced memory leaks in every program that I wrote. It was quite annoying since  Haskell was chosen as primary language for the project and I needed to produce some results relatively fast.

Today I decided to take closer look during what stage leak occurred. My initial assumption about leak during file read was confirmed. Initially I used readFile to read a file. But in this example I use Data.ByteString since it gracefully handles file close after opening.

Here is my example:

module SizeAnalyzer where

import Data.ByteString as B
import Utils

docsDir = "/home/mah/Documents/university/MIPH/data/updatedXml"

main =
   do filenames <- getFilenamesInDirectory docsDir
      acc <- test filenames 0
      return acc

test [] acc = return acc
test (fn:fns) acc =
   do contents <- B.readFile (docsDir++"/"++fn)
      test fns $ acc + (B.length contents)

Memory usage slowly grows. Even if program is finished, used memory is not freed!