Comments on: Folds and continuation-passing-style

by: matthew

Sat, 16 Jun 2007 20:48:58 +0000

Yes, I think you’re right. The problem is that for a foldr, it’s trivial to take the head of the list and apply the operator between the head and the tail of the last. With a foldl, you need to do the inverse: finding the last elem and applying the operator between the last elem and the inits. But in order to find the last elem you’ll have to traverse the list.

It makes me wonder whether the views (Wadler, but also recently has reappeared in the dependently typed stuff) of cons as snoc would give a better angle on this. Also, maybe the amortized unit cost queues stuff would better suit this as a foldl on the whole queue is a foldr on the “reading” side followed by a foldl on the “writing” side - so long as you typically shortcut before needing the /other/ list, you’re laughing.

by: tonyg

Sat, 16 Jun 2007 16:31:35 +0000

Sure, the kons operator will shortcut - but the left-fold will still traverse the entire list, won’t it? If that’s true, then even a shortcutting kons operator doesn’t help terminate left-folds early.

by: matthew

Sat, 16 Jun 2007 14:36:04 +0000

Tony, that's slightly a trick question.

foldr works left to right, and || shortcuts on the left, thus all is well. foldl works right to left, so if you have operators that shortcut to the right then yes, the combination of said operator with foldl would shortcut as you desire.

by: tonyg

Fri, 15 Jun 2007 17:13:19 +0000

Matthew, that’s true for right folds - what about left folds?

by: matthew

Fri, 15 Jun 2007 16:18:23 +0000

In defense of Haskell (not that it was really being attacked at all), I'd probably say that the laziness gets you short circuiting for free when you need it. For example, the definition of "or" (which is || throughout a list):

or    =  foldr (||) False

True  || _ =  True
False || x =  x

And it works happily on infinite lists:

Prelude> or (True: repeat False)
True

(sheesh, I hope this code doesn't get mangled up...)

by: tonyg

Thu, 14 Jun 2007 11:43:20 +0000

Good question.

Languages I know of that guarantee proper tail calls (it's not really an optimisation, it's more of a correctness thing ;-) ): Scheme, SML, O'Caml, Haskell. Languages that should, but don't: Smalltalk, Javascript.

Of the properly tail-recursive languages above, only Scheme offers first-class continuations. SML/NJ has an implementation-specific extension for them. Haskell lets you work in the continuation monad for some parts of your program but provides no general continuation-reification operator.

Even in Scheme, there can be tradeoffs involved in using call/cc - some implementations make it very expensive, for instance. Sometimes explicit CPS just seems to be the Right Thing, even though call/cc is available.

by: Holger

Thu, 14 Jun 2007 09:58:33 +0000

Ah, I see. Yes indeed that is more general.

But out of curiosity: How many languages actually guarantee the tail call optimisation needed to make the explicit CPS coding feasible? And how many of those do not offer continuations?

by: tonyg

Wed, 13 Jun 2007 16:36:08 +0000

@Holger: You’re right, and this is the traditional way of exiting (for instance) a for-each or fold loop early in Scheme. However, what if there are no first-class continuations, no call/cc? At that point, explicit reification of the continuations involved, via the CPS foldl, becomes necessary.

by: matthias

Wed, 13 Jun 2007 12:31:38 +0000

See also Oleg Kiselyov’s work on the best collection traversal interface, which, amongst other things, features a “left fold enumerator supporting a premature termination”.

by: Holger

Wed, 13 Jun 2007 12:02:35 +0000

But is it necessary to put the continuation code in the folding function? You could just use the continuations where you need it, e.g. a short-cicuited contains? can use the standard foldl thus:

(define (contains? predicate val elements)
(call/cc
(lambda (cont)
(foldl (lambda (elt acc)
(if (predicate elt val)
(cont #t)
#f))
#f
elements))))