Course contentsShow
← Computer Science
Lesson 229 of 2,8725. Functions and ModularityFree lesson

Helper Functions in Recursion

Use wrapper functions with accumulator parameters to convert non-tail-recursive functions to tail-recursive form.

Helper Functions in Recursion

You'll learn how to use wrapper functions with accumulator parameters to transform ordinary recursive functions into tail-recursive ones—making them more efficient and easier to convert to loops.

The Core Idea

Sometimes a recursive function isn't naturally tail-recursive because it needs to do work after the recursive call returns. A helper function is an inner or separate function that takes extra parameters (called accumulators) to carry partial results forward, eliminating the need for work after the call.

Think of it like a relay race: instead of each runner waiting to hand off something after running back (non-tail recursion), each runner carries the baton forward and passes everything at once (tail recursion with an accumulator).

How It Works

Consider computing a factorial. The naive version isn't tail-recursive:

def factorial(n):
    if n == 0:
        return 1
    return n * factorial(n - 1)  # multiplication happens AFTER return

With a helper function and accumulator:

def factorial(n):
    def helper(n, accumulator):
        if n == 0:
            return accumulator
        return helper(n - 1, n * accumulator)  # tail call!
    
    return helper(n, 1)

The helper function carries the running product in accumulator. The outer factorial is the wrapper that provides a clean interface, hiding the accumulator from the user.

Why This Matters

Tail-recursive functions with accumulators can be easily converted to loops (as you learned in lesson 228), and some compilers optimize them automatically. The wrapper keeps your function easy to call while the helper does the efficient work.

Key Takeaway: Helper functions with accumulator parameters transform non-tail-recursive functions into tail-recursive form by carrying intermediate results forward, enabling optimization and simpler iteration conversion.