The data-memocombinators package provides combinators for creating memo tables. It can build up data similar to a lookup table. It is now available in Fedora. Install it using:

$ sudo yum install ghc-data-memocombinators-devel

The time and memory consumption for a command execution can be viewed in ghci by setting the following:

ghci> :set +s

Suppose we wish to apply memoization to the Fibonacci function:

import qualified Data.MemoCombinators as Memo

fib = Memo.integral fib'
    where
    fib' 0 = 0
    fib' 1 = 1
    fib' x = fib (x-1) + fib (x-2)

The 10,000th Fibonacci number using the fib function is returned in a much shorter time in the second attempt:

ghci> fib 10000
...
(0.15 secs, 87703888 bytes)

ghci> fib 10000
...
(0.03 secs, 9652144 bytes)

We can also specify a range for which the memoization is to be applied. In the following example, it is applied only for the numbers between 1 and 1000:

import qualified Data.MemoCombinators as Memo

fib2 = Memo.arrayRange (1, 1000) fib'
    where
    fib' 0 = 0
    fib' 1 = 1
    fib' x = fib2 (x-1) + fib2 (x-2)

Using fib2 to return the 1000th Fibonacci number, we observe the following:

ghci> fib2 1000
...
(0.04 secs, 10804024 bytes)

ghci> fib2 1000
...
(0.02 secs, 7384584 bytes)

The mulHundred function takes an integer list as an argument and muliplies each element in the list with 100. We want to tabulate the values for faster lookup using:

import qualified Data.MemoCombinators as Memo

mulHundred = (Memo.list Memo.integral) b
  where
  b [] = []
  b (x:xs) = [100 * x]  ++ mulHundred xs 

Running the mulHundred function in ghci:

ghci> mulHundred [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[100,200,300,400,500,600,700,800,900,1000]
(0.03 secs, 9592680 bytes)

ghci> mulHundred [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[100,200,300,400,500,600,700,800,900,1000]
(0.02 secs, 8426040 bytes)

We can also apply memoization for quicksort. For example:

import qualified Data.MemoCombinators as Memo

quicksort = (Memo.list Memo.integral) quicksort' where
          quicksort' [] = []
          quicksort' (p:xs) = (quicksort lesser) ++ [p] ++ (quicksort greater)
                            where
                            lesser = filter (< p) xs
                            greater = filter (>= p) xs

Subsequent sorting of the input is faster:

ghci> let input = [x | x <- [100, 99..1]]
(0.02 secs, 7895376 bytes)

ghci> quicksort input
[1,2,..100]
(0.04 secs, 19918312 bytes)

ghci> quicksort input
[1,2,..100]
(0.01 secs, 7925856 bytes)

If we would like to create a table of results for the AND operation, we could use Memo.bool:

import qualified Data.MemoCombinators as Memo

andGate = Memo.bool new
  where
  new x y = x && y

For example:

ghci> False && True
False
(0.02 secs, 8537120 bytes)

ghci> andGate False True
False
(0.02 secs, 8442648 bytes)

ghci> andGate False True
False
(0.01 secs, 7376560 bytes)