Recall that a function is tail recursive if its recursive call is the last operation in the function. A tail recursive function can be automatically converted by a compiler to use iteration, making it faster We have seen that a function can be made tail recursive by using a helper function, which we will call as accumulator, as in the following example. Original: (define (factorial n) (if (= n 0) 1 (* n (factorial (- n 1))) )) Tail recursive: (define (fact-accumulator n factpartial) (if (= n 0) factpartial (fact-accumulator (- n 1) (* n factpartial)) )) (define (factorial n) (fact-accumulator n 1)) We can write the tail recursive function also as follows. (define (factorial n) (letrec ((fact-accumulator (lambda (n factpartial) (if (= n 0) factpartial (fact-accumulator (- n 1) (* n factpartial)) ) ) (fact-accumulator n 1) Now, consider the following example for finding the length of a list. (define (length lst) (if (null? lst) 0 (+ 1 (length (cdr lst))))) If we step through the evaluation of this functions on (list 1 2 3 4 5) it will be like: (+ 1 (+ 1 (+ i (+ 1 (+ 1 0))))) => 5 We can write the tail recursive function as follows. (define (length lst) (letrec (length_helper (lambda (1st current_length) (if (null? lst) current_length (length_helper (cdr Ist) (+ 1 current_length)) ) ) (length_helper lst 0) )) Here, we ask you to step through the evaluation of the tail recursive function. Write briefly about your observations