73 lines
1.6 KiB
Markdown
73 lines
1.6 KiB
Markdown
X-Date: 2024-01-29T21:00:00Z
|
|
X-Note-Id: c7df8c86-62cb-4032-98d8-6555645af220
|
|
Subject: Tail-recursive even/odd
|
|
X-Slug: tail_recursive_even_odd
|
|
|
|
Tail calls are a way to save on call stack space. If a function call happens as a last thing a function performs, then
|
|
it is possible for a language implementation to optimize the call by getting rid of all temporary values on the stack
|
|
before the call is made.
|
|
|
|
Consider this implementation of `even` and `odd` functions in Python:
|
|
|
|
```
|
|
def even(x):
|
|
if x == 0:
|
|
return True
|
|
return odd(x-1)
|
|
|
|
def odd(x):
|
|
if x == 0:
|
|
return false
|
|
return even(x-1)
|
|
```
|
|
|
|
Here, the recursive calls are in the "tail" position, and thus in theory it is possible to just discard the caller's
|
|
stack and proceed with evaluating the callee without making a regular function call. In Python there are no tail calls,
|
|
but it's not hard to implement in a virtual machine.
|
|
|
|
So, this is what I did in my virtual machine. Here's the same example written in the VM assembly:
|
|
|
|
```
|
|
;; Pick a reasonably big number
|
|
;; to demonstrate that we don't
|
|
;; use stack much
|
|
(const val 1000000)
|
|
(const one 1)
|
|
(const zero 0)
|
|
|
|
(sr 3)
|
|
(setjump r0 even)
|
|
(mov r1 val)
|
|
(call r0 1)
|
|
|
|
(aeq r0 one)
|
|
(retnil)
|
|
|
|
;; Even implementation
|
|
(label even)
|
|
(sr 3)
|
|
(jeq r0 zero even-end)
|
|
|
|
(setjump r1 odd)
|
|
(sub r2 r0 one)
|
|
(tailcall r1 1)
|
|
|
|
(label even-end)
|
|
(ret one)
|
|
|
|
;; Odd implementation
|
|
(label odd)
|
|
(sr 3)
|
|
(jeq r0 zero odd-end)
|
|
|
|
(setjump r1 even)
|
|
(sub r2 r0 one)
|
|
(tailcall r1 1)
|
|
|
|
(label odd-end)
|
|
(ret zero)
|
|
```
|
|
|
|
|
|
In places where we want to make a tail call, instead of using `call`, you need to use `tailcall`. But otherwise
|
|
the way you write such calls would be the same.
|