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

<1*U><1*U(;1*U)>

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.

Trac metadata

Trac field	Value
Version	8.0.1
Type	Task
TypeOfFailure	OtherFailure
Priority	normal
Resolution	Unresolved
Component	Compiler
Test case
Differential revisions
BlockedBy
Related
Blocking
CC	ilya
Operating system
Architecture