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.

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)" []

For certain reason, I had to modify Prolog interpreter written in Standard ML. I used Moscow ML implementation. Interpreter had structures which look like:

...
datatype Term = Var of string * pos

              | Fun of string * Term list * pos

type Atom = string * Term list

datatype Query = And of Query * Query * pos
               | Or of Query * Query * pos
...

So in order to print those structure, one can do that in the top level mode of Moscow ML. But this may be somewhat inconvenient. So I ended up writing my own PrettyPrinter module where I created separate data type for types I wanted to print:

datatype PrintType =
         Clause of Prolog.Clause
       | ClauseList of Prolog.Clause list
       | Atom of Prolog.Atom
       | Query of Prolog.Query
       | Term of Prolog.Term
       ...

And had following print and show functions:

fun show (Clause (atom, query)) =
		(show (Atom atom)) ^ " " ^ (show (Query query))
  | show (ClauseList cl) =
		"[" ^ (showList (ClauseList cl))  ^ "]"
  | show (Atom (atomName, terms)) =
  ...
and showList(Clause _) = ""             (* shouldn't happen *)
  | showList(ClauseList []) = ""
  | showList(ClauseList (c::cs)) =
		(show (Clause c)) ^ (getListSeparator cs) ^ (showList (ClauseList cs))
  ...

fun print pt = BasicIO.print (show pt ^ "\n")

Annoying.