[GHC] #14295: tagToEnum# leads to some silly closures

[GHC]

#14295: tagToEnum# leads to some silly closures
-------------------------------------+-------------------------------------
           Reporter:  dfeuer         |             Owner:  (none)
               Type:  bug            |            Status:  new
           Priority:  normal         |         Milestone:  8.4.1
          Component:  Compiler       |           Version:  8.2.1
           Keywords:  datacon-tags   |  Operating System:  Unknown/Multiple
       Architecture:                 |   Type of failure:  Runtime
  Unknown/Multiple                   |  performance bug
          Test Case:                 |        Blocked By:
           Blocking:                 |   Related Tickets:
Differential Rev(s):                 |         Wiki Page:
-------------------------------------+-------------------------------------
 I don't know how important this is in practice, but it smells pretty
 silly.

 Suppose I write

 {{{#!hs
 foo :: (Bool -> a) -> Int# -> a
 foo f x = f (tagToEnum# x)
 }}}

 Since `tagToEnum#` can fail, GHC compiles this to

 {{{#!hs
 foo
   = \ (@ a_a10v)
       (f_s1by [Occ=Once!] :: GHC.Types.Bool -> a_a10v)
       (x_s1bz [Occ=Once] :: GHC.Prim.Int#) ->
       let {
         sat_s1bA [Occ=Once] :: GHC.Types.Bool
         [LclId]
         sat_s1bA = GHC.Prim.tagToEnum# @ GHC.Types.Bool x_s1bz } in
       f_s1by sat_s1bA
 }}}

 That seems pretty silly! We know that `tagToEnum#` is applied to `Bool`,
 so we can transform this to something like

 {{{#!hs
 foo f x = case x <=# 1# of
             1# -> f $! tagToEnum# x
             _ -> f (error "tagToEnum# was used at Bool with tag ...")
 }}}

 which avoids an extra closure at the cost of a single `Int#` comparison.
 The same goes for arbitrary known enumeration types. I suspect the right
 place to fix this up is in CorePrep.

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