[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
      Resolution:                    |             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:                    |
-------------------------------------+-------------------------------------
Description changed by dfeuer:

Old description:

> 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.

New description:

 I don't know how important this is in practice, but it looks unfortunate.

 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 bad! 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#comment:1>
GHC <http://www.haskell.org/ghc/>
The Glasgow Haskell Compiler