# The Sway Reference Manual/Recursion

In the previous chapter, we learned about looping using the functions *while*, *do*-*until*, *for*, and *for*-*each*. These functions implement what is known as *iterative* looping.

Recursion is another way of looping; often, recursive loops are easier to write and understand, as compared to iterative loops, such as *while*s and *for*s. Many mathematical functions are easy to implement recursively, so we will start there. Recall that the factorial of a number *n* is:

Consider writing a function which computes the factorial of a positive integer. For example, if the function were passed the value of 4, it should return the value of 24 since 4! is 4*3*2*1 or 24. One approach would be to use an iterative loop to cycle through all the multipliers, saving the partial product at each iteration. Getting the code to work correctly does take a bit of fiddling to get all the important bits right. A working implementation might look like:

function factorial(n) { var i; var product = 1; for (i = 1, i <= n, i = i + 1) { product = product * i; } product; }

This implementation raises many questions, since it goes against the general convention for structuring a counting loop:

- Why was the product initialized to one instead of zero?
- Why was the loop initialization chosen to be instead of ?
- Why was the loop test instead of ?

With some pondering, these questions can be answered because of the mathematics of multiplication..

There is a radically different approach that can be taken, an extremely simple, elegant, and powerful approach, called *recursion*. To apply recursion to solve a problem, it must be possible to state the solution of a problem in ever simpler terms. For factorial, the factorial of a number can be stated in terms of a simpler factorial.

otherwise

This second formulation states that the factorial of zero is onea. ^{[1]} and that the factorial of any other (positive) number is obtained by multiplying the that number by the factorial of one less than that number. After some study, you should be able to see that both the first formulation (with the ellipses ...) and this new formulation are equivalent^{[2]}. The second form is particularly well suited for implementation as a computer program:

function factorial(n) { if (n == 0) { 1; } else { n * factorial(n - 1); } }

or

function factorial(n) { if (n == 0,1,n * factorial(n - 1)); }

using *if'*s pure function call syntax.

Note how these two versions of *factorial* precisely implement the second formulation.

Convince yourself that the function really works by tracing the function call:

factorial(3)

Decomposing the call, we find that:

factorial(3) is 3 * factorial(2)

since *n*, having a value of 3, is not equal to 0. and so the second block of the *if* is evaluated. We can replace `factorial(2)` by `2 * factorial(1)`, yielding:

factorial(3) is 3 * 2 * factorial(1)

since *n*, now having a value of 2, is still not zero. Continuing along this vein, we can replace `factorial(1)` by `1 * factorial(0)`, yielding:

factorial(3) is 3 * 2 * 1 * factorial(0)

Now in this call to factorial, *n* does have a value of zero, so we can replace `factorial(0)` with its immediate return value of zero:

factorial(3) is 3 * 2 * 1 * 1

Thus, `factorial(3)` has a value of six:

sway> factorial(3); INTEGER: 6

as expected.

## The parts of a recursive function[edit]

Recursive approaches rely on the fact that it is usually simpler to solve a smaller problem than a larger one. In the factorial problem, trying to find the factorial *n* - 1 is a little bit simpler than finding the factorial of *n*. If finding the factorial of *n - 1* is still too hard to solve easily, then find the factorial of *n - 2* and so on until we find a case where the solution is easy. With regards to factorial, this is when *n* is equal to zero. The 'easy-to-solve' code (and the values that gets you there) is known as the *base* case. The find-the-solution-for-a-simpler-problem code (and the values that get you there) is known as the *recursive* case. The recursive case usually contains a call to the very function being executed. This call is known as a *recursive* call.

Most well-formed recursive functions are composed of at least one *base* case and at least one *recursive* case.

## The greatest common divisor[edit]

Consider finding the greatest common divisor (gcd) of two numbers. One approach is use repeated division. The first division divides the two numbers in question, saving the remainder. Now make the divisor the dividend and the remainder the divisor. Repeat this process until the remainder is zero. At that point, the current divisor is the gcd.

