Should one expect performance differences between these two emptys, or is it merely a matter of stylistic preference?
foo list = case list of
[] -> True
(_ : _) -> False
bar list = case list of
(_ : _) -> False
_ -> True
1 Answer
In general you should not expect performance to change predictably between trivial fiddling around with patterns like what you're asking about, and can often expect the generated code to be identical.
But the way to actually check is to look at core and or benchmark with criterion. In this case the generated code is the same, and indeed GHC seems to actually combine them:
I compiled the snippet above with
ghc -Wall -O2 -ddump-to-file -ddump-simpl -dsuppress-module-prefixes -dsuppress-uniques -fforce-recomp YourCode.hs
And we see this core:
foo :: forall t. [t] -> Bool
[GblId,
Arity=1,
Caf=NoCafRefs,
Str=DmdType <S,1*U>,
Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=False)
Tmpl= \ (@ t) (list [Occ=Once!] :: [t]) ->
case list of _ [Occ=Dead] {
[] -> True;
: _ [Occ=Dead] _ [Occ=Dead] -> False
}}]
foo =
\ (@ t) (list :: [t]) ->
case list of _ [Occ=Dead] {
[] -> True;
: ds ds1 -> False
}
-- RHS size: {terms: 1, types: 0, coercions: 0}
bar :: forall t. [t] -> Bool
[GblId,
Arity=1,
Caf=NoCafRefs,
Str=DmdType <S,1*U>,
Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=False)
Tmpl= \ (@ t) (list [Occ=Once!] :: [t]) ->
case list of _ [Occ=Dead] {
[] -> True;
: _ [Occ=Dead] _ [Occ=Dead] -> False
}}]
bar = foo
I think the Tmpl stuff is the original implementation exposed for inlining in other modules, but I'm not certain.
3 Comments
Daniel Wagner
In your first sentence, "[do] not expect performance to change predictably" and "expect the generated code to be identical" appear to be at odds: surely "I expect the performance not to change" is a prediction!
epsilonhalbe
the
bar = foo line is why I recommended using two different files - because I think I heard brian o'sullivan once saying that the optimizer might do stuff like that, therefore he benchmarks similar functions in different modules/packages.
jberryman
@DanielWagner what I meant was: I usually find doing superficial changes like the op's results in the same code, but in cases where the generated code is different I find both performance differences and generated code differences were unpredictable looking at the original source (thinking here of things like the ordering of branches in the final generated code; it's not clear to me if and how this relates to the boolean operators used, ordering of case statements, etc). But I would be interested if you disagree!
-ddump-simplfor the four (including from previous question edits) example functions doesn't seem to exhibit any difference. Their core is identical. I'm not sure if this is generalizable though.(:)takes arguments isn't really relevant.listis a value that is constructed by either[]or(:); that's the only thing the underlying code needs to look at.(_ : _)aren't omittable.[]is nullary and the:constructor binary._that their values won't be used.listwill be a value of some kind that is tagged with (the equivalent of) either[]or(:), and the compiler just needs to look at the tag.undefined : undefined, and each one would still returnFalsewithout any error.