[GHC] #11393: Ability to define INLINE pragma for all instances of a given typeclass

[GHC]

#11393: Ability to define INLINE pragma for all instances of a given typeclass
-------------------------------------+-------------------------------------
           Reporter:  danilo2        |             Owner:
               Type:  feature        |            Status:  new
  request                            |
           Priority:  normal         |         Milestone:
          Component:  Compiler       |           Version:  8.1
           Keywords:                 |  Operating System:  Unknown/Multiple
       Architecture:                 |   Type of failure:  None/Unknown
  Unknown/Multiple                   |
          Test Case:                 |        Blocked By:
           Blocking:                 |   Related Tickets:
Differential Rev(s):                 |         Wiki Page:
-------------------------------------+-------------------------------------
 Hello! I would like to request a feature that would allow me to define the
 `INLINE` pragma for all instances of a given type class. Currently when we
 are creating high-performance libraries, that strongly depend on type-
 level computations we are using a lot of typeclasses that we want to be
 cut-out during the compilation time. We can use the `INLINE` pragma to be
 sure that after type-class resolution the code will be inlined and
 hopefully strongly optimized, but we have to put the pragme in every
 single type class instance, which makes the code look ugly and is just
 impractival. So I would like to transform code like (this is just example,
 not a real-world problem solving code):

 {{{

 class Foo a b where foo :: a -> b

 instance Foo Int String where foo = show
                               {-# INLINE foo #-}
 instance Foo Int Int    where foo = id
                               {-# INLINE foo #-}
 instance Foo Int Float  where foo = fromIntegral
                               {-# INLINE foo #-}

 }}}

 into:

 {{{

 class Foo a b where foo :: a -> b
                     {-# INLINE foo #-}

 instance Foo Int String where foo = show
 instance Foo Int Int    where foo = id
 instance Foo Int Float  where foo = fromIntegral

 }}}

 I think it would be pretty easy to support such syntax and a lot of
 libraries would benefit from the design.

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