Let's turn it into a function, first iteratively and then recursively.

// compute the gcd of two positive integers iteratively function gcd(first,second) { var remainder; do-until (remainder == 0) { remainder = first % second; first = second; second = remainder; } first; //first holds the last divisor }

The *do-until* loop insures that the loop body is executed before the remainder is tested. Let's rewrite the function recursively. First we identify the recurrence case(s) and then the base case(s). In this case, the recurrence and base cases are a little different than in the factorial example. We recur^{[3]}if the remainder is not zero. We immediately return the answer if the remainder is zero. Now that the recurrence and base cases have been identified, we can write the recursive version without too much trouble.

// compute the gcd of two positive integers function gcd(first,second) { if (first % second == 0) { second; } else { gcd(second,first % second); } }

or

function gcd(first,second) { if (first % second == 0,second,gcd(second,first % second)); }

or, to remove the repeated computation of the remainder:

function gcd(first,second) { var remainder = first % second; if (remainder == 0,second,gcd(second,remainder)); }

Again, the recursive version is more compact.

Look at how the recursive version turns *second* into *first* by passing *second* as the first argument in the recursive call. By the same token, *remainder* becomes *second* by nature of being the second argument in the recurive call. To convince yourself that the routine really works, modify *gcd* to inspect the arguments:

function gcd(first,second) { var remainder = first % second; inspect(array(first,second,remainder)); if (remainder == 0,second,gcd(second,remainder)); }

You haven't learned about arrays or the built-in *array* function yet, but think of it as a way to group multiple things together. Inspecting the array is a trick to get multiple values inspected with a single call to *inspect*.

sway> gcd(66,42); array(first,second,remainder) is [66,42,24] array(first,second,remainder) is [42,24,18] array(first,second,remainder) is [24,18,6] array(first,second,remainder) is [18,6,0] INTEGER: 6

Note, how the first remainder, 24, keeps shifting to the left. In the first recursive call, the remainder becomes *second*, so the 24 shifts one spot to the left. On the second recursive call, the current *second*, which is 24, becomes *first*, so the 24 shifts once again to the left.

## The Fibonacci sequence[edit]

A third example of recursion is the computation of the Fibonacci number. The Fibonacci series looks like this:

n 0 1 2 3 4 5 6 7 8 ... Fib(n) 0 1 1 2 3 5 8 13 21 ...

and is found in nature again and again^{[4]}.. In general, a Fibonacci number is equal to the sum of the previous two Fibonacci numbers. The exceptions are the zeroes and the first Fibonacci numbers which are equal to 0 and 1 respectively. Voila! The recurrence case and the two base cases have jumped right out at us! Here, then is a recursive implementation of a function which computes the nth Fibonacci number.

// compute the nth Fibonacci number // n must be non-negative! function fibonacci(n) { if (n == 0) return 0; if (n == 1) return 1; fibonacci(n-1) + fibonacci(n-2); }

Our implementation is straightforward and elegant. Unfortunately, it's horribly inefficient. Unlike our recursive versions of *factorial* and *gcd*, which recurred about as many times as the iterative versions looped, our Fibonacci version will recur many, many more times than an iterative version of Fibonacci when computing larger Fibonacci numbers. Here's why.

Consider the call to `fib(6)`. Tracing all the recursive calls to *fib*, we get:

fib(6) is fib(5) + fib(4)

Replacing `fib(5)` with `fib(4) + fib(3)`, we get:

fib(6) is fib(4) + fib(3) + fib(4)

We can already see a problem, we will compute fib(4) twice, once from the original call to fib(6) and again when we try to find fib(5). If we write down all the recursive calls to `fib(6)` which each recursive call indented from the previous, we get a structure that looks like this:

