# Recursion

## What is Recursion?

Recursion is the process in which a function calls itself until a condition is met. This concept is similar to a `while`

loop in which a body of code will be executed repeatedly until a condition is met.

Recursion is an advanced topic when it comes to functions and programming; it often takes time and practice until a programmer is comfortable with creating and using recursive functions so don’t feel discouraged if it doesn’t all stick right away.

## Breaking Down a Recursive Function

In a recursive function, a base case (usually an `if`

expression) is created to check for a condition. If the condition is `true`

, then the function will return a value. If the condition is `false`

, the function will return a function call to itself with a new set of argument values; this is known as a *recursive call*. The function will continue to call upon itself until the base case is reached.

Let’s use a recursive function to get the sum of a group of numbers from `num`

until `0`

:

```
fun recursiveSum(num: Int): Int {
// base case
if (num == 0) {
return num
} else {
// recursive call
return num + recursiveSum(num - 1)
}
}
```

If we were to call this function with an argument of `4`

, we would get a return value of `10`

. Let’s try and break down how that worked. Until the parameter `num`

has a value of `0`

, the code in the `else`

block, `return num + recursiveSum(num - 1)`

, will be executed like so:

`recursiveSum(4)`

returns`4 + recursiveSum(3)`

.`recursiveSum(3)`

returns`3 + recursiveSum(2)`

.`recursiveSum(2)`

returns`2 + recursiveSum(1)`

.`recursiveSum(1)`

returns`1 + recursiveSum(0)`

.

Once we call `recursiveSum(0)`

, the base case is reached because `num`

is `0`

. Now, we need to return the value from each call starting from the last call made.

`recursiveSum(0)`

returns`0`

.`recursiveSum(1)`

returns`1 + 0`

which equals`1`

.`recursiveSum(2)`

returns`2 + 1`

which equals`3`

.`recursiveSum(3)`

returns`3 + 3`

which equals`6`

.`recursiveSum(4)`

returns`4 + 6`

which equals`10`

.

**Note:** Like a `while`

loop, a recursive function can run infinitely if we do not create a base case that eventually stops the recursive calls.

Let’s practice creating our own recursive function: