[Haskell-cafe] haskell in online contests

[wren ng thornton]

vishnu wrote:
> wow ok, I'm not even able to see why they're different in the desugared
> version

They're different because case is strict binding (see caveat below) 
whereas let is lazy binding. If we say,

     let foo = big ugly computation in bar

Then if foo isn't used in bar, it'll never be computed. (Even if foo 
occurs in bar, provided it occurs somewhere that won't be evaluated.) 
Whereas if we say,

     case big ugly computation of foo -> bar

Then we're forced to do the computation, regardless of whether foo is 
used in bar. Actually, that's not entirely true. In this example, 
because foo is a variable, the binding will be lazy; whereas if we 
replaced foo with a (non-lazy) pattern then it'd be strict.


Part of the complication in explaining the exact details is because both 
case and let can have patterns inside of the binding so the desugaring 
process has to continue recursively. Also there're some details about 
using let for defining recursive groups, which you can't do with case. 
Also Haskell's syntax conflates defining functions with doing pattern 
matching, so there's an extra step to separate functions using pattern 
matching into the definition binding vs the pattern matching. In any 
case, once you're done compiling you end up with a strict binding 
operator (kind of like case) and a lazy binding operator (kind of like let).

When in doubt, try playing around with different definitions to see 
whether they break when you pass in 'undefined'. There are also a few 
papers out there on how the STG works under the covers.

-- 
Live well,
~wren