#22: Recursion with Pattern Matching

Recursion in Elixir is a programming technique where a function calls itself either directly or indirectly to solve a problem. Elixir is well-suited for recursion due to its tail-call optimization (more about this below), which prevents stack overflow errors by optimizing recursive calls. Recursion is commonly used in Elixir for tasks like list processing, tree traversal, and mathematical calculations.

Here are some of the key points about recursion in Elixir:

1. Base Case: Every recursive function must have a base case that defines when the recursion should stop.

2. Recursive Call: The function calls itself with modified arguments to move towards the base case.

3. Tail-Call Optimization: Elixir optimizes tail-recursive calls, ensuring efficient memory usage.

Basic Recursion Example:

defmodule Math do
  def factorial(0), do: 1
  def factorial(n) when n > 0, do: n * factorial(n - 1)
end

IO.puts(Math.factorial(5))  # Output: 120

In the above example, the Math.factorial/1 function calculates the factorial of a number using recursion. It has a base case when n is 0, and it recursively calls itself with n-1 until the base case is reached.

Recursion with Pattern Matching Example:

defmodule ListUtils do
  def sum_list([]), do: 0
  def sum_list([head | tail]), do: head + sum_list(tail)
end

IO.puts(ListUtils.sum_list([1, 2, 3, 4, 5]))  # Output: 15

In this example, the sum_list/1 function recursively sums the elements of a list using pattern matching. The base case is an empty list, and the recursive case matches the head and tail of the list to calculate the sum.

More Examples Showcasing Recursion in Elixir:

# Calculate the Fibonacci sequence
defmodule Fibonacci do
  def fib(0), do: 0
  def fib(1), do: 1
  def fib(n) when n > 1, do: fib(n - 1) + fib(n - 2)
end

IO.puts(Fibonacci.fib(6))  # Output: 8

# Calculate the length of a list of arbitrary size
defmodule ListUtils do
  def list_length([]), do: 0
  def list_length([_ | tail]), do: 1 + list_length(tail)
end

IO.puts(ListUtils.list_length([1, 2, 3, 4, 5]))  # Output: 5

What is meant by Tail-call Optimization?

One key advantage of using recursion in Elixir is that the language is tail-call optimized. Tail-call optimization is a feature that allows the Elixir compiler to optimize tail-recursive functions by reusing the current stack frame for the next recursive call instead of creating a new stack frame. This optimization prevents the stack from growing indefinitely and eliminates the risk of running into a StackOverflow exception.

However, it is important to note that even though Elixir is tail-call optimized, you still need to define a base case in your recursive function. The base case serves as the termination condition that stops the recursion and prevents the function from running indefinitely. Without a base case, the recursive function would continue to call itself infinitely, leading to an infinite loop.