Class 39: Tail Recursion, Continued

Held Tuesday, November 12, 2002

Summary

Today we continue our consideration of tail recursion, including the construction of tail-recursive procedures that build lists.

Related Pages:

• Reading on tail recursion
• Lab on tail recursion
• Previous outline

Assignments

• Read Variable-Arity Procedures.

Notes

• Are there questions on exam 2?
  • Any updates I make are documented in the extra credit part.
• Quiz today!

Overview

• A few more notes on tail recursion
• Lab

Making Procedures Tail-Recursive

• Is tail recursion always better?
  • No, not if you do a lot of extra work in each recursive call.
  • Consider add-to-all-2 from the lab. It was significantly slower than the non-tail-recursive version.
• Can all recursive procedures be made tail-recursive?
  • Yes, but sometimes it requires a significant amount of work.
  • For example, we needed to reverse the result in select.
  • Consider the following strange procedure:

    (define strange
      (lambda (lst)
        (if (null? lst) 0
            (let ((first (car lst))
                  (tmp (strange (cdr lst))))
               (if (> first tmp) 
                   (- first tmp)
                   (- tmp first))))))
    

  • Consider also the following less-strange procedure

    (define square (lambda (x) (* x x)))
    (define exponent
      (lambda (val power)
        (cond
          ; Anything to the 0th power is 1.
          ((zero? power) 1)
          ; Cool math: x^2n = (x^n)*(x^n)
          ((even? power) (square (exponent val (/ power 2))))
          ; Less-cool math: x^(n+1) = x * x^n
          (else (* val (exponent val (- power 1)))))))
    

Some More Notes

• It should be easy to identify non-tail recursive procedures:
  • They're recursive.
  • In at least one recursive call, you apply some procedure to the result of the recursive call.
• The filter procedure defined below is not tail recursive because it applies cons the result of one of the recursive calls.

  (define filter
    (lambda (pred? lst)
      (cond
        ((null? lst) null)
        ((pred? (car lst)) (filter pred? (cdr lst)))
        (else (cons (car lst) (filter pred? (cdr lst)))))))
  

• The largest procedure defined below is not tail recursive because it applies max to the result of the recursive call.

  (define largest
    (lambda (lst)
      (if (null? (cdr lst)) 
          (car lst)
          (max (car lst) (largest (cdr lst))))))
  

• Yes, we can make both of these procedures tail recursive, but with varying degrees of difficulty.

  (define tr-filter
    (lambda (pred? lst)
      (let kernel ((unfiltered lst)
                   (rev-filtered null))
        (cond
          ((null? unfiltered) (reverse rev-filtered))
          ((pred? (car unfiltered)) 
           (kernel (cdr unfiltered) rev-filtered))
          (else (kernel (cdr unfiltered)
                        (cons (car unfiltered) rev-filtered)))))))
  
  (define tr-largest
    (lambda (lst)
      (let kernel ((remaining (cdr lst))
                   (max-so-far (car lst)))
        (if (null? remaining) max-so-far
            (kernel (cdr remaining)
                    (max (car remaining) max-so-far))))))
  

Lab

• Continue the lab.