# [plt-scheme] a semi-trivial tree-traversal problem

Here is a semi-trivial tree-traversal problem.
Given a nested list (a tree) of numbers, return the number that
causes the sum of all preceding (depth-first search) numbers to be
greater than a specified value.
For example:
(define L '((3 3) 2 4) )
; (search-width L 7) --> 2
... because 3 + 3 + 2 is greater than 7.
One solution is to flatten the list, and then walk down the list
accumulating a total and terminating appropriately. But that
solution requires that the flatten operation be executed first, on a
tree of indeterminate and potentially massive size. A potentially
wasteful process.
So, here is a potential solution that I hammered out.
(define (search-width L offset)
(call-with-current-continuation
(lambda (return)
(letrec ((_search-width (lambda (L)
(if (list? L)
(if (empty? L)
#f
(let ()
(_search-width (car L))
(_search-width (cdr L))
#f))
(if (> L offset)
(return L)
(let ()
(set! offset (- offset L))
#f))))))
(_search-width L)))))
As far as I can determine, this works. But I have some questions.
First, does this style of programming lead to any 'hidden' problems?
Second, how might we eliminate the 'ugly' call to set! ? And
finally, is there a generally better approach to solving this
problem, either in terms of efficiency, or coding style?
David Richards