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!

During ghci startup just add -i<dir> parameter where <dir> stands for directory with module you want to import.
For example if you want to include a module from parent directory:

ghci -i../

Here is a simple configuration file test.cfg example:

key: value

And here is the program which reads the configuration file:

import Data.ConfigFile
import Data.Either.Utils

main =
 do val <- readfile emptyCP "test.cfg"
    let cp = forceEither val
    putStrLn $ forceEither $ get cp "" "key"

In this example we will use Ubuntu machine. We will use MySQL driver for HDBC from HackageDB.

First, we need to install MySQL server:

sudo apt-get install mysql-server

Then we need MySQL client library:

sudo apt-get install libmysqlclient-dev

Then, we install HDBC MySQL driver using Cabal:

http://hackage.haskell.org/package/HDBC-mysql

And you are ready to write some code!

module DatabaseTest where

import Database.HDBC
import Database.HDBC.MySQL

main =
   do conn <- connectMySQL defaultMySQLConnectInfo {
                  mysqlHost = "localhost",
                  mysqlDatabase = "db",
                  mysqlUser = "user",
                  mysqlPassword = "pass",
                  mysqlUnixSocket = "/var/run/mysqld/mysqld.sock" }
      quickQuery conn "INSERT INTO test VALUES (1)" []