Demand analysis for sum types
While working on #10613 it crossed my mind that it might be worthwhile to expand the demand type also onto sum types.
So instead of
| UProd [ArgUse] -- Product
we would have
| UData [[ArgUse]] -- Data type
and a function like
fromMaybe :: a -> Maybe a -> b
would have a signature of
which indicates that the second argument of
fromMaybe is evaluated at most once; the first constructor of the result has no arguments, the second (separated by
;) has one argument which is also used at most once.
I could imagine that this gives a lot of useful information with parsers and other code that repeatedly retuns stuff wrapped in a
Maybe or similar type.
Now, sum types are often recursive (
…), and we probably want to be smarter about recursion here. But note that this is not a new problem. If you write
data Stream = Stream Int Stream Stream Stream foo (Stream 0 x y z) = 0 foo (Stream 1 x y z) = foo x foo (Stream 2 x y z) = foo y foo (Stream _ x y z) = foo z
you already get huge demand signatures.