Strict Haskell is not as strict as it probably should be
Consider this with -XStrict
f y = let Just x = blah[y] in body[y,x]
Suppose that in a call to f
,
-
blah
returnsNothing
- but
body
does not usex
Should f
succeed? For sure, blah
will be evaluated to HNF before body
is started, but is the match against Just
done strictly too?
According to our current semantics, in the match against Just
is not done strictly, so the call should succeed. I think that’s unexpected and probably wrong.
The translation goes like this:
!(Just x) = blah
==> (FORCE) v = blah; Just x = v (and add a seq on v)
==> (SPLIT) v = blah; x = case v of Just x -> x
So we finish up with
f y = let v = blah[y] in
let x = case v of Just x -> x in
v `seq` body[y,x]
I don’t think that’s what we intended, because there's a thunk for x
.
If the pattern can fail, I think we want the FORCE rule to say this:
Replace any binding !p = e with
v = case e of p -> (v1,..,vn); (v1,..,vn) = v
and replace e0 with v seq e0,
where v is fresh and v1..vn are the variable(s) bound by p
(Compare with the text at the above link.)
Trac metadata
Trac field | Value |
---|---|
Version | 7.10.3 |
Type | Bug |
TypeOfFailure | OtherFailure |
Priority | normal |
Resolution | Unresolved |
Component | Compiler |
Test case | |
Differential revisions | |
BlockedBy | |
Related | |
Blocking | |
CC | |
Operating system | |
Architecture |