Helpers for continuous mappings, useful to memoize functions on Int (instead of Word only) and functions over two and three arguments.

Example 1

Imagine writing a program to simulate Rule 90. This is a cellular automaton, which consists of an infinite one-dimensional line of cells, each being either dead (False) or alive (True). If two neighbours of a cell are equal, it becomes dead on the next step, otherwise alive.

Usually cellular automata are modelled by a finite vector. This is a bit suboptimal, because cellular automata may grow in different directions over time, but with a finite vector one has to define a bounding segment well beforehand. Moreover, what if we are interested to explore an evolution of an essentially infinite initial configuration?

It would be natural to encode an initial configuration as a function Int -> Bool, which takes a coordinate and returns the status of the corresponding cell. Define a function, which translates the automaton to the next step:

step :: (Int -> Bool) -> (Int -> Bool)
step current = \n -> current (n - 1) /= current (n + 1)

Unfortunately, iterating step would be extremely slow because of branching recursion. One could suggest to introduce a caching layer:

step :: (Int -> Bool) -> (Int -> Bool)
step current = \n -> current' (n - 1) /= current' (n + 1)
  where
    current' = memoize (current . fromIntegral) . fromIntegral

Unfortunately, it would not work well, because fromIntegral :: Int -> Word maps -1 to maxBound and it would take ages to memoize everything up to maxBound. But continuous mappings intToWord and wordToInt avoid this issue:

step :: (Int -> Bool) -> (Int -> Bool)
step current = \n -> current' (n - 1) /= current' (n + 1)
  where
    current' = memoize (current . wordToInt) . intToWord

Example 2

What about another famous cellular automaton: Conway's Game of Life? It is two-dimensional, so its state can be represented as a function Int -> Int -> Bool. Following the approach above, we would like to memoize such functions. Namely, cast the state to Word -> Bool, ready for memoization:

cast :: (Int -> Int -> Bool) -> (Word -> Bool)
cast f = \n -> let (x, y) = fromZCurve n in
 f (word2int x) (word2int y)

and then back:

uncast :: (Word -> Bool) -> (Int -> Int -> Bool)
uncast g = \x y -> g (toZCurve (int2word x) (int2word y))