[GHC] #15358: no way to talk about unpacking sum types / unpacking tuples

[GHC]

#15358: no way to talk about unpacking sum types / unpacking tuples
-------------------------------------+-------------------------------------
           Reporter:  chessai        |             Owner:  (none)
               Type:  feature        |            Status:  new
  request                            |
           Priority:  normal         |         Milestone:  8.6.1
          Component:  Compiler       |           Version:  8.4.3
           Keywords:  unboxedsums,   |  Operating System:  Unknown/Multiple
  unboxedtuples                      |
       Architecture:                 |   Type of failure:  None/Unknown
  Unknown/Multiple                   |
          Test Case:                 |        Blocked By:
           Blocking:                 |   Related Tickets:
Differential Rev(s):                 |         Wiki Page:
-------------------------------------+-------------------------------------
 Suppose I have the following Haskell module:

 {{{#!hs
 {-# LANGUAGE BangPatterns #-}

 -- strict 'Maybe'
 data StrictMaybe a = SNothing | SJust !a

 -- lazy 'Maybe'
 data Maybe a = Nothing | Just a

 data BoxedInner = BoxedInner
   !Int
   !(Maybe Int)

 data StillBoxedInner = StillBoxedInner
   !Int
   !(StrictMaybe Int)

 mBoxed :: BoxedInner
 mBoxed = BoxedInner 0 (Just 0)

 mWantThisToUnbox :: StillBoxedInner
 mWantThisToUnbox = StillBoxedInner 1 (Just 1)
 }}}

 the 'StrictMaybe' can unbox the first 'Int' into 1#, but the 1 inside of
 the just cannot unbox. When compiled to core with -O2 what I'd want to see
 is something like:

 {{{#!hs
 mWantThisToUnbox = StillBoxedInner 0# (# | 1# #)
 }}}

 (where (# (# #) | a #) is an unboxed sum type with two constructors, one
 nullary and one unary)

 but instead the Int inside 'SJust' remains boxed.

 Even with something like the following:

 {{{#!hs
 {-# LANGUAGE UnboxedSums #-}
 data UMaybe a = (# (# #) | a #)
 }}}

 something like 'UMaybe Int' would still result in 'Int' being boxed.

 This same thing occurs with unpacked tuples, consider something like:

 {{{#!hs
 data StrictTuple = StrictTuple
   !Int
   !(Int, Int)
 }}}

 Anything inside the (Int, Int) tuple will not unbox, despite having a bang
 pattern there.

-- 
Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/15358>
GHC <http://www.haskell.org/ghc/>
The Glasgow Haskell Compiler