Some times ago I encountered with question: How to get function execution time in Haskell program? I asked this question at StackOverflow, and got some useful answers. Here i will try to describe how to do it. For example we have simple haskell program which will calculate sum of prime numbers which are between 0 and 10000. Something like this:

```
module TimingTest where
main :: IO()
main = do
putStrLn "Start"
putStrLn ("Result: " ++ show primesSum)
putStrLn "Done"
--
-- Returns True if `n` is prime
--
isPrime :: Int -> Bool
isPrime n = null [ x | x <- [2..n - 1], n `mod` x == 0]
primesSum :: Int
primesSum = sum [x | x <- [2..10000], isPrime x == True]
```

Yes, it’s not the best implementation of prime numbers, but it’s not important at the current moment. Let’s see what we have for checking execution time.

## Time

First of all, the simplest method to get execution time is time command. Compile our source code and execute:

```
$ time ./TimingTest
```

We must get something like this:

```
real 0m3.503s
user 0m3.492s
sys 0m0.004s
```

## GHCI

The second method is just add `:set +s`

in `ghci`

before the function execution. Of course it’s not the best method, because functions run much slower in ``ghci`

.

## TimeIt

The third method is to use TimeIt haskell library by Lennart Augustsson. Very little, but useful library with simple API. It consist only from two functions:

```
timeIt :: IO a -> IO a -- | Wrap an IO computation so that it prints out the execution time
```

and

```
timeItT :: IO a -> IO (Double, a)Source -- | Wrap an IO computation so that it returns execution time is seconds as well as the real value.
```

Let’s remake our main function as:

```
import System.TimeIt
main :: IO()
main = do
putStrLn "Start"
timeIt $ putStrLn ("Result: " ++ show primesSum)
putStrLn "End"
```

and will get something like this:

```
Start
Result: 5736396
CPU time: 8.22s
```

## Criterion

Criterion library provides a powerful but simple way to measure software performance by Bryan O’Sullivan. For using it, will remake again our main function as:

```
module Main where
import Criterion.Main
main :: IO()
main = defaultMain [
bgroup "Prime numbers." [bench "prime numbers benchmark" $ whnfIO (putStrLn $ show primesSum)]
]
```

and as a result we will get:

```
estimating clock resolution...
mean is 3.760062 us (160001 iterations)
found 3006 outliers among 159999 samples (1.9%)
2461 (1.5%) high severe
estimating cost of a clock call...
mean is 98.08812 ns (28 iterations)
found 4 outliers among 28 samples (14.3%)
4 (14.3%) low severe
```