is computed by. Conceptually, it will be easiest if we think of the reduction
happening in the order displayed above.
-Well, once we've found a match between our sought number `3` and some member of
+Once we've found a match between our sought number `3` and some member of
the list, we'd like to avoid any further unnecessary computations and just
deliver the answer `true` as "quickly" or directly as possible to the larger
computation in which the search was embedded.
understanding of the v2 lists will give you a helpful model.
In broad outline, a single stage of the search would look like before, except
-now f would receive two extra, "handler" arguments.
+now `f` would receive two extra, "handler" arguments.
f 3 <result of folding f and z over [2; 1]> <handler to continue folding leftwards> <handler to abort the traversal>
of the list multiplied to, because that would affect the answer you passed
along to the continue-leftwards handler.
-A **version 5** list encodes the kind of fold operation we're envisaging here, in
-the same way that v3 (and [v4](/advanced/#index1h1)) lists encoded the simpler fold operation.
-Roughly, the list `[5;4;3;2;1]` would look like this:
+A **version 5** list encodes the kind of fold operation we're envisaging here,
+in the same way that v3 (and [v4](/advanced_lambda/#index1h1)) lists encoded
+the simpler fold operation. Roughly, the list `[5;4;3;2;1]` would look like
+this:
\f z continue_leftwards_handler abort_handler.
> and so on. All those steps have to be evaluated to finally get the result
> that `5` is the outer/leftmost head of the list. That's not an efficient way
> to get the leftmost head.
->
+>
> We could improve this by building lists as left folds when implementing them
> as continuation-passing style folds. We'd just replace above:
->
-> let make_list = \h t. \f z continue_handler abort_handler.
-> f h z (\z. t f z continue_handler abort_handler) abort_handler
->
+>
+> let make_list = \h t. \f z continue_handler abort_handler.
+> f h z (\z. t f z continue_handler abort_handler) abort_handler
+>
> now `extract_head` should return the leftmost head directly, using its
> `abort_handler`:
->
-> let extract_head = \lst larger_computation. lst
-> (\hd sofar continue_handler abort_handler. abort_handler hd)
-> junk
-> larger_computation
-> larger_computation
->
+>
+> let extract_head = \lst larger_computation. lst
+> (\hd sofar continue_handler abort_handler. abort_handler hd)
+> junk
+> larger_computation
+> larger_computation
+>
> 3. To extract tails efficiently, too, it'd be nice to fuse the apparatus
-> developed in these v5 lists with the ideas from [v4](/advanced/#index1h1)
-> lists. But that is left as an exercise.
+> developed in these v5 lists with the ideas from
+> [v4](/advanced_lambda/#index1h1) lists. But that is left as an exercise.