Python быстрее, чем скомпилированный Haskell?

У меня есть простой скрипт, написанный как на Python, так и на Haskell. Он читает файл с 1 000 000 целых чисел, разделенных новой строкой, анализирует этот файл в список целых чисел, быстро сортирует его, а затем записывает в другой отсортированный файл. Этот файл имеет тот же формат, что и несортированный. Простой.

Вот Haskell:

quicksort :: Ord a => [a] -> [a]
quicksort []     = []
quicksort (p:xs) = (quicksort lesser) ++ [p] ++ (quicksort greater)
    where
        lesser  = filter (< p) xs
        greater = filter (>= p) xs

main = do
    file <- readFile "data"
    let un = lines file
    let f = map (\x -> read x::Int ) un
    let done = quicksort f
    writeFile "sorted" (unlines (map show done))

А вот Python:

def qs(ar):
    if len(ar) == 0:
        return ar

    p = ar[0]
    return qs([i for i in ar if i < p]) + [p] + qs([i for i in ar if i > p])


def read_file(fn):
    f = open(fn)
    data = f.read()
    f.close()
    return data

def write_file(fn, data):
    f = open('sorted', 'w')
    f.write(data)
    f.close()


def main():
    data = read_file('data')

    lines = data.split('\n')
    lines = [int(l) for l in lines]

    done = qs(lines)
    done = [str(l) for l in done]

    write_file('sorted', "\n".join(done))

if __name__ == '__main__':
    main()

Очень просто. Теперь я компилирую код на Haskell с помощью

$ ghc -O2 --make quick.hs

И измеряю эти два с помощью:

$ time./quick
$ time python qs.py

Results:

Haskell:

real    0m10.820s
user    0m10.656s
sys 0m0.154s

Python:

real    0m9.888s
user    0m9.669s
sys 0m0.203s

Как Python может быть быстрее, чем родной код Haskell?

Спасибо

РЕДАКТИРОВАТЬ:

• Версия Python :2.7.1
• Версия GHC :7.0.4
• Mac OSX, 10.7.3
• Intel Core i5 2,4 ГГц

Список сгенерирован

from random import shuffle
a = [str(a) for a in xrange(0, 1000*1000)]
shuffle(a)
s = "\n".join(a)
f = open('data', 'w')
f.write(s)
f.close()

Таким образом, все числа уникальны.