>> Clojure doesn't have implicit tail call but it does have loop-recur and trampoline. SICP can be followed quite easily in Clojure.
>>> http://mitpress.mit.edu/sicp/full-text/book/book-Z-H-11.html.... This section relies on TCO. I realize that it could be translated, but I do not feel that this could be done without heavy modification. Besides that, basically the section's goal is to explain TCO.
This is the scheme implementation:
(define (factorial n)
(fact-iter 1 1 n))
(define (fact-iter product counter max-count)
(if (> counter max-count)
product
(fact-iter (* counter product)
(+ counter 1)
max-count)))
And this is the analogous(but not idiomatic) clojure: (defn fact-iter [product counter max-count]
(if (> counter max-count)
product
(recur (* counter product) (inc counter) max-count)))
(defn factorial [n]
(fact-iter 1 1 n))
There are no heavy modifications.> Besides that, basically the section's goal is to explain TCO.
def fact_iter(product, counter, max_count)
return product if counter > max_count
fact_iter (counter * product), (counter + 1), max_count
end
def fact(n)
fact_iter 1, 1, n
end
Now Ruby doesn't have TCO. But how does it stop you from understanding TCO, and how to implement them if the runtime supports it?I read SICP some time ago, and didn't do all the exercises, but as far as I recall, chapters 1-3 can easily be followed in Clojure, Ruby, JS...
I disagree that the Ruby example is sufficient, though. Remember, SICP is intended as an introduction to programming. A chapter like this is useful to people who do /not/ understand TCO, recursion, and the stack already. Understanding it and using that knowledge to translate the exercises is different than having a shaky grasp lisp, scheme, and the "interpretation of computer programs"
This section relies on TCO. I realize that it could be translated, but I do not feel that this could be done without heavy modification. Besides that, basically the section's goal is to explain TCO.