Tail recursive Common Lisp interpreter?

["George J. Carrette" <GJC@MC.LCS.MIT.EDU>]

Thats an extremely interesting discovery. One known way to win: You
can implement an explicit control evaluator like one might in Scheme.
The control-point from a block then falls out like schemes lexical
catch contruct does. Or, what is easier, given a Scheme with lexical catch,
write your Common-Lisp interpreter in that. 

Here is another tail-recursion story. One of Papert's hackers was relating
to me one day how LOGO was tail recursive even though it used shallow
binding, and how that this was a pretty clever thing (to pull off)
So I said, ok, lets try to write:
  (DEFUN IFACT (N ACC) (IF (ZEROP N) ACC (IFACT (1- N) (* N ACC))))
and thus (DEFUN FACT (N) (IFACT N 1)). Well, my first try didnt work
at all, in fact, it didnt return ANY VALUE. I was then told that, OH,
to return a value you have to use OUTPUT. Thus (excuse the inexact logo syntax)
   TO IFACT :N :ACC IF N=0 OUTPUT ACC ELSE OUTPUT IFACT N-1 N*ACC
well, the OUTPUT caused the tail recursion to be broken.

  Or, you cant teach an ancient dog old tricks.
  Or, you can dress the language up but you cant take it ...