# [plt-scheme] match.ss performance

So, what should the expansion be? Two things come to mind (shown
below), but I have no idea which one is more efficient (or perhaps
there is a third?)
Also, what about `or' patterns? Should that use continuations, or maybe
just continuation-passing style with success and failure continuations?
(probably in mzscheme cps is far more efficient) How do you re-use
parts of overlapping ors? (or do you just assume that the overlapping
parts have been lifted out?)
Robby
(let ([fail (lambda () (match:error ...))])
(let ([x l])
(if (pair? x)
(let ([x2 (cdr x)])
(if (pair? x2)
(let ([x3 (cdr x2)])
(if (pair? x3)
(let ([x4 (cdr x3)])
(if (pair? x4)
(let ([x4 (cdr x4)])
(if (null? x4)
((lambda (a4 a3 a2 a1) l)
(car x4) (car x3) (car x2) (car x1))
(fail)))
(fail)))
(fail)))
(fail)))
(fail))))
(let ([fail (lambda () (match:error ...))])
(let ([x l])
(if (not (pair? x)) (fail))
(let ([x2 (cdr x)])
(if (not (pair? x2)) (fail))
(let ([x3 (cdr x2)])
(if (not (pair? x3)) (fail))
(let ([x4 (cdr x3)])
(if (not (pair? x4)) (fail))
(let ([x4 (cdr x4)])
(if (not (null? x4)) (fail))
((lambda (a4 a3 a2 a1) l)
(car x4) (car x3) (car x2) (car x1))))))))