UNPACK support for sum types

Currently the pragma only supports single-constructor types. So in the following example it will simply be ignored:

data A = 
  A1 Char |
  A2 {-# UNPACK #-} !B

data B = 
  B1 Int |
  B2 Bool

However the problem seems to be easily solvable by denormalizing the type A to something like the following during unpacking:

data A =
  A1 Char |
  A2_1 Int |    -- from B1
  A2_2 Bool     -- from B2

Trac metadata

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

changed weight to 5

added Tfeature request Trac import labels

Smells fishy. Would create a pwr(N,2) number of denormalizations where N is the number of inner sum types. Sounds like code explosion to me...

Would be better to calculate the largest size of the fully unpacked type like a C compiler would for unions.

o/t The behaviour of the trac for n^2 notation is really annoying!

It's even more complicated than just allocating the max needed by any of the unpacked sum type's constructor. The GC needs to know what the fields are in any given constructor to be able to GC correctly. I don't think this will be hard (that's why we haven't done it already).

mentioned in issue #10016

Trac metadata

Trac field	Value
TypeOfFailure	OtherFailure → RuntimePerformance

assigned to @osa1

See also: https://mail.haskell.org/pipermail/ghc-devs/2015-September/009742.html

Trac metadata

Trac field	Value
Differential revisions	- → D1540, D1559

I'm just popping in to +1 this. Currently, Data.IntMap defines

data IntMap a = Bin ... !(IntMap a) !(IntMap a) | Tip ... | Nil

Logically, it *should* be

data IntMap a = IM !(IntMap1) | Nil
data IntMap1 a = Bin ... !(IntMap1) !(IntMap1) | Tip ...

which would enforce the invariant that no Nils can occur within a tree. But that has an extra indirection, which seems likely unacceptable. If we could UNPACK the IntMap1 into the IntMap, we'd get the current performance with much nicer type guarantees.

One special case is a GADT with one constructor that takes one argument without any class context. For instance

data Foo a = This a | That a a
data Bar a b where
  Bar :: !(Foo a) -> Bar a a
data Baz where
  Baz :: !(Foo a) -> Baz

It would be great to be able to unpack Foo into Bar and Baz. Matching on the Bar or Baz constructor would force its contents to WHNF and reveal the evidence/open the existential.

Trac metadata

Trac field	Value
Differential revisions	D1540, D1559 → D1540, D1559, D2259

closed

In [changeset:"714bebff"]:

Author: Ömer Sinan Ağacan <omeragacan@gmail.com>
Date:   Thu Jul 21 08:07:41 2016 +0000

    Implement unboxed sum primitive type

Trac metadata

Trac field	Value
Resolution	Unresolved → ResolvedFixed

added Pnormal label