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

27 Sep 2017

      #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