Comments on: Lazier functional programming, part 2

By: Douglas McClean

Douglas McClean — Thu, 23 Dec 2010 01:03:01 +0000

@Paul, I thought so too at first, but now I think I understand why that isn't the case. If you alternate between taking steps to evaluate f \bot and taking steps to evaluate g \bot, one of three things will happen.

Either the partial answers you start to get will differ at some point (in which case you are done), or you will get to the end of both without encountering a difference (in which case you are done), or you will keep evaluating forever (in which case the answer was \bot anyway).

(Is this the gist of it? Or am I missing a different reason?)

By: conal

conal — Wed, 22 Sep 2010 20:24:27 +0000

Make that laxer if-then-else and either. Just fixed module name.

Thanks to Luke Palmer for the suggestion, via Twitter.

luqui: "@conal, lazier? Not laxer?".

conal: @luqui For the module name? "Laxer" would be more fitting than "Lazier", wouldn't it?

luqui: @conal, well according to the motivating blog posts, yes. I'm wondering why you went to the trouble to find a good term then didn't use it.

conal: @luqui simple reason: i forgot. just fixed. thanks!

By: conal

conal — Wed, 22 Sep 2010 19:41:56 +0000

The new version of the lub package has modules for glb and for lazier 'if-then-else' and 'either'.

By: David Sankel

David Sankel — Wed, 22 Sep 2010 17:42:50 +0000

Thanks. That clears it up. For those interested, I've asked haskell-cafe for more information on that particular optimization.

By: conal

conal — Tue, 21 Sep 2010 22:28:46 +0000

David: Ah, thanks. Now I get the ambiguity. I'll try to clarify.

Suppose you define h = eitherL f g (for some functions f and g), and then apply h to several Either-valued arguments. Then under GHC or GHCi, the work of computing f ⊥ ⊓ g ⊥ will be done just once, not repeatedly.

Now suppose instead that eitherL were defined as

eitherL f g x = (f ⊥ ⊓ g ⊥) ⊔ either f g x

and again, define h = eitherL f g (for some functions f and g). In this case f ⊥ ⊓ g ⊥ will get redundantly computed every time h is applied, because it is expressed within the scope of the "λ x → ..." (after desugaring).

The same sort of operational difference holds between the two following denotationally-equivalent expressions:

const (nthPrime 100000)
 
  _ -> nthPrime 100000

By: David Sankel

David Sankel — Tue, 21 Sep 2010 18:30:45 +0000

I guess the thing that's tripping me up is that I don't know what is being allowed to compute (who is computing?) in the sentence "Note in the either definition that the argument ordering allows computing (f ⊥ ⊓ g ⊥) just once and reusing the result for different values of the third argument". Maybe the subject here is a Haskell interpreter with certain assumed optimizations (or lack of)?

By: conal

conal — Tue, 21 Sep 2010 17:09:18 +0000

Couldn't an evaluator easily detect ( f ⊥ ⊓ g ⊥ ) as a common subexpression in two different applications of eitherL' f g?

What do you mean by an "evaluator" in this question? Something that structurally analyzes and transforms thunks at run time?

If you're asking about compilers, then my understanding is a compiler could perform the same code transformation that I applied, and that GHC intentionally does not, so as to avoid space leaks.

By: David Sankel

David Sankel — Tue, 21 Sep 2010 15:08:26 +0000

Dimtar's implementation,

eitherL' f g x = ( f ⊥ ⊓ g ⊥ ) ⊔ either f g x

, seems to generally have the same properties as your implementation.

On the other hand, I'm not certain if it "allows computing ( f ⊥ ⊓ g ⊥ ) just once and reusing the result for different values of the third argument". Couldn't an evaluator easily detect ( f ⊥ ⊓ g ⊥ ) as a common subexpression in two different applications of eitherL' f g?

By: conal

conal — Mon, 20 Sep 2010 21:16:07 +0000

Paul: No. I meant the definitions in the post as actual, computable, ideal implementations, except that I left out some class constraints, which I'll add in an edit.

By: Paul Brauner

Paul Brauner — Mon, 20 Sep 2010 10:04:53 +0000

So, if I understand, the ideal version cannot be reached effectively without solving the halting problem. The best you can do is to approximate it as much as you want by choosing a timeout as long as you want on the computation of (f ⊥ ⊓ g ⊥). Am I right?