fib(6) fib(5) fib(4) fib(3) fib(2) fib(1) fib(0) fib(1) fib(2) fib(1) fib(0) fib(3) fib(2) fib(1) fib(0) fib(1) fib(4) fib(3) fib(2) fib(1) fib(0) fib(1) fib(2) fib(1) fib(0)

We would expect, based on how the Fibonacci sequence is generated to take about six 'steps' to calculate `fib(6)`. Instead, ultimately there were 13 calls to either `fib(1)` or `fib(0)`^{[5]}. There was a tremendous amount of duplicated, and therefore wasted effort. So let's try to compute Fibonacci numbers using an iterative loop:

function fib(n) { var i; var first = 0; var second = 1; for (i = 0, i < n, i = i + 1) { var sum = first + second; first = second; second = sum; } first; }

In the loop body, we see that *fib* is much like *gcd*; the second number becomes the first number and some combination of the first and second number becomes the second number. In the case of *gcd*, the combination was the remainder and, in the case of *fib*, the combination is sum.

As with factorial, hitting on the right way to proceed iteratively is not exactly straightforward, while the recursive version practically wrote itself. Noting the similarity of *fib* and *gcd* suggest a way to have both recursion and efficiency at the same time.

## More on recursive loops[edit]

To transform an iterative loop into a recursive loop, one first identifies those variables that are changing in the loop body; these variable will become formal parameters in the recursive function. For example, the *fib* loop above has three (not two!) variables that are being changed during each iteration of the loop: *first*, *second*, and *i*. So, we start out our recursive function as thus:

function loop(first,second,i) { ... }

The loop test becomes an *if* test in the body of the *loop* function:

function loop(first,second,i) { if (i < n) { ... } else { ... } }

The if-true block becomes the recursive call. The arguments to the recursive call encode the updates to the loop variables The if-false block becomes the value the loop attempted to calculate:

function loop(first,second,i) { if (i < n) { loop(second,first + second,i + 1); } else { first; } }

Using function call syntax for *if* shortens up the function:

function loop(first,second,i) { if (i < n,loop(second,first + second,i + 1),first); }

Next, we embed the *loop* function into our the function containing the original loop. That way, any non-local variables referenced in the test or body of the original loop will be visible to the *loop* function:

function fib(n) { function loop(first,second,i) { if (i < n,loop(second,first + second,i + 1),first); } ... }

Finally, we call the *loop* function with the initial values of the loop variables:

function fib(n) { function loop(first,second,i) { if (i < n,loop(second,first + second,i + 1),first); } loop(0,1,0); }

For more practice, let's convert the iterative version of *factorial* into a recursive function using this method. We'll see we'll end up with a different recursive function than before.

function factorial(n) { var i; var product = 1; for (i = 1, i <= n, i = i + 1) { product = product * i; } product; }

We start, as before, by working on the *loop* function. In this case, only two variables are changing in the loop: product and *i*.

function loop(product,i) { ... }

Next, we write the *if* expression:

function loop(product,i) { if (i <= n,loop(product * i,i + 1),product); }

Next, we embed the *loop* function and call it:

function factorial(n) { function loop(product,i) { if (i <= n,loop(product * i,i + 1),product); } loop(1,1); }

The moral of this story is that any iterative loop can be rewritten as a recursion and any recursion can be rewritten as an iterative loop. Moreover, in 'good' languages^{[6]}, there is no reason to prefer one way over the other, either in terms of the time it takes or the space used in execution. Use a recursion if that makes the implementation more clear, otherwise, use an iterative loop.

## Footnotes[edit]

- ↑ Mathematicians, being an inclusive bunch, like to invite zero to the factorial party.
- ↑ The first formulation gets the basic idea of factorial across but is not very precise. For example, how would you computer the factorial of three using the first formulation?
- ↑ The word is
*recur*, NOT*recurse*! - ↑ Pineapples, the golden ratio, chambered nautilus, etc.
- ↑ 13 is a Fibonacci number. Curious!
- ↑ Someday, Sway will be a 'good' language.