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
