i see both of the following functions are syntactically tail recursive ones, but, in racket, which of them is really treated as tail recursion, or both? i mean whether it is optimized as tail recursion by the interpreter.
;;1
(define (foo i m s)
(if (< i m)
(foo (+ i 1) m (+ i s))
s))
;;2
(define (foo i m s)
(if (= i m)
s
(foo (+ i 1) m (+ i s))))
are there any different answers in other lisps?
Both are tail recursive by the fact that the recursive call is done in the tail position, that is to say: it's the last thing done when calling the recursion. It doesn't matter at all if the order of the consequent and alternative parts in the if expression is reversed in the procedures shown.
And by Scheme's specification, all tail recursions must be optimized away, no mater where they appear in the code, syntactically speaking:
Implementations of Scheme must be properly tail-recursive. Procedure calls that occur in certain syntactic contexts called tail contextsare tail calls. A Scheme implementation is properly tail-recursive if it supports an unbounded number of active tail calls. A call is active if the called procedure may still return. Note that this includes regular returns as well as returns through continuations captured earlier by call-with-current-continuation that are later invoked. In the absence of captured continuations, calls could return at most once and the active calls would be those that had not yet returned. A formal definition of proper tail recursion can be found in Clinger's paper [5]. The rules for identifying tail calls in constructs from the (rnrs base (6)) library are described in section 11.20.
As long as we are talking about Scheme: no. All conforming implementations are required to detect tail-calls and make the appropriate optimizations, so that those require only a constant stack space. In your example, both are perfectly valid tail-calls, and must be recognized as such by any conformant implementation.
If, on the other hand, we are talking "Lisp in general", then things are different. ANSI Common Lisp for example does not require conforming implementations to treat tail-calls specially. Though most modern implementations do recognize tail calls (and will optimize them away given the right combination of declarations), there is nothing in the language itself, which would garantee this behaviour.
Section 3.5, page 11, of Scheme R7RS draft 8 identifies all tail recursive requirements based on syntactic form. For if the requirement is:
(if expression <tail expression> <tail expression>)
(if expression <tail expression>)
So based on your code examples and assuming Racket is faithful to Scheme, both are tail recursive. As for other lisps, I don't believe Common Lisp requires tail recursion optimization.
emacs lisp doesn't optimise tail recursion:
(defun fact (n &optional result)
(unless result (setq result 1)) ; use 1 if not given
(if (zerop n) result
(fact (1- n) (* n result))))
(fact 12)
479001600
(fact 1000)
Lisp nesting exceeds max-lisp-eval-depth
(Never mind that the value is a fixed integer so you can't return an accurate value for 1000! anyway - (fact 30) works but returns a wrong value.)
To add to what the previous correspondents have said, an implementation would be free to optimise tail recursion on higher optimization levels and/or lower safety. If in doubt, try different values and (disassemble 'foo) Also try (trace foo) - if the tail recursion is not optimised, you should see every call when you call it, if it is you should see only the "top" call.
