Here are five ways to write the Ackermann function.

In math:

In direct style:

`(define ack (lambda (n m) (cond [(zero? n) (add1 m)] [(zero? m) (ack (sub1 n) 1)] [else (ack (sub1 n) (ack n (sub1 m)))])))`

In continuation-passing style:

`(define ack (lambda (n m) (ack-cps n m (empty-k)))) (define ack-cps (lambda (n m k) (cond [(zero? n) (k (add1 m))] [(zero? m) (ack-cps (sub1 n) 1 k)] [else (ack-cps n (sub1 m) (lambda (v) (ack-cps (sub1 n) v k)))]))) (define empty-k (lambda () (lambda (v) v)))`

In CPS with continuations represented as data:

`(define ack (lambda (n m) (ack-cps n m (empty-k)))) (define ack-cps (lambda (n m k) (cond [(zero? n) (ack-apply-k k (add1 m))] [(zero? m) (ack-cps (sub1 n) 1 k)] [else (ack-cps n (sub1 m) (ack-make-k n k))]))) (define empty-k (lambda () `(empty-k))) (define ack-make-k (lambda (n k) `(ack-make-k ,n ,k))) (define ack-apply-k (lambda (k v) (pmatch k [(empty-k) v] [(ack-make-k ,n ,k) (ack-cps (sub1 n) v k)])))`

In four registers or so:

`(define ack-n) (define ack-m) (define ack-k) (define ack-v) (define ack (lambda (local-n local-m) (begin (set! ack-n local-n) (set! ack-m local-m) (set! ack-k `(empty-k)) (ack-reg)))) (define ack-reg (lambda () ; ack-n ack-m ack-k (cond [(zero? ack-n) (set! ack-v (add1 ack-m)) (ack-apply-k)] [(zero? ack-m) (set! ack-n (sub1 ack-n)) (set! ack-m 1) (ack-reg)] [else (set! ack-k `(ack-make-k ,ack-n ,ack-k)) (set! ack-m (sub1 ack-m)) (ack-reg)]))) (define ack-apply-k (lambda () ; ack-k ack-v (pmatch ack-k [(empty-k) ack-v] [(ack-make-k ,local-n ,local-k) (set! ack-k local-k) (set! ack-m ack-v) (set! ack-n (sub1 local-n)) (ack-reg)])))`

Left as an exercise for the reader:

What are set-bangs and function calls with no arguments? (Well, aside from "ridiculous Scheme", I mean.) They're assignment statements and gotos, more or less. Which means that you could now pretty straightforwardly write this in the assembly language of your choice.