In this article, we will look into encoding the Fibonacci function using the `fix`-point combinator. This is an interesting function as it can be used to implement general recursion in a programming language.

To set a context we first need to discuss some programming language fundamentals: In daily speech, programmers are used to programming languages being express all possible computations. This is, they are Turing complete.

However, often we want a programming language to support various properties. Some often discussed properties are type safety, which entails that programs that compile also runs without errors, and normalization, which roughly says we always get a result.

An often used framework for reasoning about these properties is the simply typed lambda calculus (STLC) with friends. With the raw STLC, it is not possible to encode general recursion. Hence we need to add a friend, which makes it possible.

This friend could be the fixed point operator.

# Day 11 - Fix

Generally, the `fix` operator looks as follow:

In the `ghci` interpreter we may define the function as follows:

``````> let fix f = let x = f x in x
``````

We now have a function `fix` that takes a function as the argument, applies it to itself and returns the result. If the function we apply `fix` on returns a value, then fix will return a value:

``````> fix (\rec -> "Hello Fix!")
"Hello fix!"
``````

Next, if we just apply the function on itself we will get an infinite loop:

``````> fix (\rec -> rec)
^CInterrupted.
``````

Now, this makes sense, as we continuously attempt to apply the lambda function on itself.

In above example, we only have a single argument, `n`, which is the function itself. We can say that we have the recursion directly in our hands. But to be able to do something interesting, like calculating the i‘th Fibonacci number, we need to add an argument we can decrement on. First a simple example.

``````> fix (\rec n -> if n == 0 then 0 else n + rec (n-1)) 10
55
``````

In above example we use the `if` to return a value when we hit 0, otherwise we apply the function on n-1. The expression simply adds all numbers from 0 to 10.

From here it is straight forward to implement the Fibonacci function. We need to have a nested if-statement, as we have two base cases. Otherwise, it is very similar to the function above.

``````> let fib = fix (\rec n ->
if n == 0 then 0 else if n == 1 then 1 else rec (n-1) + rec (n-2))
> fib 10
55
``````

# Reflections

This is a directly recursive implementation of the Fibonacci function. This is indeed visible from time complexity, and it is not feasible to compute the Fibonacci number of large numbers. It is indeed possible to augment above implementation with an accumulator.

Above implementation is interesting as we completely separate the recursion from the actual computation. In an earlier article, I implemented the function in Haskell using normal function syntax. Here the distinction between the recursion mechanism and the calculating mechanism is not as distinct.

The separation is especially interesting when formally reasoning about programming languages as we can get clutter away. This, however, is much easier when doing this in dedicated languages.

Above examples are kind of futile in Haskell, as it already supports better functionality for solving the Fibonacci function. It is, however, interesting to think about what a minimal language for solving the function would be. In above implementation, we need support for `fix`, `if-then-else`, boolean constructions, and natural numbers. This is four language constructions.