On Jul 14, 2007, at 1:36 AM, Trevor S. wrote:
sum([H|T]) -> H + sum(T);
sum([]) -> 0.
“Oh my god! Won’t that blow the stack?” - well, I think it’s
okay because of something called ‘tail-recursion’ - but like you, I
don’t know what I don’t know.
For what it’s worth: the function definition is “tail-recursive” and
the technique used by the compiler/interpreter to prevent stack
overflow is called “tail-recursion elimination”. That is, the
compiler/interpreter transforms the recursion into an iteration
(which is relatively easy to do for tail-recursive functions).
Regards, Morton
On 7/14/07, Morton G. [email protected] wrote:
On Jul 14, 2007, at 1:36 AM, Trevor S. wrote:
sum([H|T]) -> H + sum(T);
sum([]) -> 0.
“Oh my god! Won’t that blow the stack?” - well, I think it’s
okay because of something called ‘tail-recursion’ - but like you, I
don’t know what I don’t know.
unfortunately this is not a tail recursive call. The recursive call
(sum) is
not the last call, + is. To write this tail recursively, you’d want to
use
an accumulating parameter:
sum(X) -> asum(0, X).
asum(N, [H|T]) -> asum(H + N, T);
asum(N, []) -> N.
For what it’s worth: the function definition is “tail-recursive” and
Hey Logan and Morton,
my thanks to both of you for the information. Quite a lot has fallen
into place in my head because of these two emails.
Trev