[GHC] #9642: LANGUAGE pragma synonyms

[GHC]

#9642: LANGUAGE pragma synonyms
-------------------------------------+-------------------------------------
       Reporter:  dreixel            |                   Owner:
           Type:  feature request    |                  Status:  new
       Priority:  normal             |               Milestone:
      Component:  Compiler           |                 Version:  7.9
       Keywords:                     |        Operating System:
   Architecture:  Unknown/Multiple   |  Unknown/Multiple
     Difficulty:  Unknown            |         Type of failure:
     Blocked By:                     |  None/Unknown
Related Tickets:                     |               Test Case:
                                     |                Blocking:
                                     |  Differential Revisions:
-------------------------------------+-------------------------------------
 Here are the first 20 lines of a typical Haskell file of mine:

 {{{
 {-# LANGUAGE EmptyDataDecls                    #-}
 {-# LANGUAGE FlexibleContexts                  #-}
 {-# LANGUAGE FlexibleInstances                 #-}
 {-# LANGUAGE LiberalTypeSynonyms               #-}
 {-# LANGUAGE ScopedTypeVariables               #-}
 {-# LANGUAGE RankNTypes                        #-}
 {-# LANGUAGE StandaloneDeriving                #-}
 {-# LANGUAGE AutoDeriveTypeable                #-}
 {-# LANGUAGE DeriveDataTypeable                #-}
 {-# LANGUAGE DeriveGeneric                     #-}
 {-# LANGUAGE DefaultSignatures                 #-}
 {-# LANGUAGE OverlappingInstances              #-}
 {-# LANGUAGE UndecidableInstances              #-}
 {-# LANGUAGE MultiParamTypeClasses             #-}
 {-# LANGUAGE TypeOperators                     #-}
 {-# LANGUAGE TypeFamilies                      #-}
 {-# LANGUAGE GADTs                             #-}
 {-# LANGUAGE DataKinds                         #-}
 {-# LANGUAGE PolyKinds                         #-}
 {-# LANGUAGE ConstraintKinds                   #-}
 }}}

 Over a couple of modules in a small package, I find myself copy-pasting
 these 20 lines, as either I will use these extensions, or they won't
 really cause any harm to the code I'm writing.

 As a way to simplify this, and reduce code duplication, I propose
 introducing LANGUAGE pragma synonyms:
 {{{
 {-# LANGUAGE PedrosHaskell = EmptyDataDecls, FlexibleContexts,
 FlexibleInstances
                            , LiberalTypeSynonyms, ScopedTypeVariables
                            , RankNTypes, StandaloneDeriving,
 AutoDeriveTypeable
                            , DeriveDataTypeable, DeriveGeneric,
 DefaultSignatures
                            , OverlappingInstances, UndecidableInstances
                            , MultiParamTypeClasses, TypeOperators,
 TypeFamilies
                            , GADTs, DataKinds, PolyKinds, ConstraintKinds
 #-}
 }}}

 After writing this, in that same module or any module that imports it, I
 could just write:
 {{{
 {-# LANGUAGE PedrosHaskell #-}
 }}}
 And all the pragmas above would be enabled.

 Besides making my life easier, I suspect this will also help increase
 modularity of certain packages. For example, packages could define a
 package-specific language pragma that should be enabled in order to use
 that package. Then, if the package maintainer upgrades one datatype to
 become a GADT, the pragma would be updated to include `GADTs`, and user
 code (that could now be requiring that pragma) would automatically enable
 `GADTs` too.

 Furthermore, it can also make the language standardisation process
 simpler. After all,

 {{{
 {-# LANGUAGE Haskell2010 = PatternGuards, NoNPlusKPatterns, RelaxedPolyRec
                          , EmptyDataDecls, ForeignFunctionInterface #-}
 }}}

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