For a function to be tail recursive, there must be nothing to do after the function returns except return its value. That is, the last thing that happens in the recursive step is the call to the function itself. This is generally achieved by using an accumulator parameter for keeping track of the answer:

(define (factorial x acc)
  (if (zero? x)
      acc
      (factorial (sub1 x) (* x acc))))

The above procedure will be initially called with 1 as accumulator, like this:

(factorial 10 1)
=> 3628800

Notice that the accumulated value gets returned when the base case is reached, and that the acc parameter gets updated at each point in the recursive call. I had to add one extra parameter to the procedure, but this can be avoided by defining an inner procedure or a named let, for example:

(define (factorial x)
  (let loop ((x x)
             (acc 1))
    (if (zero? x)
        acc
        (loop (sub1 x) (* x acc)))))

In your first code block, f is not tail recursive. The recursive call to f has to happen, return its result, and then 1 or 7, depending on the branch, has to be added to the result. Since the call to recursive call to f has to return, and there are arbitrarily many recursive calls to f, this means that arbitrarily many stack frames must be allocated.

When you think of calling a function, it may help to imagine that you take a new piece of paper and write all the of the local variables and values on that piece of paper. When you're determining the result of the function, there may be recursive calls to the same function. If the call is a tail-call, then when you take a piece of paper for it, you can throw away the old sheet, since you don't need any of its values anymore.

For instance, consider two ways of computing the length of a list:

(define (length-1 list)
  (if (null? list)
      0
      (+ 1
         (length-1 (cdr list))))) ; recursive call, NOT a tail-call

In this implementation, you have to finish the recursive call to length-1, get its result, and add 1 to it. That means that you need somewhere to come back to after the recursive call. Now consider a tail-recursive version:

(define (length-2 list current-length)
  (if (null? list)
      current-length
      (length-2 (cdr list) ; recursive call, IS a tail-call
                (+ 1 current-length))))

In this version, once you start to make the recursive call to length-2, you don't need any context from the original call anymore. In fact, you could translate this to a loop by assigning (cdr list) to list, and assigning (+ 1 current-length) to current-length. You can reuse the same stack space. That's how tail call optimization (when the tail call is to the same function) is equivalent to a loop.

What is Tail Recursion? Tail recursion is a special case of recursion where the recursive call is the last operation in the function. In tail-recursive functions, the result of the recursive call is immediately returned as the result of the current function call, without any additional computation. This allows for optimizations that can make tail-recursive functions more memory efficient than non-tail-recursive functions. Characteristics of Tail Recursion Last Operation: The recursive call is the final action in the function. No Pending Operations: After the recursive call returns, there are no further computations to be performed. Optimization Potential: Tail-recursive functions can be optimized by reusing the current function's stack frame, making the recursion as efficient as iteration. Tail Recursion Example Consider the calculation of the factorial of a number using tail recursion: Non-Tail-Recursive Factorial In a non-tail-recursive implementation, the multiplication happens after the recursive call returns: def factorial(n): if n == 0: return 1 else: return n * factorial(n - 1) print(factorial(5)) # Output: 120 Tail-Recursive Factorial In a tail-recursive implementation, the recursive call is the last operation: def factorial_tail(n, acc=1): if n == 0: return acc else: return factorial_tail(n - 1, n * acc) print(factorial_tail(5)) # Output: 120 Benefits of Tail Recursion Memory Efficiency: Tail-recursive functions can be optimized by reusing the current stack frame, preventing stack overflow for deep recursion. Performance: Reduces the overhead associated with recursive calls.

You pose a good question. You went from a recursive process (recursive-repeated) which builds a recursive process ((f (f (f ...)))) to an iterative process (iter-repeated) that builds the same recursive process.

You're right in thinking that you've basically done the same thing because the end result is the same. You just constructed the same chain in two different ways. This is the "consequence" of using compose in your implementation.

Consider this approach

(define (repeat n f)
  (λ (x)
    (define (iter n x)
      (if (zero? n)
          x
          (iter (- n 1) (f x))))
    (iter n x)))

Here, instead of building up an entire chain of function calls ahead of time, we'll return a single lambda that waits for the input argument. When the input argument is specified, we will loop inside the lambda in an iterative way for n times.

Let's see it work

(define (add1 x) (+ x 1))

;; apply add1 5 times to 3
(print ((repeat 5 add1) 3)) ;; → 8