packages feed

haskell-tools-rewrite 1.0.0.1 → 1.0.0.2

raw patch · 25 files changed

+826/−822 lines, 25 filesdep ~tastydep ~tasty-hunit

Dependency ranges changed: tasty, tasty-hunit

Files

Language/Haskell/Tools/Rewrite/Create/Binds.hs view
@@ -12,97 +12,97 @@ import Language.Haskell.Tools.Rewrite.ElementTypes
 
 -- | A simplified function to generate simple value bindings without local definitions, guards or complex lhs.
-mkSimpleBind' :: Name dom -> Expr dom -> ValueBind dom
+mkSimpleBind' :: Name -> Expr -> ValueBind
 mkSimpleBind' n e = mkSimpleBind (mkVarPat n) (mkUnguardedRhs e) Nothing
 
 -- | Creates a value binding (@ v = "12" @).
-mkSimpleBind :: Pattern dom -> Rhs dom -> Maybe (LocalBinds dom) -> ValueBind dom
+mkSimpleBind :: Pattern -> Rhs -> Maybe LocalBinds -> ValueBind
 mkSimpleBind p r l = mkAnn (child <> child <> child) (USimpleBind p r (mkAnnMaybe opt l))
 
 -- | Creates a function binding (@ f 0 = 1; f x = x @). All matches must have the same name.
-mkFunctionBind :: [Match dom] -> ValueBind dom
+mkFunctionBind :: [Match] -> ValueBind
 mkFunctionBind = mkAnn child . UFunBind . mkAnnList (indented list)
 
 -- | A simplified function for creating function bindings without local definitions or guards.
-mkFunctionBind' :: Name dom -> [([Pattern dom], Expr dom)] -> ValueBind dom
+mkFunctionBind' :: Name -> [([Pattern], Expr)] -> ValueBind
 mkFunctionBind' name matches = mkFunctionBind $ map (\(args, rhs) -> mkMatch (mkMatchLhs name args) (mkUnguardedRhs rhs) Nothing) matches
 
 -- | Creates a clause of function binding
-mkMatch :: MatchLhs dom -> Rhs dom -> Maybe (LocalBinds dom) -> Match dom
+mkMatch :: MatchLhs -> Rhs -> Maybe LocalBinds -> Match
 mkMatch lhs rhs locs
   = mkAnn (child <> child <> child)
       $ UMatch lhs rhs (mkAnnMaybe (after " " opt) locs)
 
 -- | Creates a match lhs with the function name and parameter names (@ f a b @)
-mkMatchLhs :: Name dom -> [Pattern dom] -> MatchLhs dom
+mkMatchLhs :: Name -> [Pattern] -> MatchLhs
 mkMatchLhs n pats = mkAnn (child <> child) $ UNormalLhs n (mkAnnList (after " " $ separatedBy " " list) pats)
 
 -- | Creates an infix match lhs for an operator (@ a + b @)
-mkInfixLhs :: Pattern dom -> Operator dom -> Pattern dom -> [Pattern dom] -> MatchLhs dom
+mkInfixLhs :: Pattern -> Operator -> Pattern -> [Pattern] -> MatchLhs
 mkInfixLhs lhs op rhs pats
   = mkAnn (child <> child <> child <> child) $ UInfixLhs lhs op rhs (mkAnnList (after " " $ separatedBy " " list) pats)
 
 -- | Local bindings attached to a declaration (@ where x = 42 @)
-mkLocalBinds :: [LocalBind dom] -> MaybeLocalBinds dom
+mkLocalBinds :: [LocalBind] -> MaybeLocalBinds
 mkLocalBinds = mkAnnMaybe (relativeIndented 2 $ after "\nwhere " opt)
                      . Just . mkAnn child . ULocalBinds . mkAnnList (indented list)
 
-mkLocalBinds' :: [LocalBind dom] -> LocalBinds dom
+mkLocalBinds' :: [LocalBind] -> LocalBinds
 mkLocalBinds' = mkAnn (" where " <> child) . ULocalBinds . mkAnnList (indented list)
 
 -- | Creates a local binding for a value
-mkLocalValBind :: ValueBind dom -> LocalBind dom
+mkLocalValBind :: ValueBind -> LocalBind
 mkLocalValBind = mkAnn child . ULocalValBind
 
 -- | Creates a local type signature
-mkLocalTypeSig :: TypeSignature dom -> LocalBind dom
+mkLocalTypeSig :: TypeSignature -> LocalBind
 mkLocalTypeSig = mkAnn child . ULocalSignature
 
 -- | Creates a local fixity declaration
-mkLocalFixity :: FixitySignature dom -> LocalBind dom
+mkLocalFixity :: FixitySignature -> LocalBind
 mkLocalFixity = mkAnn child . ULocalFixity
 
 -- | Creates a type signature (@ f :: Int -> Int @)
-mkTypeSignature :: Name dom -> Type dom -> TypeSignature dom
+mkTypeSignature :: Name -> Type -> TypeSignature
 mkTypeSignature n t = mkAnn (child <> " :: " <> child) (UTypeSignature (mkAnnList (separatedBy ", " list) [n]) t)
 
 -- | Creates a left-associative fixity declaration (@ infixl 5 +, - @).
-mkInfixL :: Int -> Operator dom -> FixitySignature dom
+mkInfixL :: Int -> Operator -> FixitySignature
 mkInfixL prec op = mkAnn (child <> " " <> child <> " " <> child)
                      $ UFixitySignature (mkAnn "infixl" AssocLeft) (mkAnnMaybe opt $ Just $ mkAnn (fromString (show prec)) (Precedence prec)) (mkAnnList (separatedBy ", " list) [op])
 
 -- | Creates a right-associative fixity declaration (@ infixr 5 +, - @).
-mkInfixR :: Int -> Operator dom -> FixitySignature dom
+mkInfixR :: Int -> Operator -> FixitySignature
 mkInfixR prec op = mkAnn (child <> " " <> child <> " " <> child)
                      $ UFixitySignature (mkAnn "infixr" AssocRight) (mkAnnMaybe opt $ Just $ mkAnn (fromString (show prec)) (Precedence prec)) (mkAnnList (separatedBy ", " list) [op])
 
 -- | Creates a non-associative fixity declaration (@ infix 5 +, - @).
-mkInfix :: Int -> Operator dom -> FixitySignature dom
+mkInfix :: Int -> Operator -> FixitySignature
 mkInfix prec op = mkAnn (child <> " " <> child <> " " <> child)
                     $ UFixitySignature (mkAnn "infix" AssocNone) (mkAnnMaybe opt $ Just $ mkAnn (fromString (show prec)) (Precedence prec)) (mkAnnList (separatedBy ", " list) [op])
 
 -- | Creates an unguarded right-hand-side (@ = 3 @)
-mkUnguardedRhs :: Expr dom -> Rhs dom
+mkUnguardedRhs :: Expr -> Rhs
 mkUnguardedRhs = mkAnn (" = " <> child) . UUnguardedRhs
 
 -- | Creates an unguarded right-hand-side (@ | x == 1 = 3; | otherwise = 4 @)
-mkGuardedRhss :: [GuardedRhs dom] -> Rhs dom
+mkGuardedRhss :: [GuardedRhs] -> Rhs
 mkGuardedRhss = mkAnn child . UGuardedRhss . mkAnnList (indented list)
 
 -- | Creates a guarded right-hand side of a value binding (@ | x > 3 = 2 @)
-mkGuardedRhs :: [RhsGuard dom] -> Expr dom -> GuardedRhs dom
+mkGuardedRhs :: [RhsGuard] -> Expr -> GuardedRhs
 mkGuardedRhs guards expr = mkAnn ("| " <> child <> " = " <> child) $ UGuardedRhs (mkAnnList (separatedBy ", " list) guards) expr
 
 -- | Creates a bind statement in a pattern guard (@ Just v <- x @)
-mkGuardBind :: Pattern dom -> Expr dom -> RhsGuard dom
+mkGuardBind :: Pattern -> Expr -> RhsGuard
 mkGuardBind pat expr = mkAnn (child <> " <- " <> child) $ UGuardBind pat expr
 
 -- | Creates a let statement in a pattern guard (@ let x = 3 @)
-mkGuardLet :: [LocalBind dom] -> RhsGuard dom
+mkGuardLet :: [LocalBind] -> RhsGuard
 mkGuardLet = mkAnn ("let " <> child) . UGuardLet . mkAnnList (indented list)
 
 -- | Creates an expression to check for a pattern guard
-mkGuardCheck :: Expr dom -> RhsGuard dom
+mkGuardCheck :: Expr -> RhsGuard
 mkGuardCheck = mkAnn child . UGuardCheck
 
 -- pragmas are omitted
Language/Haskell/Tools/Rewrite/Create/Decls.hs view
@@ -10,47 +10,47 @@ import Language.Haskell.Tools.Rewrite.ElementTypes
 
 -- | Creates a type synonym ( @type String = [Char]@ )
-mkTypeDecl :: DeclHead dom -> Type dom -> Decl dom
+mkTypeDecl :: DeclHead -> Type -> Decl
 mkTypeDecl dh typ = mkAnn (child <> " :: " <> child) $ UTypeDecl dh typ
 
 -- | Creates a standalone deriving declaration (@ deriving instance X T @)
-mkStandaloneDeriving :: Maybe (DeriveStrategy dom) -> Maybe (OverlapPragma dom) -> InstanceRule dom -> Decl dom
+mkStandaloneDeriving :: Maybe DeriveStrategy -> Maybe OverlapPragma -> InstanceRule -> Decl
 mkStandaloneDeriving strat overlap instRule 
   = mkAnn ("deriving instance" <> child <> child <> child)
       $ UDerivDecl (mkAnnMaybe (after " " opt) strat) (mkAnnMaybe (after " " opt) overlap) instRule
 
 -- | Creates a fixity declaration (@ infixl 5 +, - @)
-mkFixityDecl :: FixitySignature dom -> Decl dom
+mkFixityDecl :: FixitySignature -> Decl
 mkFixityDecl = mkAnn child . UFixityDecl
 
 -- | Creates default types (@ default (T1, T2) @)
-mkDefaultDecl :: [Type dom] -> Decl dom
+mkDefaultDecl :: [Type] -> Decl
 mkDefaultDecl = mkAnn ("default (" <> child <> ")") . UDefaultDecl . mkAnnList (separatedBy ", " list)
 
 -- | Creates type signature declaration (@ f :: Int -> Int @)
-mkTypeSigDecl :: TypeSignature dom -> Decl dom
+mkTypeSigDecl :: TypeSignature -> Decl
 mkTypeSigDecl = mkAnn child . UTypeSigDecl
 
 -- | Creates a function or value binding (@ f x = 12 @)
-mkValueBinding :: ValueBind dom -> Decl dom
+mkValueBinding :: ValueBind -> Decl
 mkValueBinding = mkAnn child . UValueBinding
 
 -- | Creates a Template Haskell splice declaration (@ $(generateDecls) @)
-mkSpliceDecl :: Splice dom -> Decl dom
+mkSpliceDecl :: Splice -> Decl
 mkSpliceDecl = mkAnn child . USpliceDecl
 
 -- * Data type definitions
 
 -- | Creates a data or newtype declaration.
-mkDataDecl :: DataOrNewtypeKeyword dom -> Maybe (Context dom) -> DeclHead dom -> [ConDecl dom] -> [Deriving dom] -> Decl dom
+mkDataDecl :: DataOrNewtypeKeyword -> Maybe Context -> DeclHead -> [ConDecl] -> [Deriving] -> Decl
 mkDataDecl keyw ctx dh cons derivs
   = mkAnn (child <> " " <> child <> child <> child <> child)
       $ UDataDecl keyw (mkAnnMaybe (after " " opt) ctx) dh
                  (mkAnnList (after " = " $ separatedBy " | " list) cons) (mkAnnList (indented list) derivs)
 
 -- | Creates a GADT-style data or newtype declaration.
-mkGADTDataDecl :: DataOrNewtypeKeyword dom -> Maybe (Context dom) -> DeclHead dom -> Maybe (KindConstraint dom)
-                    -> [GadtConDecl dom] -> [Deriving dom] -> Decl dom
+mkGADTDataDecl :: DataOrNewtypeKeyword -> Maybe Context -> DeclHead -> Maybe (KindConstraint)
+                    -> [GadtConDecl] -> [Deriving] -> Decl
 mkGADTDataDecl keyw ctx dh kind cons derivs
   = mkAnn (child <> " " <> child <> child <> child <> child <> child)
       $ UGDataDecl keyw (mkAnnMaybe (after " " opt) ctx) dh
@@ -58,52 +58,52 @@                   (mkAnnList (indented list) derivs)
 
 -- | Creates a GADT constructor declaration (@ D1 :: Int -> T String @)
-mkGadtConDecl :: [Name dom] -> Type dom -> GadtConDecl dom
+mkGadtConDecl :: [Name] -> Type -> GadtConDecl
 mkGadtConDecl names typ
   = mkAnn (child <> " :: " <> child <> child <> child)
       $ UGadtConDecl (mkAnnList (separatedBy ", " list) names) emptyList noth (mkAnn child $ UGadtNormalType typ)
 
 -- | Creates a GADT constructor declaration with record syntax (@ D1 :: { val :: Int } -> T String @)
-mkGadtRecordConDecl :: [Name dom] -> [FieldDecl dom] -> Type dom -> GadtConDecl dom
+mkGadtRecordConDecl :: [Name] -> [FieldDecl] -> Type -> GadtConDecl
 mkGadtRecordConDecl names flds typ
   = mkAnn (child <> " :: " <> child <> child <> child) $ UGadtConDecl (mkAnnList (separatedBy ", " list) names) emptyList noth
       $ mkAnn (child <> " -> " <> child)
       $ UGadtRecordType (mkAnnList (after "{ " $ separatedBy ", " $ followedBy " }" list) flds) typ
 
 -- | Creates an ordinary data constructor (@ C t1 t2 @)
-mkConDecl :: Name dom -> [Type dom] -> ConDecl dom
+mkConDecl :: Name -> [Type] -> ConDecl
 mkConDecl name args = mkAnn (child <> child <> child <> child) $ UConDecl emptyList noth name (mkAnnList (after " " $ separatedBy " " $ list) args)
 
 -- | Creates a record data constructor (@ Point { x :: Double, y :: Double } @)
-mkRecordConDecl :: Name dom -> [FieldDecl dom] -> ConDecl dom
+mkRecordConDecl :: Name -> [FieldDecl] -> ConDecl
 mkRecordConDecl name fields
   = mkAnn (child <> child <> child <> " { " <> child <> " }") $ URecordDecl emptyList noth name (mkAnnList (separatedBy ", " list) fields)
 
 -- | Creates an infix data constructor (@ t1 :+: t2 @)
-mkInfixConDecl :: Type dom -> Operator dom -> Type dom -> ConDecl dom
+mkInfixConDecl :: Type -> Operator -> Type -> ConDecl
 mkInfixConDecl lhs op rhs = mkAnn (child <> child <> child <> " " <> child <> " " <> child) $ UInfixConDecl emptyList noth lhs op rhs
 
 -- | Creates a field declaration (@ fld :: Int @) for a constructor
-mkFieldDecl :: [Name dom] -> Type dom -> FieldDecl dom
+mkFieldDecl :: [Name] -> Type -> FieldDecl
 mkFieldDecl names typ = mkAnn (child <> " :: " <> child) $ UFieldDecl (mkAnnList (separatedBy ", " list) names) typ
 
 -- | Creates a deriving clause following a data type declaration. (@ deriving Show @ or @ deriving (Show, Eq) @)
-mkDeriving :: [InstanceHead dom] -> Deriving dom
+mkDeriving :: [InstanceHead] -> Deriving
 mkDeriving [deriv] = mkAnn (" deriving " <> child <> child) $ UDerivingOne noth deriv
 mkDeriving derivs = mkAnn (" deriving " <> child <> " (" <> child <> ")") $ UDerivings noth (mkAnnList (separatedBy ", " list) derivs)
 
 -- | The @data@ keyword in a type definition
-mkDataKeyword :: DataOrNewtypeKeyword dom
+mkDataKeyword :: DataOrNewtypeKeyword
 mkDataKeyword = mkAnn "data" UDataKeyword
 
 -- | The @newtype@ keyword in a type definition
-mkNewtypeKeyword :: DataOrNewtypeKeyword dom
+mkNewtypeKeyword :: DataOrNewtypeKeyword
 mkNewtypeKeyword = mkAnn "newtype" UNewtypeKeyword
 
 -- * Class declarations
 
 -- | Creates a type class declaration (@ class X a where f = ... @)
-mkClassDecl :: Maybe (Context dom) -> DeclHead dom -> [FunDep dom] -> Maybe (ClassBody dom) -> Decl dom
+mkClassDecl :: Maybe Context -> DeclHead -> [FunDep] -> Maybe ClassBody -> Decl
 mkClassDecl ctx dh funDeps body
   = let fdeps = case funDeps of [] -> Nothing
                                 _ -> Just $ mkAnn child $ UFunDeps $ mkAnnList (separatedBy ", " list) funDeps
@@ -111,248 +111,248 @@           $ UClassDecl (mkAnnMaybe (followedBy " " opt) ctx) dh (mkAnnMaybe (after " | " opt) fdeps) (mkAnnMaybe opt body)
 
 -- | Creates the list of declarations that can appear in a typeclass
-mkClassBody :: [ClassElement dom] -> ClassBody dom
+mkClassBody :: [ClassElement] -> ClassBody
 mkClassBody = mkAnn (" where " <> child) . UClassBody . mkAnnList (indented list)
 
 -- | Creates a type signature as class element: @ f :: A -> B @
-mkClassElemSig :: TypeSignature dom -> ClassElement dom
+mkClassElemSig :: TypeSignature -> ClassElement
 mkClassElemSig = mkAnn child . UClsSig
 
 -- | Creates a default binding as class element: @ f x = "aaa" @
-mkClassElemDef :: ValueBind dom -> ClassElement dom
+mkClassElemDef :: ValueBind -> ClassElement
 mkClassElemDef = mkAnn child . UClsDef
 
 -- | Creates an associated type synonym in class: @ type T y :: * @
-mkClassElemTypeFam :: DeclHead dom -> Maybe (TypeFamilySpec dom) -> ClassElement dom
+mkClassElemTypeFam :: DeclHead -> Maybe TypeFamilySpec -> ClassElement
 mkClassElemTypeFam dh tfSpec = mkAnn ("type " <> child) $ UClsTypeFam (mkAnn (child <> child) $ UTypeFamily dh (mkAnnMaybe opt tfSpec))
 
 -- | Creates an associated data synonym in class: @ data T y :: * @
-mkClassElemDataFam :: DeclHead dom -> Maybe (KindConstraint dom) -> ClassElement dom
+mkClassElemDataFam :: DeclHead -> Maybe KindConstraint -> ClassElement
 mkClassElemDataFam dh kind = mkAnn ("data " <> child) $ UClsTypeFam (mkAnn (child <> child) $ UDataFamily dh (mkAnnMaybe opt kind))
 
 -- | Creates a default choice for type synonym in class: @ type T x = TE @ or @ type instance T x = TE @
-mkClsDefaultType :: DeclHead dom -> Type dom -> ClassElement dom
+mkClsDefaultType :: DeclHead -> Type -> ClassElement
 mkClsDefaultType dh typ = mkAnn ("type " <> child <> " = " <> child) $ UClsTypeDef dh typ
 
 -- | Creates a default signature (by using @DefaultSignatures@) in class: @ default enum :: (Generic a, GEnum (Rep a)) => [a] @
-mkClsDefaultSig :: Name dom -> Type dom -> ClassElement dom
+mkClsDefaultSig :: Name -> Type -> ClassElement
 mkClsDefaultSig dh typ = mkAnn ("default " <> child <> " :: " <> child) $ UClsDefSig dh typ
 
 -- | Creates a functional dependency, given on the form @l1 ... ln -> r1 ... rn@
-mkFunDep :: [Name dom] -> [Name dom] -> FunDep dom
+mkFunDep :: [Name] -> [Name] -> FunDep
 mkFunDep lhss rhss = mkAnn (child <> " -> " <> child)
                        $ UFunDep (mkAnnList (separatedBy ", " list) lhss) (mkAnnList (separatedBy ", " list) rhss)
 
 -- | Minimal pragma: @ {-\# MINIMAL (==) | (/=) \#-} @ in a class
-mkClsMinimal :: MinimalFormula dom -> ClassElement dom
+mkClsMinimal :: MinimalFormula -> ClassElement
 mkClsMinimal = mkAnn ("{-# MINIMAL " <> child <> " #-}") . UClsMinimal
 
-mkMinimalName :: Name dom -> MinimalFormula dom
+mkMinimalName :: Name -> MinimalFormula
 mkMinimalName = mkAnn child . UMinimalName
 
-mkMinimalParen :: MinimalFormula dom -> MinimalFormula dom
+mkMinimalParen :: MinimalFormula -> MinimalFormula
 mkMinimalParen = mkAnn ("(" <> child <> ")") . UMinimalParen
 
 -- | One of the minimal formulas are needed (@ min1 | min2 @)
-mkMinimalOr :: [MinimalFormula dom] -> MinimalFormula dom
+mkMinimalOr :: [MinimalFormula] -> MinimalFormula
 mkMinimalOr = mkAnn child . UMinimalOr . mkAnnList (separatedBy " | " list)
 
 -- | Both of the minimal formulas are needed (@ min1 , min2 @)
-mkMinimalAnd :: [MinimalFormula dom] -> MinimalFormula dom
+mkMinimalAnd :: [MinimalFormula] -> MinimalFormula
 mkMinimalAnd = mkAnn child . UMinimalAnd . mkAnnList (separatedBy ", " list)
 
 -- * Declaration heads
 
 -- | Type or class name as a declaration head
-mkNameDeclHead :: Name dom -> DeclHead dom
+mkNameDeclHead :: Name -> DeclHead
 mkNameDeclHead = mkAnn child . UDeclHead
 
 -- | Parenthesized type as a declaration head
-mkParenDeclHead :: DeclHead dom -> DeclHead dom
+mkParenDeclHead :: DeclHead -> DeclHead
 mkParenDeclHead = mkAnn child . UDHParen
 
 -- | Application in a declaration head
-mkDeclHeadApp :: DeclHead dom -> TyVar dom -> DeclHead dom
+mkDeclHeadApp :: DeclHead -> TyVar -> DeclHead
 mkDeclHeadApp dh tv = mkAnn (child <> " " <> child) $ UDHApp dh tv
 
 -- | Infix application of the type/class name to the left operand in a declaration head
-mkInfixDeclHead :: TyVar dom -> Operator dom -> TyVar dom -> DeclHead dom
+mkInfixDeclHead :: TyVar -> Operator -> TyVar -> DeclHead
 mkInfixDeclHead lhs op rhs = mkAnn (child <> " " <> child <> " " <> child) $ UDHInfix lhs op rhs
 
 -- * Type class instance declarations
 
 -- | Creates a type class instance declaration (@ instance X T [where f = ...] @)
-mkInstanceDecl :: Maybe (OverlapPragma dom) -> InstanceRule dom -> Maybe (InstBody dom) -> Decl dom
+mkInstanceDecl :: Maybe OverlapPragma -> InstanceRule -> Maybe InstBody -> Decl
 mkInstanceDecl overlap instRule body = mkAnn ("instance " <> child <> child <> child)
                                  $ UInstDecl (mkAnnMaybe (after " " opt) overlap) instRule (mkAnnMaybe opt body)
 
 -- | The instance declaration rule, which is, roughly, the part of the instance declaration before the where keyword.
-mkInstanceRule :: Maybe (Context dom) -> InstanceHead dom -> InstanceRule dom
+mkInstanceRule :: Maybe Context -> InstanceHead -> InstanceRule
 mkInstanceRule ctx ih
   = mkAnn (child <> child <> child) $ UInstanceRule (mkAnnMaybe (after " " opt) Nothing) (mkAnnMaybe (after " " opt) ctx) ih
 
 -- | Type or class name as a part of the instance declaration
-mkInstanceHead :: Name dom -> InstanceHead dom
+mkInstanceHead :: Name -> InstanceHead
 mkInstanceHead = mkAnn child . UInstanceHeadCon
 
 -- | Infix application of the type/class name to the left operand as a part of the instance declaration
-mkInfixInstanceHead :: Type dom -> Operator dom -> InstanceHead dom
+mkInfixInstanceHead :: Type -> Operator -> InstanceHead
 mkInfixInstanceHead typ n = mkAnn (child <> child) $ UInstanceHeadInfix typ n
 
 -- | Parenthesized instance head as a part of the instance declaration
-mkParenInstanceHead :: InstanceHead dom -> InstanceHead dom
+mkParenInstanceHead :: InstanceHead -> InstanceHead
 mkParenInstanceHead = mkAnn ("(" <> child <> ")") . UInstanceHeadParen
 
 -- | Application to one more type as a part of the instance declaration
-mkAppInstanceHead :: InstanceHead dom -> Type dom -> InstanceHead dom
+mkAppInstanceHead :: InstanceHead -> Type -> InstanceHead
 mkAppInstanceHead fun arg = mkAnn (child <> " " <> child) $ UInstanceHeadApp fun arg
 
 -- | Instance body is the implementation of the class functions (@ where a x = 1; b x = 2 @)
-mkInstanceBody :: [InstBodyDecl dom] -> InstBody dom
+mkInstanceBody :: [InstBodyDecl] -> InstBody
 mkInstanceBody = mkAnn (" where " <> child) . UInstBody . mkAnnList (indented list)
 
 -- | A normal declaration (@ f x = 12 @) in a type class instance
-mkInstanceBind :: ValueBind dom -> InstBodyDecl dom
+mkInstanceBind :: ValueBind -> InstBodyDecl
 mkInstanceBind = mkAnn child . UInstBodyNormalDecl
 
 -- | Type signature in instance definition with @InstanceSigs@
-mkInstanceTypeSig :: TypeSignature dom -> InstBodyDecl dom
+mkInstanceTypeSig :: TypeSignature -> InstBodyDecl
 mkInstanceTypeSig = mkAnn child . UInstBodyTypeSig
 
 -- | An associated type definition (@ type A X = B @) in a type class instance
-mkInstanceTypeFamilyDef :: TypeEqn dom -> InstBodyDecl dom
+mkInstanceTypeFamilyDef :: TypeEqn -> InstBodyDecl
 mkInstanceTypeFamilyDef = mkAnn child . UInstBodyTypeDecl
 
 -- | An associated data type implementation (@ data A X = C1 | C2 @) int a type class instance
-mkInstanceDataFamilyDef :: DataOrNewtypeKeyword dom -> InstanceRule dom -> [ConDecl dom] -> [Deriving dom] -> InstBodyDecl dom
+mkInstanceDataFamilyDef :: DataOrNewtypeKeyword -> InstanceRule -> [ConDecl] -> [Deriving] -> InstBodyDecl
 mkInstanceDataFamilyDef keyw instRule cons derivs
   = mkAnn (child <> " " <> child <> child <> child)
       $ UInstBodyDataDecl keyw instRule (mkAnnList (after " = " $ separatedBy " | " list) cons)
                                         (mkAnnList (indented list) derivs)
 
 -- | An associated data type implemented using GADT style int a type class instance
-mkInstanceDataFamilyGADTDef :: DataOrNewtypeKeyword dom -> InstanceRule dom -> Maybe (KindConstraint dom) -> [GadtConDecl dom]
-                                 -> [Deriving dom] -> InstBodyDecl dom
+mkInstanceDataFamilyGADTDef :: DataOrNewtypeKeyword -> InstanceRule -> Maybe KindConstraint -> [GadtConDecl]
+                                 -> [Deriving] -> InstBodyDecl
 mkInstanceDataFamilyGADTDef keyw instRule kind cons derivs
   = mkAnn (child <> " " <> child <> child <> child)
       $ UInstBodyGadtDataDecl keyw instRule (mkAnnMaybe opt kind) (mkAnnList (after " = " $ separatedBy " | " list) cons)
                              (mkAnnList (indented list) derivs)
 
 -- | Specialize instance pragma (no phase selection is allowed) in a type class instance
-mkInstanceSpecializePragma :: Type dom -> InstBodyDecl dom
+mkInstanceSpecializePragma :: Type -> InstBodyDecl
 mkInstanceSpecializePragma = mkAnn ("{-# SPECIALIZE " <> child <> " #-}") . USpecializeInstance
 
 -- | @OVERLAP@ pragma for type instance definitions
-mkEnableOverlap :: OverlapPragma dom
+mkEnableOverlap :: OverlapPragma
 mkEnableOverlap = mkAnn "{-# OVERLAP #-}" UEnableOverlap
 
 -- | @NO_OVERLAP@ pragma for type instance definitions
-mkDisableOverlap :: OverlapPragma dom
+mkDisableOverlap :: OverlapPragma
 mkDisableOverlap = mkAnn "{-# NO_OVERLAP #-}" UDisableOverlap
 
 -- | @OVERLAPPABLE@ pragma for type instance definitions
-mkOverlappable :: OverlapPragma dom
+mkOverlappable :: OverlapPragma
 mkOverlappable = mkAnn "{-# OVERLAPPABLE #-}" UOverlappable
 
 -- | @OVERLAPPING@ pragma for type instance definitions
-mkOverlapping :: OverlapPragma dom
+mkOverlapping :: OverlapPragma
 mkOverlapping = mkAnn "{-# OVERLAPPING #-}" UOverlapping
 
 -- | @OVERLAPS@ pragma for type instance definitions
-mkOverlaps :: OverlapPragma dom
+mkOverlaps :: OverlapPragma
 mkOverlaps = mkAnn "{-# OVERLAPS #-}" UOverlaps
 
 -- | @INCOHERENT@ pragma for type instance definitions
-mkIncoherentOverlap :: OverlapPragma dom
+mkIncoherentOverlap :: OverlapPragma
 mkIncoherentOverlap = mkAnn "{-# INCOHERENT #-}" UIncoherentOverlap
 
 -- * Type roles
 
 -- | Creates a role annotations (@ type role Ptr representational @)
-mkRoleDecl :: QualifiedName dom -> [Role dom] -> Decl dom
+mkRoleDecl :: QualifiedName -> [Role] -> Decl
 mkRoleDecl name roles
   = mkAnn ("type role " <> child <> child) $ URoleDecl name $ mkAnnList (separatedBy " " $ after " " list) roles
 
 -- | Marks a given type parameter as @nominal@.
-mkNominalRole :: Role dom
+mkNominalRole :: Role
 mkNominalRole = mkAnn "nominal" UNominal
 
 -- | Marks a given type parameter as @representational@.
-mkRepresentationalRole :: Role dom
+mkRepresentationalRole :: Role
 mkRepresentationalRole = mkAnn "representational" URepresentational
 
 -- | Marks a given type parameter as @phantom@.
-mkPhantomRole :: Role dom
+mkPhantomRole :: Role
 mkPhantomRole = mkAnn "phantom" UPhantom
 
 -- * Foreign imports and exports
 
 -- | Creates a foreign import (@ foreign import foo :: Int -> IO Int @)
-mkForeignImport :: CallConv dom -> Maybe (Safety dom) -> Name dom -> Type dom -> Decl dom
+mkForeignImport :: CallConv -> Maybe Safety -> Name -> Type -> Decl
 mkForeignImport cc safety name typ = mkAnn (child <> child <> " " <> child <> " :: " <> child)
                                        $ UForeignImport cc (mkAnnMaybe (after " " opt) safety) name typ
 
 -- | Creates a foreign export (@ foreign export ccall foo :: Int -> IO Int @)
-mkForeignExport :: CallConv dom -> Name dom -> Type dom -> Decl dom
+mkForeignExport :: CallConv -> Name -> Type -> Decl
 mkForeignExport cc name typ = mkAnn (child <> " " <> child <> " :: " <> child) $ UForeignExport cc name typ
 
 -- | Specifies @stdcall@ calling convention for foreign import/export.
-mkStdCall :: CallConv dom
+mkStdCall :: CallConv
 mkStdCall = mkAnn "stdcall" UStdCall
 
 -- | Specifies @ccall@ calling convention for foreign import/export.
-mkCCall :: CallConv dom
+mkCCall :: CallConv
 mkCCall = mkAnn "ccall" UCCall
 
 -- | Specifies @capi@ calling convention for foreign import/export.
-mkCApi :: CallConv dom
+mkCApi :: CallConv
 mkCApi = mkAnn "capi" UCApi
 
 -- | Specifies that the given foreign import is @unsafe@.
-mkUnsafe :: Safety dom
+mkUnsafe :: Safety
 mkUnsafe = mkAnn "unsafe" UUnsafe
 
 -- * Type and data families
 
 -- | Creates a type family declaration ( @type family F x@ )
-mkTypeFamily :: DeclHead dom -> Maybe (TypeFamilySpec dom) -> Decl dom
+mkTypeFamily :: DeclHead -> Maybe TypeFamilySpec -> Decl
 mkTypeFamily dh famSpec = mkAnn child $ UTypeFamilyDecl (mkAnn (child <> child) $ UTypeFamily dh (mkAnnMaybe (after " " opt) famSpec))
 
 -- | Creates a closed type family declaration ( @type family F x where F Int = (); F a = Int@ )
-mkClosedTypeFamily :: DeclHead dom -> Maybe (TypeFamilySpec dom) -> [TypeEqn dom] -> Decl dom
+mkClosedTypeFamily :: DeclHead -> Maybe TypeFamilySpec -> [TypeEqn] -> Decl
 mkClosedTypeFamily dh kind typeqs = mkAnn (child <> child <> " where " <> child)
                                       $ UClosedTypeFamilyDecl dh (mkAnnMaybe (after " " opt) kind) (mkAnnList (indented list) typeqs)
 
 -- | Creates a data family declaration (@ data family A a :: * -> * @)
-mkDataFamily :: DeclHead dom -> Maybe (KindConstraint dom) -> Decl dom
+mkDataFamily :: DeclHead -> Maybe KindConstraint -> Decl
 mkDataFamily dh kind = mkAnn child $ UTypeFamilyDecl (mkAnn (child <> child) $ UDataFamily dh (mkAnnMaybe (after " " opt) kind))
 
 -- | Specifies the kind of a type family (@ :: * -> * @)
-mkTypeFamilyKindSpec :: KindConstraint dom -> TypeFamilySpec dom
+mkTypeFamilyKindSpec :: KindConstraint -> TypeFamilySpec
 mkTypeFamilyKindSpec = mkAnn child . UTypeFamilyKind
 
 -- | Specifies the injectivity of a type family (@ = r | r -> a @)
-mkTypeFamilyInjectivitySpec :: TyVar dom -> [Name dom] -> TypeFamilySpec dom
+mkTypeFamilyInjectivitySpec :: TyVar -> [Name] -> TypeFamilySpec
 mkTypeFamilyInjectivitySpec res dependent
   = mkAnn child (UTypeFamilyInjectivity $ mkAnn (child <> " -> " <> child) $ UInjectivityAnn res (mkAnnList (separatedBy " " list) dependent))
 
 -- | Type equations as found in closed type families (@ T A = S @)
-mkTypeEqn :: Type dom -> Type dom -> TypeEqn dom
+mkTypeEqn :: Type -> Type -> TypeEqn
 mkTypeEqn lhs rhs = mkAnn (child <> " = " <> child) $ UTypeEqn lhs rhs
 
 -- | Creates a type family instance declaration (@ type instance Fam T = AssignedT @)
-mkTypeInstance :: InstanceRule dom -> Type dom -> Decl dom
+mkTypeInstance :: InstanceRule -> Type -> Decl
 mkTypeInstance instRule typ = mkAnn ("type instance " <> child <> " = " <> child) $ UTypeInstDecl instRule typ
 
 -- | Creates a data instance declaration (@ data instance Fam T = Con1 | Con2 @)
-mkDataInstance :: DataOrNewtypeKeyword dom -> InstanceRule dom -> [ConDecl dom] -> [Deriving dom] -> Decl dom
+mkDataInstance :: DataOrNewtypeKeyword -> InstanceRule -> [ConDecl] -> [Deriving] -> Decl
 mkDataInstance keyw instRule cons derivs
   = mkAnn (child <> " instance " <> child <> " = " <> child <> child)
       $ UDataInstDecl keyw instRule (mkAnnList (after " = " $ separatedBy " | " list) cons)
                                     (mkAnnList (indented list) derivs)
 
 -- | Creates a GADT-style data instance declaration (@ data instance Fam T where ... @)
-mkGadtDataInstance :: DataOrNewtypeKeyword dom -> InstanceRule dom -> Maybe (KindConstraint dom) -> [GadtConDecl dom] -> Decl dom
+mkGadtDataInstance :: DataOrNewtypeKeyword -> InstanceRule -> Maybe KindConstraint -> [GadtConDecl] -> Decl
 mkGadtDataInstance keyw instRule kind cons
   = mkAnn (child <> " instance " <> child <> child <> " where " <> child)
       $ UGDataInstDecl keyw instRule (mkAnnMaybe (after " " opt) kind) (mkAnnList (indented list) cons)
@@ -360,41 +360,41 @@ -- * Pattern synonyms
 
 -- | Creates a pattern synonym (@ pattern Arrow t1 t2 = App \"->\" [t1, t2] @)
-mkPatternSynonym :: PatSynLhs dom -> PatSynRhs dom -> Decl dom
+mkPatternSynonym :: PatSynLhs -> PatSynRhs -> Decl
 mkPatternSynonym lhs rhs = mkAnn child $ UPatternSynonymDecl $ mkAnn ("pattern " <> child <> " " <> child)
                                                              $ UPatternSynonym lhs rhs
 
 -- | Creates a left hand side of a pattern synonym with a constructor name and arguments (@ Arrow t1 t2 @)
-mkConPatSyn :: Name dom -> [Name dom] -> PatSynLhs dom
+mkConPatSyn :: Name -> [Name] -> PatSynLhs
 mkConPatSyn con args = mkAnn (child <> child) $ UNormalPatSyn con $ mkAnnList (after " " $ separatedBy " " list) args
 
 -- | Creates an infix pattern synonym left-hand side (@ t1 :+: t2 @)
-mkInfixPatSyn :: Name dom -> Operator dom -> Name dom -> PatSynLhs dom
+mkInfixPatSyn :: Name -> Operator -> Name -> PatSynLhs
 mkInfixPatSyn lhs op rhs = mkAnn (child <> " " <> child <> " " <> child) $ UInfixPatSyn lhs op rhs
 
 -- | Creates a record-style pattern synonym left-hand side (@ Arrow { arrowFrom, arrowTo } @)
-mkRecordPatSyn :: Name dom -> [Name dom] -> PatSynLhs dom
+mkRecordPatSyn :: Name -> [Name] -> PatSynLhs
 mkRecordPatSyn con args
   = mkAnn (child <> child) $ URecordPatSyn con $ mkAnnList (after "{ " $ separatedBy ", " $ followedBy " }" list) args
 
 -- | Creates an automatically two-way pattern synonym (@ = App \"Int\" [] @)
-mkSymmetricPatSyn :: Pattern dom -> PatSynRhs dom
+mkSymmetricPatSyn :: Pattern -> PatSynRhs
 mkSymmetricPatSyn = mkAnn ("= " <> child) . flip UBidirectionalPatSyn (mkAnnMaybe opt Nothing)
 
 -- | Creates a pattern synonym that can be only used for pattenr matching but not for combining (@ <- App \"Int\" [] @)
-mkOneWayPatSyn :: Pattern dom -> PatSynRhs dom
+mkOneWayPatSyn :: Pattern -> PatSynRhs
 mkOneWayPatSyn = mkAnn ("<- " <> child) . UOneDirectionalPatSyn
 
 -- | Creates a pattern synonym with the other direction explicitly specified (@ <- App \"Int\" [] where Int = App \"Int\" [] @)
-mkTwoWayPatSyn :: Pattern dom -> [Match dom] -> PatSynRhs dom
+mkTwoWayPatSyn :: Pattern -> [Match] -> PatSynRhs
 mkTwoWayPatSyn pat match = mkAnn ("<- " <> child <> child) $ UBidirectionalPatSyn pat $ mkAnnMaybe (after " where " opt)
                              $ Just $ mkAnn child $ UPatSynWhere $ mkAnnList (indented list) match
 
 -- | Creates a pattern type signature declaration (@ pattern Succ :: Int -> Int @)
-mkPatternSignatureDecl :: PatternSignature dom -> Decl dom
+mkPatternSignatureDecl :: PatternSignature -> Decl
 mkPatternSignatureDecl = mkAnn child . UPatTypeSigDecl
 
-mkPatternSignature :: [Name dom] -> Type dom -> PatternSignature dom
+mkPatternSignature :: [Name] -> Type -> PatternSignature
 mkPatternSignature names typ
   = mkAnn (child <> " :: " <> child)
       $ UPatternTypeSignature (mkAnnList (separatedBy ", " list) names) typ
@@ -402,92 +402,92 @@ -- * Top level pragmas
 
 -- | Creates a top-level pragmas
-mkPragmaDecl :: TopLevelPragma dom -> Decl dom
+mkPragmaDecl :: TopLevelPragma -> Decl
 mkPragmaDecl = mkAnn child . UPragmaDecl
 
 -- | A pragma that introduces source rewrite rules (@ {-\# RULES "map/map" [2]  forall f g xs. map f (map g xs) = map (f.g) xs \#-} @)
-mkRulePragma :: [Rule dom] -> TopLevelPragma dom
+mkRulePragma :: [Rule] -> TopLevelPragma
 mkRulePragma = mkAnn ("{-# RULES " <> child <> " #-}") . URulePragma . mkAnnList (separatedBy ", " list)
 
 -- | A pragma that marks definitions as deprecated (@ {-\# DEPRECATED f "f will be replaced by g" \#-} @)
-mkDeprPragma :: [Name dom] -> String -> TopLevelPragma dom
+mkDeprPragma :: [Name] -> String -> TopLevelPragma
 mkDeprPragma defs msg = mkAnn ("{-# DEPRECATED " <> child <> " " <> child <> " #-}")
                           $ UDeprPragma (mkAnnList (separatedBy ", " list) defs)
                              (mkAnnList (separatedBy ", " list) [mkAnn ("\"" <> child <> "\"") $ UStringNode msg])
 
 -- | A pragma that marks definitions as deprecated (@ {-\# WARNING unsafePerformIO "you should know what you are doing" \#-} @)
-mkWarningPragma :: [Name dom] -> String -> TopLevelPragma dom
+mkWarningPragma :: [Name] -> String -> TopLevelPragma
 mkWarningPragma defs msg = mkAnn ("{-# WARNING " <> child <> " " <> child <> " #-}")
                              $ UWarningPragma (mkAnnList (separatedBy ", " list) defs)
                                 (mkAnnList (separatedBy ", " list) [mkAnn ("\"" <> child <> "\"") $ UStringNode msg])
 
 -- | A pragma that annotates a definition with an arbitrary value (@ {-\# ANN f 42 \#-} @)
-mkAnnPragma :: AnnotationSubject dom -> Expr dom -> TopLevelPragma dom
+mkAnnPragma :: AnnotationSubject -> Expr -> TopLevelPragma
 mkAnnPragma subj ann = mkAnn ("{-# ANN " <> child <> " " <> child <> " #-}") $ UAnnPragma subj ann
 
 -- | A pragma that marks a function for inlining to the compiler (@ {-\# INLINE thenUs \#-} @)
-mkInlinePragma :: Maybe (ConlikeAnnot dom) -> Maybe (PhaseControl dom) -> Name dom -> TopLevelPragma dom
+mkInlinePragma :: Maybe (ConlikeAnnot) -> Maybe (PhaseControl) -> Name -> TopLevelPragma
 mkInlinePragma conlike phase name
   = mkAnn ("{-# INLINE " <> child <> child <> child <> " #-}") $ UInlinePragmaDecl
       $ mkAnn child $ UInlinePragma (mkAnnMaybe (followedBy " " opt) conlike) (mkAnnMaybe (followedBy " " opt) phase) name
 
 -- | A pragma that forbids a function from being inlined by the compiler (@ {-\# NOINLINE f \#-} @)
-mkNoInlinePragma :: Name dom -> TopLevelPragma dom
+mkNoInlinePragma :: Name -> TopLevelPragma
 mkNoInlinePragma name = mkAnn ("{-# NOINLINE " <> child <> " #-}") $ UInlinePragmaDecl
       $ mkAnn child $ UNoInlinePragma name
 
 -- | A pragma that marks a function that it may be inlined by the compiler (@ {-\# INLINABLE thenUs \#-} @)
-mkInlinablePragma :: Maybe (PhaseControl dom) -> Name dom -> TopLevelPragma dom
+mkInlinablePragma :: Maybe (PhaseControl) -> Name -> TopLevelPragma
 mkInlinablePragma phase name
   = mkAnn ("{-# INLINEABLE " <> child <> child <> " #-}") $ UInlinePragmaDecl
       $ mkAnn child $ UInlinablePragma (mkAnnMaybe (followedBy " " opt) phase) name
 
 -- | A pragma for maintaining line numbers in generated sources (@ {-\# LINE 123 "somefile" \#-} @)
-mkLinePragma :: Int -> Maybe (StringNode dom) -> TopLevelPragma dom
+mkLinePragma :: Int -> Maybe (StringNode) -> TopLevelPragma
 mkLinePragma line filename
   = mkAnn ("{-# LINE " <> child <> child <> " #-}")
      $ ULinePragma (mkAnn child $ LineNumber line) (mkAnnMaybe (after " " opt) filename)
 
 -- | A pragma that tells the compiler that a polymorph function should be optimized for a given type (@ {-\# SPECIALISE f :: Int -> b -> b \#-} @)
-mkSpecializePragma :: Maybe (PhaseControl dom) -> Name dom -> [Type dom] -> TopLevelPragma dom
+mkSpecializePragma :: Maybe PhaseControl -> Name -> [Type] -> TopLevelPragma
 mkSpecializePragma phase def specTypes
   = mkAnn child (USpecializeDecl
                   $ mkAnn ("{-# SPECIALIZE " <> child <> child <> " " <> child <> " #-}")
                     $ USpecializePragma (mkAnnMaybe (after " " opt) phase) def $ mkAnnList (separatedBy ", " list) specTypes)
 
 -- | Marks that the pragma should be applied from a given compile phase (@ [2] @)
-mkPhaseControlFrom :: Integer -> PhaseControl dom
+mkPhaseControlFrom :: Integer -> PhaseControl
 mkPhaseControlFrom phaseNum
   = mkAnn ("[" <> child <> child <> "]") $ UPhaseControl (mkAnnMaybe opt Nothing) (mkAnnMaybe opt $ Just $ mkAnn child $ PhaseNumber phaseNum)
 
 -- | Marks that the pragma should be applied until a given compile phase (@ [~2] @)
-mkPhaseControlUntil :: Integer -> PhaseControl dom
+mkPhaseControlUntil :: Integer -> PhaseControl
 mkPhaseControlUntil phaseNum
   = mkAnn ("[" <> child <> child <> "]") $ UPhaseControl (mkAnnMaybe opt $ Just $ mkAnn "~" PhaseInvert)
                                                          (mkAnnMaybe opt $ Just $ mkAnn child $ PhaseNumber phaseNum)
 
 -- | A rewrite rule (@ "map/map" forall f g xs. map f (map g xs) = map (f.g) xs @)
-mkRewriteRule :: String -> Maybe (PhaseControl dom) -> [RuleVar dom] -> Expr dom -> Expr dom -> Rule dom
+mkRewriteRule :: String -> Maybe PhaseControl -> [RuleVar] -> Expr -> Expr -> Rule
 mkRewriteRule name phase vars lhs rhs
   = mkAnn (child <> " " <> child <> child <> child <> " = " <> child)
       $ URule (mkAnn ("\"" <> child <> "\"") $ UStringNode name) (mkAnnMaybe (followedBy " " opt) phase)
               (mkAnnList (after "forall " $ separatedBy " " $ followedBy ". " list) (vars)) lhs rhs
 
-mkRuleVar :: Name dom -> RuleVar dom
+mkRuleVar :: Name -> RuleVar
 mkRuleVar name = mkAnn child (URuleVar name)
 
 -- | The definition with the given name is annotated
-mkNameAnnotation :: Name dom -> AnnotationSubject dom
+mkNameAnnotation :: Name -> AnnotationSubject
 mkNameAnnotation name = mkAnn child $ UNameAnnotation name
 
 -- | A type with the given name is annotated
-mkTypeAnnotation :: Name dom -> AnnotationSubject dom
+mkTypeAnnotation :: Name -> AnnotationSubject
 mkTypeAnnotation name = mkAnn ("type " <> child) $ UTypeAnnotation name
 
 -- | The whole module is annotated
-mkModuleAnnotation :: AnnotationSubject dom
+mkModuleAnnotation :: AnnotationSubject
 mkModuleAnnotation = mkAnn "module" UModuleAnnotation
 
 -- | A @CONLIKE@ modifier for an @INLINE@ pragma.
-mkConlikeAnnotation :: ConlikeAnnot dom
+mkConlikeAnnotation :: ConlikeAnnot
 mkConlikeAnnotation = mkAnn "CONLIKE" UConlikeAnnot
Language/Haskell/Tools/Rewrite/Create/Exprs.hs view
@@ -12,165 +12,165 @@ -- * Expressions
 
 -- | Create a expression for a variable or a data constructor (@ a @)
-mkVar :: Name dom -> Expr dom
+mkVar :: Name -> Expr
 mkVar = mkAnn child . UVar
 
 -- | Create a literal expression (@ 42 @)
-mkLit :: Literal dom -> Expr dom
+mkLit :: Literal -> Expr
 mkLit = mkAnn child . ULit
 
 -- | Create a infix operator application expression (@ a + b @)
-mkInfixApp :: Expr dom -> Operator dom -> Expr dom -> Expr dom
+mkInfixApp :: Expr -> Operator -> Expr -> Expr
 mkInfixApp lhs op rhs = mkAnn (child <> " " <> child <> " " <> child) $ UInfixApp lhs op rhs
 
 -- | Create a prefix operator application expression (@ -x @)
-mkPrefixApp :: Operator dom -> Expr dom -> Expr dom
+mkPrefixApp :: Operator -> Expr -> Expr
 mkPrefixApp op rhs = mkAnn (child <> child) $ UPrefixApp op rhs
 
 -- | Create a function application expression (@ f 4 @)
-mkApp :: Expr dom -> Expr dom -> Expr dom
+mkApp :: Expr -> Expr -> Expr
 mkApp f e = mkAnn (child <> " " <> child) (UApp f e)
 
 -- | Create a lambda expression (@ \\a b -> a + b @)
-mkLambda :: [Pattern dom] -> Expr dom -> Expr dom
+mkLambda :: [Pattern] -> Expr -> Expr
 mkLambda pats rhs = mkAnn ("\\" <> child <> " -> " <> child) $ ULambda (mkAnnList (separatedBy " " list) pats) rhs
 
 -- | Create a local binding (@ let x = 2; y = 3 in e x y @)
-mkLet :: [LocalBind dom] -> Expr dom -> Expr dom
+mkLet :: [LocalBind] -> Expr -> Expr
 mkLet pats expr = mkAnn ("let " <> child <> " in " <> child) $ ULet (mkAnnList (indented list) pats) expr
 
 -- | Create a if expression (@ if a then b else c @)
-mkIf :: Expr dom -> Expr dom -> Expr dom -> Expr dom
+mkIf :: Expr -> Expr -> Expr -> Expr
 mkIf cond then_ else_ = mkAnn ("if " <> child <> " then " <> child <> " else " <> child) $ UIf cond then_ else_
 
 -- | Create a multi way if expressions with @MultiWayIf@ extension (@ if | guard1 -> expr1; guard2 -> expr2 @)
-mkMultiIf :: [GuardedCaseRhs dom] -> Expr dom
+mkMultiIf :: [GuardedCaseRhs] -> Expr
 mkMultiIf cases = mkAnn ("if" <> child) $ UMultiIf (mkAnnList (indented list) cases)
 
 -- | Create a pattern matching expression (@ case expr of pat1 -> expr1; pat2 -> expr2 @)
-mkCase :: Expr dom -> [Alt dom] -> Expr dom
+mkCase :: Expr -> [Alt] -> Expr
 mkCase expr cases = mkAnn ("case " <> child <> " of " <> child) $ UCase expr (mkAnnList (indented list) cases)
 
 -- | Create a do-notation expressions (@ do x <- act1; act2 @)
-mkDoBlock :: [Stmt dom] -> Expr dom
+mkDoBlock :: [Stmt] -> Expr
 mkDoBlock stmts = mkAnn (child <> " " <> child) $ UDo (mkAnn "do" UDoKeyword) (mkAnnList (indented list) stmts)
 
 -- | Create a tuple expression (@ (e1, e2, e3) @)
-mkTuple :: [Expr dom] -> Expr dom
+mkTuple :: [Expr] -> Expr
 mkTuple exprs = mkAnn ("(" <> child <> ")") $ UTuple (mkAnnList (separatedBy ", " list) exprs)
 
 -- | Create a unboxed tuple expression (@ (\# e1, e2, e3 \#) @)
-mkUnboxedTuple :: [Expr dom] -> Expr dom
+mkUnboxedTuple :: [Expr] -> Expr
 mkUnboxedTuple exprs = mkAnn ("(# " <> child <> " #)") $ UTuple (mkAnnList (separatedBy ", " list) exprs)
 
 -- | Create a tuple section, enabled with @TupleSections@ (@ (a,,b) @). One of the elements must be missing.
-mkTupleSection :: [Maybe (Expr dom)] -> Expr dom
+mkTupleSection :: [Maybe Expr] -> Expr
 mkTupleSection elems 
   = let tupSecs = map (maybe (mkAnn "" Missing) (mkAnn child . Present)) elems
      in mkAnn ("(" <> child <> ")") $ UTupleSection (mkAnnList (separatedBy ", " list) tupSecs)
 
 -- | Create a unboxed tuple section, enabled with @TupleSections@ (@ (\#a,,b\#) @). One of the elements must be missing.
-mkTupleUnboxedSection :: [Maybe (Expr dom)] -> Expr dom
+mkTupleUnboxedSection :: [Maybe Expr] -> Expr
 mkTupleUnboxedSection elems 
   = let tupSecs = map (maybe (mkAnn "" Missing) (mkAnn child . Present)) elems
      in mkAnn ("(" <> child <> ")") $ UTupleSection (mkAnnList (separatedBy ", " list) tupSecs)
 
 -- | Create a list expression: @[1,2,3]@
-mkList :: [Expr dom] -> Expr dom
+mkList :: [Expr] -> Expr
 mkList exprs = mkAnn ("[" <> child <> "]") $ UList (mkAnnList (separatedBy ", " list) exprs)
 
 -- | Create a parallel array expression: @[: 1,2,3 :]@
-mkParArray :: [Expr dom] -> Expr dom
+mkParArray :: [Expr] -> Expr
 mkParArray exprs = mkAnn ("[: " <> child <> " :]") $ UParArray (mkAnnList (separatedBy ", " list) exprs)
 
 -- | Create a parenthesized expression: @( a + b )@
-mkParen :: Expr dom -> Expr dom
+mkParen :: Expr -> Expr
 mkParen = mkAnn ("(" <> child <> ")") . UParen
 
 -- | Create a left operator section: @(1+)@
-mkLeftSection :: Expr dom -> Operator dom -> Expr dom
+mkLeftSection :: Expr -> Operator -> Expr
 mkLeftSection lhs op = mkAnn ("(" <> child <> " " <> child <> ")") $ ULeftSection lhs op
 
 -- | Create a right operator section: @(+1)@
-mkRightSection :: Operator dom -> Expr dom -> Expr dom
+mkRightSection :: Operator -> Expr -> Expr
 mkRightSection op rhs = mkAnn ("(" <> child <> " " <> child <> ")") $ URightSection op rhs
 
 -- | Create a record value construction: @Point { x = 3, y = -2 }@
-mkRecCon :: Name dom -> [FieldUpdate dom] -> Expr dom
+mkRecCon :: Name -> [FieldUpdate] -> Expr
 mkRecCon name flds = mkAnn (child <> " { " <> child <> " }") $ URecCon name (mkAnnList (separatedBy ", " list) flds)
 
 -- | Create a record value  update: @p1 { x = 3, y = -2 }@
-mkRecUpdate :: Expr dom -> [FieldUpdate dom] -> Expr dom
+mkRecUpdate :: Expr -> [FieldUpdate] -> Expr
 mkRecUpdate expr flds = mkAnn (child <> " { " <> child <> " }") $ URecUpdate expr (mkAnnList (separatedBy ", " list) flds)
 
 -- | Create a enumeration expression (@ [1,3..10] @)
-mkEnum :: Expr dom -> Maybe (Expr dom) -> Maybe (Expr dom) -> Expr dom
+mkEnum :: Expr -> Maybe (Expr) -> Maybe (Expr) -> Expr
 mkEnum from step to = mkAnn ("[" <> child <> child <> ".." <> child <> "]") $ UEnum from (mkAnnMaybe (after "," opt) step) (mkAnnMaybe (after "," opt) to)
 
 -- | Create a parallel array enumeration (@ [: 1,3 .. 10 :] @)
-mkParArrayEnum :: Expr dom -> Maybe (Expr dom) -> Expr dom -> Expr dom
+mkParArrayEnum :: Expr -> Maybe (Expr) -> Expr -> Expr
 mkParArrayEnum from step to
   = mkAnn ("[: " <> child <> child <> ".." <> child <> " :]") 
       $ UParArrayEnum from (mkAnnMaybe (after "," opt) step) to
 
 -- | Create a list comprehension (@ [ (x, y) | x <- xs | y <- ys ] @)
-mkListComp :: Expr dom -> [ListCompBody dom] -> Expr dom
+mkListComp :: Expr -> [ListCompBody] -> Expr
 mkListComp expr stmts 
   = mkAnn ("[ " <> child <> " | " <> child <> " ]") 
       $ UListComp expr $ mkAnnList (separatedBy " | " list) stmts
 
 -- | Create a parallel array comprehensions @ [: (x, y) | x <- xs , y <- ys :] @ enabled by @ParallelArrays@
-mkParArrayComp :: Expr dom -> [ListCompBody dom] -> Expr dom
+mkParArrayComp :: Expr -> [ListCompBody] -> Expr
 mkParArrayComp expr stmts 
   = mkAnn ("[: " <> child <> " | " <> child <> " :]") 
       $ UParArrayComp expr $ mkAnnList (separatedBy " | " list) stmts
 
 -- | Create a explicit type signature (@ x :: Int @)
-mkExprTypeSig :: Expr dom -> Type dom -> Expr dom
+mkExprTypeSig :: Expr -> Type -> Expr
 mkExprTypeSig lhs typ = mkAnn (child <> " :: " <> child) $ UTypeSig lhs typ
 
 -- | Create a explicit type application (@ show \@Integer (read "5") @)
-mkExplicitTypeApp :: Expr dom -> Type dom -> Expr dom
+mkExplicitTypeApp :: Expr -> Type -> Expr
 mkExplicitTypeApp expr typ = mkAnn (child <> " @" <> child) $ UExplTypeApp expr typ
 
 -- | @'x@ for template haskell reifying of expressions
-mkVarQuote :: Name dom -> Expr dom
+mkVarQuote :: Name -> Expr
 mkVarQuote = mkAnn ("'" <> child) . UVarQuote
 
 -- | @''T@ for template haskell reifying of types
-mkTypeQuote :: Name dom -> Expr dom
+mkTypeQuote :: Name -> Expr
 mkTypeQuote = mkAnn ("''" <> child) . UTypeQuote
 
 -- | Create a template haskell bracket expression
-mkBracketExpr :: Bracket dom -> Expr dom
+mkBracketExpr :: Bracket -> Expr
 mkBracketExpr = mkAnn child . UBracketExpr
 
 -- | Create a template haskell splice expression, for example: @$(gen a)@ or @$x@
-mkSpliceExpr :: Splice dom -> Expr dom
+mkSpliceExpr :: Splice -> Expr
 mkSpliceExpr = mkAnn child . USplice
 
 -- | Create a template haskell quasi quote expression, for example: @[quoter| a + b ]@
-mkQuasiQuoteExpr :: QuasiQuote dom -> Expr dom
+mkQuasiQuoteExpr :: QuasiQuote -> Expr
 mkQuasiQuoteExpr = mkAnn child . UQuasiQuoteExpr
 
 -- | Creates a pragma that marks an expression.
-mkExprPragma :: ExprPragma dom -> Expr dom -> Expr dom
+mkExprPragma :: ExprPragma -> Expr -> Expr
 mkExprPragma pragma expr = mkAnn (child <> " " <> child) $ UExprPragma pragma expr
 
 -- | Create a arrow definition: @proc a -> f -< a+1@
-mkProcExpr :: Pattern dom -> Cmd dom -> Expr dom
+mkProcExpr :: Pattern -> Cmd -> Expr
 mkProcExpr pat cmd = mkAnn ("proc " <> child <> " -> " <> child) $ UProc pat cmd
 
 -- | Create a arrow definition: @proc a -> f -< a+1@
-mkArrowApp :: Expr dom -> ArrowApp dom -> Expr dom -> Expr dom
+mkArrowApp :: Expr -> ArrowApp -> Expr -> Expr
 mkArrowApp lhs arrow rhs = mkAnn (child <> " " <> child <> " " <> child) $ UArrowApp lhs arrow rhs
 
 -- | Create a lambda case ( @\case 0 -> 1; 1 -> 2@ )
-mkLambdaCase :: [Alt dom] -> Expr dom
+mkLambdaCase :: [Alt] -> Expr
 mkLambdaCase = mkAnn ("\\case" <> child) . ULamCase . mkAnnList (indented list)
 
 -- | Create a static pointer expression (@ static e @). The inner expression must be closed (cannot have variables bound outside)
-mkStaticPointer :: Expr dom -> Expr dom
+mkStaticPointer :: Expr -> Expr
 mkStaticPointer = mkAnn ("static" <> child) . UStaticPtr
 
 
@@ -178,54 +178,54 @@ -- * Field updates
 
 -- | Create a update of a field (@ x = 1 @)
-mkFieldUpdate :: Name dom -> Expr dom -> FieldUpdate dom
+mkFieldUpdate :: Name -> Expr -> FieldUpdate
 mkFieldUpdate name val = mkAnn (child <> " = " <> child) $ UNormalFieldUpdate name val
 
 -- | Create a update the field to the value of the same name (@ x @)
-mkFieldPun :: Name dom -> FieldUpdate dom
+mkFieldPun :: Name -> FieldUpdate
 mkFieldPun name = mkAnn child $ UFieldPun name
 
 -- | Create a update the fields of the bounded names to their values (@ .. @). Must be the last initializer. Cannot be used in a record update expression.
-mkFieldWildcard :: FieldUpdate dom
+mkFieldWildcard :: FieldUpdate
 mkFieldWildcard = mkAnn child $ UFieldWildcard $ mkAnn ".." FldWildcard
 
 
 -- * Pattern matching and guards
 
 -- | Create a clause of case expression (@ Just x -> x + 1 @)
-mkAlt :: Pattern dom -> CaseRhs dom -> Maybe (LocalBinds dom) -> Alt dom
+mkAlt :: Pattern -> CaseRhs -> Maybe LocalBinds -> Alt
 mkAlt pat rhs locals = mkAnn (child <> child <> child) $ UAlt pat rhs (mkAnnMaybe (after " where " opt) locals)
 
 -- | Create a unguarded right-hand side a pattern match (@ -> 3 @)
-mkCaseRhs :: Expr dom -> CaseRhs dom
+mkCaseRhs :: Expr -> CaseRhs
 mkCaseRhs = mkAnn (" -> " <> child) . UUnguardedCaseRhs
 
 -- | Create a guarded right-hand sides of a pattern match (@ | x == 1 -> 3; | otherwise -> 4 @)
-mkGuardedCaseRhss :: [GuardedCaseRhs dom] -> CaseRhs dom
+mkGuardedCaseRhss :: [GuardedCaseRhs] -> CaseRhs
 mkGuardedCaseRhss = mkAnn child . UGuardedCaseRhss . mkAnnList (indented list)
 
 -- | Creates a guarded right-hand side of pattern matches binding (@ | x > 3 -> 2 @)      
-mkGuardedCaseRhs :: [RhsGuard dom] -> Expr dom -> GuardedCaseRhs dom
+mkGuardedCaseRhs :: [RhsGuard] -> Expr -> GuardedCaseRhs
 mkGuardedCaseRhs guards expr = mkAnn (" | " <> child <> " -> " <> child) $ UGuardedCaseRhs (mkAnnList (separatedBy ", " list) guards) expr
 
 -- * Pragmas that can be applied to expressions
 
 -- | Creates a @CORE@ pragma for adding notes to expressions.
-mkCorePragma :: String -> ExprPragma dom
+mkCorePragma :: String -> ExprPragma
 mkCorePragma = mkAnn ("{-# CORE " <> child <> " #-}") . UCorePragma 
                  . mkAnn ("\"" <> child <> "\"") . UStringNode
 
 -- | Creates an @SCC@ pragma for defining cost centers for profiling
-mkSccPragma :: String -> ExprPragma dom
+mkSccPragma :: String -> ExprPragma
 mkSccPragma = mkAnn ("{-# SCC " <> child <> " #-}") . USccPragma 
                 . mkAnn ("\"" <> child <> "\"") . UStringNode
 
 -- | Creates a pragma that describes if an expression was generated from a code fragment by an external tool (@ {-\# GENERATED "Happy.y" 1:15-1:25 \#-} @)
-mkGeneratedPragma :: SourceRange dom -> ExprPragma dom
+mkGeneratedPragma :: SourceRange -> ExprPragma
 mkGeneratedPragma = mkAnn ("{-# GENERATED " <> child <> " #-}") . UGeneratedPragma 
 
 -- | Create a in-AST source ranges (for generated pragmas)
-mkSourceRange :: String -> Integer -> Integer -> Integer -> Integer -> SourceRange dom
+mkSourceRange :: String -> Integer -> Integer -> Integer -> Integer -> SourceRange
 mkSourceRange file fromLine fromCol toLine toCol
   = mkAnn (child <> " " <> child <> ":" <> child <> "-" <> child <> ":" <> child)
       $ USourceRange (mkAnn ("\"" <> child <> "\"") $ UStringNode file)
@@ -235,74 +235,76 @@ -- * Commands
 
 -- | An arrow application command (@ f -< x + 1 @)
-mkArrowAppCmd :: Expr dom -> ArrowApp dom -> Expr dom -> Cmd dom
+mkArrowAppCmd :: Expr -> ArrowApp -> Expr -> Cmd
 mkArrowAppCmd lhs arrow rhs 
   = mkAnn (child <> " " <> child <> " " <> child)
       $ UArrowAppCmd lhs arrow rhs
 
 -- | A form command (@ (|untilA (increment -< x+y) (within 0.5 -< x)|) @)
-mkArrowFromCmd :: Expr dom -> [Cmd dom] -> Cmd dom
+mkArrowFromCmd :: Expr -> [Cmd] -> Cmd
 mkArrowFromCmd expr cmds 
   = mkAnn ("(| " <> child <> child <> " |)")
       $ UArrowFormCmd expr $ mkAnnList (after " " $ separatedBy " " list) cmds
 
 -- | A function application command
-mkAppCmd :: Cmd dom -> Expr dom -> Cmd dom
+mkAppCmd :: Cmd -> Expr -> Cmd
 mkAppCmd cmd expr = mkAnn (child <> " " <> child)
                       $ UAppCmd cmd expr
 
 -- | An infix command application
-mkInfixCmd :: Cmd dom -> Name dom -> Cmd dom -> Cmd dom
+mkInfixCmd :: Cmd -> Name -> Cmd -> Cmd
 mkInfixCmd lhs op rhs = mkAnn (child <> " " <> child <> " " <> child)
                           $ UInfixCmd lhs op rhs
 
 -- | A lambda command 
-mkLambdaCmd :: [Pattern dom] -> Cmd dom -> Cmd dom
+mkLambdaCmd :: [Pattern] -> Cmd -> Cmd
 mkLambdaCmd args cmd = mkAnn ("\\" <> child <> " -> " <> child)
                          $ ULambdaCmd (mkAnnList (separatedBy " " list) args) cmd
 
 -- | A parenthesized command
-mkParenCmd :: Cmd dom -> Cmd dom
+mkParenCmd :: Cmd -> Cmd
 mkParenCmd cmd = mkAnn ("(" <> child <> ")") $ UParenCmd cmd
 
 -- | A pattern match command
-mkCaseCmd :: Expr dom -> [CmdAlt dom] -> Cmd dom
+mkCaseCmd :: Expr -> [CmdAlt] -> Cmd
 mkCaseCmd expr alts 
   = mkAnn ("case " <> child <> " of " <> child) 
       $ UCaseCmd expr $ mkAnnList (indented list) alts
 
 -- | An if command (@ if f x y then g -< x+1 else h -< y+2 @)
-mkIfCmd :: Expr dom -> Cmd dom -> Cmd dom -> Cmd dom
+mkIfCmd :: Expr -> Cmd -> Cmd -> Cmd
 mkIfCmd pred then_ else_ 
   = mkAnn ("if " <> child <> " then " <> child <> " else " <> child) 
       $ UIfCmd pred then_ else_
 
 -- | A local binding command (@ let z = x+y @)
-mkLetCmd :: [LocalBind dom] -> Cmd dom -> Cmd dom
+mkLetCmd :: [LocalBind] -> Cmd -> Cmd
 mkLetCmd binds cmd
   = mkAnn ("let " <> child <> " in " <> child) 
       $ ULetCmd (mkAnnList (indented list) binds) cmd
 
 -- | A do-notation in a command
-mkDoCmd :: [CmdStmt dom] -> Cmd dom
+mkDoCmd :: [CmdStmt] -> Cmd
 mkDoCmd stmts = mkAnn ("do " <> child) $ UDoCmd (mkAnnList (indented list) stmts)
 
 -- | Left arrow application: @-<@
-mkLeftAppl :: ArrowApp dom
+mkLeftAppl :: ArrowApp
 mkLeftAppl = mkAnn "-<" ULeftAppl
 
 -- | Right arrow application: @>-@
-mkRightAppl :: ArrowApp dom
+mkRightAppl :: ArrowApp
 mkRightAppl = mkAnn ">-" URightAppl
 
 -- | Left arrow high application: @-<<@
-mkLeftHighAppl :: ArrowApp dom
+mkLeftHighAppl :: ArrowApp
 mkLeftHighAppl = mkAnn "-<<" ULeftHighApp
 
 -- | Right arrow high application: @>>-@
-mkRightHighAppl :: ArrowApp dom
+mkRightHighAppl :: ArrowApp
 mkRightHighAppl = mkAnn ">>-" URightHighApp
 
-
+-- | A hole expression @_@
+mkHole :: Expr
+mkHole = mkAnn "_" UHole
Language/Haskell/Tools/Rewrite/Create/Kinds.hs view
@@ -10,57 +10,57 @@ import Language.Haskell.Tools.Rewrite.ElementTypes (Name, Kind, KindConstraint)
 
 -- | Kind constraint (@ :: * -> * @)
-mkKindConstraint :: Kind dom -> KindConstraint dom
+mkKindConstraint :: Kind -> KindConstraint
 mkKindConstraint = mkAnn (" :: " <> child) . UKindConstraint
 
 -- | @*@, the kind of types
-mkKindStar :: Kind dom
+mkKindStar :: Kind
 mkKindStar = mkAnn "*" UStarKind
 
 -- | @#@, the kind of unboxed types
-mkKindUnbox :: Kind dom
+mkKindUnbox :: Kind
 mkKindUnbox = mkAnn "#" UUnboxKind
 
 -- | @->@, the kind of type constructor
-mkKindFun :: Kind dom -> Kind dom -> Kind dom
+mkKindFun :: Kind -> Kind -> Kind
 mkKindFun lhs rhs = mkAnn (child <> " -> " <> child) $ UFunKind lhs rhs
 
 -- | A parenthesised kind
-mkKindParen :: Kind dom -> Kind dom
+mkKindParen :: Kind -> Kind
 mkKindParen = mkAnn ("(" <> child <> ")") . UParenKind
 
 -- | Kind variable (using @PolyKinds@ extension)
-mkKindVar :: Name dom -> Kind dom
+mkKindVar :: Name -> Kind
 mkKindVar = mkAnn child . UVarKind
 
 -- | Kind application (@ k1 k2 @)
-mkKindApp :: Kind dom -> Kind dom -> Kind dom
+mkKindApp :: Kind -> Kind -> Kind
 mkKindApp lhs rhs = mkAnn (child <> " " <> child) $ UAppKind lhs rhs
 
 -- | A list kind (@ [k] @)
-mkKindList :: Kind dom -> Kind dom
+mkKindList :: Kind -> Kind
 mkKindList = mkAnn ("[" <> child <> "]") . UListKind
 
 -- | Numeric value promoted to the kind level.
-mkIntKind :: Integer -> Kind dom
+mkIntKind :: Integer -> Kind
 mkIntKind i = mkAnn child $ UPromotedKind $ mkAnn (fromString $ show i) (UPromotedInt i)
 
 -- | String value promoted to the kind level.
-mkStringKind :: String -> Kind dom
+mkStringKind :: String -> Kind
 mkStringKind i = mkAnn child $ UPromotedKind $ mkAnn (fromString $ show i) (UPromotedString i)
 
 -- | A data constructor value promoted to the kind level.
-mkConKind :: Name dom -> Kind dom
+mkConKind :: Name -> Kind
 mkConKind = mkAnn child . UPromotedKind . mkAnn child . UPromotedCon
 
 -- | A list of elements as a kind.
-mkListKind :: [Kind dom] -> Kind dom
+mkListKind :: [Kind] -> Kind
 mkListKind = mkAnn child . UPromotedKind . mkAnn ("[" <> child <> "]") . UPromotedList . mkAnnList (separatedBy ", " list)
 
 -- | A tuple of elements as a kind.
-mkTupleKind :: [Kind dom] -> Kind dom
+mkTupleKind :: [Kind] -> Kind
 mkTupleKind = mkAnn child . UPromotedKind . mkAnn ("(" <> child <> ")") . UPromotedTuple . mkAnnList (separatedBy ", " list)
 
 -- | Kind of the unit value @()@. 
-mkUnitKind :: Kind dom
+mkUnitKind :: Kind
 mkUnitKind = mkAnn child $ UPromotedKind $ mkAnn "()" UPromotedUnit
Language/Haskell/Tools/Rewrite/Create/Literals.hs view
@@ -9,41 +9,41 @@ import Language.Haskell.Tools.Rewrite.ElementTypes (Literal)
 
 -- | Character literal: @'c'@
-mkCharLit :: Char -> Literal dom
+mkCharLit :: Char -> Literal
 mkCharLit c = mkAnn (fromString $ show c) $ UCharLit c
 
 -- | String literal: @"abc"@
-mkStringLit :: String -> Literal dom
+mkStringLit :: String -> Literal
 mkStringLit s = mkAnn (fromString $ show s) $ UStringLit s
 
 -- | Integer literal: @12@
-mkIntLit :: Integer -> Literal dom
+mkIntLit :: Integer -> Literal
 mkIntLit i = mkAnn (fromString $ show i) $ UIntLit i
 
 -- | Fractional literal: @3.14@
-mkFracLit :: Rational -> Literal dom
+mkFracLit :: Rational -> Literal
 mkFracLit f = mkAnn (fromString $ show f) $ UFracLit f
 
 -- | Primitive integer literal (of type @Int#@): @32#@
-mkPrimIntLit :: Integer -> Literal dom
+mkPrimIntLit :: Integer -> Literal
 mkPrimIntLit i = mkAnn (fromString $ show i ++ "#") $ UPrimIntLit i
 
 -- | Primitive word literal (of type @Word#@): @32##@
-mkPrimWordLit :: Integer -> Literal dom
+mkPrimWordLit :: Integer -> Literal
 mkPrimWordLit i = mkAnn (fromString $ show i ++ "##") $ UPrimWordLit i
 
 -- | Primitive float literal (of type @Float#@): @3.14#@
-mkPrimFloatLit :: Rational -> Literal dom
+mkPrimFloatLit :: Rational -> Literal
 mkPrimFloatLit f = mkAnn (fromString $ show f ++ "#") $ UPrimFloatLit f
 
 -- | Primitive double literal (of type @Double#@): @3.14##@
-mkPrimDoubleLit :: Rational -> Literal dom
+mkPrimDoubleLit :: Rational -> Literal
 mkPrimDoubleLit f = mkAnn (fromString $ show f ++ "##") $ UPrimDoubleLit f
 
 -- | Primitive character literal (of type @Char#@): @'c'#@
-mkPrimCharLit :: Char -> Literal dom
+mkPrimCharLit :: Char -> Literal
 mkPrimCharLit c = mkAnn (fromString $ show c ++ "#") $ UPrimCharLit c
 
 -- | Primitive string literal (of type @Addr#@): @"xxx"#@
-mkPrimStringLit :: String -> Literal dom
+mkPrimStringLit :: String -> Literal
 mkPrimStringLit s = mkAnn (fromString $ show s ++ "#") $ UPrimStringLit s
Language/Haskell/Tools/Rewrite/Create/Modules.hs view
@@ -13,48 +13,48 @@ 
 -- | The representation of a haskell module, that is a separate compilation unit.
 -- It may or may not have a header.
-mkModule :: [FilePragma dom] -> Maybe (ModuleHead dom) -> [ImportDecl dom] -> [Decl dom] -> Module dom
+mkModule :: [FilePragma] -> Maybe ModuleHead -> [ImportDecl] -> [Decl] -> Module
 mkModule filePrags head imps decls 
   = mkAnn (child <> child <> child <> child) 
       $ UModule (mkAnnList (followedBy "\n" $ separatedBy "\n" list) filePrags) (mkAnnMaybe opt head)
                 (mkAnnList (after "\n" $ indented list) imps) (mkAnnList (after "\n" $ indented list) decls)
                
 -- | Module declaration with name and (optional) exports
-mkModuleHead :: ModuleName dom -> Maybe (ModulePragma dom) -> Maybe (ExportSpecs dom) -> ModuleHead dom
+mkModuleHead :: ModuleName -> Maybe ModulePragma -> Maybe ExportSpecs -> ModuleHead
 mkModuleHead n pr es = mkAnn ("module " <> child <> child <> child <> " where") 
                          $ UModuleHead n (mkAnnMaybe (after "\n" opt) pr) (mkAnnMaybe opt es)
 
 -- | A list of export specifications surrounded by parentheses
-mkExportSpecs :: [ExportSpec dom] -> ExportSpecs dom
+mkExportSpecs :: [ExportSpec] -> ExportSpecs
 mkExportSpecs = mkAnn ("(" <> child <> ")") . UExportSpecs . mkAnnList (separatedBy ", " list)
 
 -- | Export a name and related names
-mkExportSpec :: IESpec dom -> ExportSpec dom
+mkExportSpec :: IESpec -> ExportSpec
 mkExportSpec = mkAnn child . UDeclExport
 
 -- | The export of an imported module (@ module A @)
-mkModuleExport :: ModuleName dom -> ExportSpec dom
+mkModuleExport :: ModuleName -> ExportSpec
 mkModuleExport = mkAnn ("module " <> child) . UModuleExport
 
 -- | Marks a name to be imported or exported with related names (subspecifier)
-mkIESpec :: Name dom -> Maybe (SubSpec dom) -> IESpec dom
+mkIESpec :: Name -> Maybe SubSpec -> IESpec
 mkIESpec name ss = mkAnn (child <> child <> child) (UIESpec noth name (mkAnnMaybe (after "(" $ followedBy ")" opt) ss))
 
 -- | Marks a pattern synonym to be imported or exported
-mkPatternIESpec :: Name dom -> IESpec dom
+mkPatternIESpec :: Name -> IESpec
 mkPatternIESpec name = mkAnn (child <> child) (UIESpec (justVal $ mkAnn child UImportPattern) name noth)
 
 -- | @(a,b,c)@: a class exported with some of its methods, or a datatype exported with some of its constructors.
-mkSubList :: [Name dom] -> SubSpec dom
+mkSubList :: [Name] -> SubSpec
 mkSubList = mkAnn child . USubSpecList . mkAnnList (separatedBy ", " list)
 
 -- | @(..)@: a class exported with all of its methods, or a datatype exported with all of its constructors.
-mkSubAll :: SubSpec dom
+mkSubAll :: SubSpec
 mkSubAll = mkAnn ".." USubSpecAll
 
 -- | An import declaration: @import Module.Name@         
-mkImportDecl :: Bool -> Bool -> Bool -> Maybe String -> ModuleName dom -> Maybe (ModuleName dom) -> Maybe (ImportSpec dom) 
-                  -> ImportDecl dom       
+mkImportDecl :: Bool -> Bool -> Bool -> Maybe String -> ModuleName -> Maybe ModuleName -> Maybe ImportSpec
+                  -> ImportDecl       
 mkImportDecl source qualified safe pkg name rename spec
   = mkAnn ("import " <> child <> child <> child <> child <> child <> child <> child) $
       UImportDecl (if source then justVal (mkAnn "{-# SOURCE #-} " UImportSource) else noth)
@@ -64,39 +64,39 @@                   name (mkAnnMaybe opt (fmap (mkAnn (" as " <> child) . UImportRenaming) rename)) (mkAnnMaybe opt spec)
 
 -- | Restrict the import definition to ONLY import the listed names
-mkImportSpecList :: [IESpec dom] -> ImportSpec dom
+mkImportSpecList :: [IESpec] -> ImportSpec
 mkImportSpecList = mkAnn ("(" <> child <> ")") . UImportSpecList . mkAnnList (separatedBy ", " list)
 
 -- | Restrict the import definition to DONT import the listed names
-mkImportHidingList :: [IESpec dom] -> ImportSpec dom
+mkImportHidingList :: [IESpec] -> ImportSpec
 mkImportHidingList = mkAnn (" hiding (" <> child <> ")") . UImportSpecHiding . mkAnnList (separatedBy ", " list)
 
 -- | The name of a module
-mkModuleName :: String -> ModuleName dom
+mkModuleName :: String -> ModuleName
 mkModuleName s = mkAnn (fromString s) (UModuleName s)
 
 -- * Pragmas
 
 -- | @LANGUAGE@ pragma, listing the enabled language extensions in that file
-mkLanguagePragma :: [String] -> FilePragma dom
+mkLanguagePragma :: [String] -> FilePragma
 mkLanguagePragma extensions 
   = mkAnn ("{-# LANGUAGE " <> child <> " #-}") $ ULanguagePragma 
       $ mkAnnList (separatedBy ", " list) (map (\ext -> mkAnn (fromString ext) (ULanguageExtension ext)) extensions)
 
 -- | @OPTIONS@ pragma, possibly qualified with a tool, e.g. OPTIONS_GHC
-mkOptionsGHC :: String -> FilePragma dom
+mkOptionsGHC :: String -> FilePragma
 mkOptionsGHC opts 
   = mkAnn ("{-# OPTIONS_GHC " <> child <> " #-}") $ UOptionsPragma 
       $ mkStringNode opts
 
 -- | A warning pragma attached to the module
-mkModuleWarningPragma :: [String] -> ModulePragma dom
+mkModuleWarningPragma :: [String] -> ModulePragma
 mkModuleWarningPragma msg 
   = mkAnn ("{-# WARNING " <> child <> " #-}") $ UModuleWarningPragma 
       $ mkAnnList (separatedBy " " list) $ map mkStringNode msg
 
 -- | A deprecated pragma attached to the module
-mkModuleDeprecatedPragma :: [String] -> ModulePragma dom
+mkModuleDeprecatedPragma :: [String] -> ModulePragma
 mkModuleDeprecatedPragma msg 
   = mkAnn ("{-# DEPRECATED " <> child <> " #-}") $ UModuleDeprecatedPragma 
       $ mkAnnList (separatedBy " " list) $ map mkStringNode msg
Language/Haskell/Tools/Rewrite/Create/Names.hs view
@@ -10,72 +10,72 @@ import qualified Name as GHC
 
 -- | Creates a simple, unqualified name
-mkName :: String -> Name dom
+mkName :: String -> Name
 mkName = mkNormalName . mkSimpleName
 
-mkQualOp :: [String] -> String -> Operator dom
+mkQualOp :: [String] -> String -> Operator
 mkQualOp quals = mkAnn child . UNormalOp . mkQualifiedName quals
 
-mkBacktickOp :: [String] -> String -> Operator dom
+mkBacktickOp :: [String] -> String -> Operator
 mkBacktickOp quals = mkAnn ("`" <> child <> "`") . UBacktickOp . mkQualifiedName quals
 
 -- | Creates an annotated qualified operator: @A.B.+@ or @\`A.B.mod\`@.
-mkQualOp' :: [String] -> GHC.Name -> Operator dom
+mkQualOp' :: [String] -> GHC.Name -> Operator
 mkQualOp' quals n | GHC.isSymOcc (GHC.getOccName n) = mkAnn child $ UNormalOp $ mkQualifiedName' quals n
                   | otherwise                       = mkAnn ("`" <> child <> "`") $ UBacktickOp $ mkQualifiedName' quals n
 
 -- | Creates an annotated unqualified operator: @+@ or @\`mod\`@.
-mkUnqualOp' :: GHC.Name -> Operator dom
+mkUnqualOp' :: GHC.Name -> Operator
 mkUnqualOp' n | GHC.isSymOcc (GHC.getOccName n) = mkAnn child $ UNormalOp $ mkSimpleName' n
               | otherwise                       = mkAnn ("`" <> child <> "`") $ UBacktickOp $ mkSimpleName' n
   
-mkUnqualOp :: String -> Operator dom
+mkUnqualOp :: String -> Operator
 mkUnqualOp = mkAnn child . UNormalOp . mkSimpleName
 
 -- | Creates an annotated qualified (non-operator) binding name: @A.B.f@ or @(A.B.+)@
-mkQualName' :: [String] -> GHC.Name -> Name dom
+mkQualName' :: [String] -> GHC.Name -> Name
 mkQualName' quals n | GHC.isSymOcc (GHC.getOccName n) = mkAnn ("(" <> child <> ")") $ UParenName $ mkQualifiedName' quals n
                     | otherwise                       = mkAnn child $ UNormalName $ mkQualifiedName' quals n
 
 -- | Creates an annotated unqualified (non-operator) binding name: @f@ or @(+)@
-mkUnqualName' :: GHC.Name -> Name dom
+mkUnqualName' :: GHC.Name -> Name
 mkUnqualName' n | GHC.isSymOcc (GHC.getOccName n) = mkAnn ("(" <> child <> ")") $ UParenName $ mkSimpleName' n
                 | otherwise                       = mkAnn child $ UNormalName $ mkSimpleName' n
 
-mkNormalName :: QualifiedName dom -> Name dom
+mkNormalName :: QualifiedName -> Name
 mkNormalName = mkAnn child . UNormalName
 
 -- | Creates a parenthesized name: @ foldl (+) 0 @
-mkParenName :: QualifiedName dom -> Name dom
+mkParenName :: QualifiedName -> Name
 mkParenName = mkAnn ("(" <> child <> ")") . UParenName
 
 -- | Creates an implicit name: @ ?var @
-mkImplicitName :: QualifiedName dom -> Name dom
+mkImplicitName :: QualifiedName -> Name
 mkImplicitName = mkAnn ("?" <> child) . UImplicitName
 
 -- | Creates an annotated qualified simple name
-mkQualifiedName' :: [String] -> GHC.Name -> QualifiedName dom
+mkQualifiedName' :: [String] -> GHC.Name -> QualifiedName
 mkQualifiedName' quals n = mkQualifiedName quals (GHC.occNameString $ GHC.getOccName n)
 
-mkQualifiedName :: [String] -> String -> QualifiedName dom
+mkQualifiedName :: [String] -> String -> QualifiedName
 mkQualifiedName [] n = mkSimpleName n
 mkQualifiedName quals name
   = mkAnn (child <> "." <> child)
           (UQualifiedName (mkAnnList (separatedBy "." list) $ map mkNamePart quals) (mkNamePart name))
 
 -- | Creates a part of a qualified name.         
-mkNamePart :: String -> NamePart dom
+mkNamePart :: String -> NamePart
 mkNamePart s = mkAnn (fromString s) (UNamePart s)
 
 -- | Creates a simple (unqualified) name
-mkSimpleName' :: GHC.Name -> QualifiedName dom
+mkSimpleName' :: GHC.Name -> QualifiedName
 mkSimpleName' = mkSimpleName . GHC.occNameString . GHC.getOccName
 
 -- | Creates a simple (unqualified) name
-mkSimpleName :: String -> QualifiedName dom
+mkSimpleName :: String -> QualifiedName
 mkSimpleName n = mkAnn (child <> child) 
                        (UQualifiedName emptyList (mkNamePart n))
 
 -- | Creates a quoted text
-mkStringNode :: String -> StringNode dom
+mkStringNode :: String -> StringNode
 mkStringNode s = mkAnn (fromString s) (UStringNode s)
Language/Haskell/Tools/Rewrite/Create/Patterns.hs view
@@ -10,85 +10,85 @@ import Language.Haskell.Tools.Rewrite.ElementTypes
 
 -- | Pattern name binding
-mkVarPat :: Name dom -> Pattern dom
+mkVarPat :: Name -> Pattern
 mkVarPat = mkAnn child . UVarPat
 
 -- | Literal pattern
-mkLitPat :: Literal dom -> Pattern dom
+mkLitPat :: Literal -> Pattern
 mkLitPat = mkAnn child . ULitPat
 
 -- | Infix constructor application pattern (@ a :+: b @)
-mkInfixAppPat :: Pattern dom -> Operator dom -> Pattern dom -> Pattern dom
+mkInfixAppPat :: Pattern -> Operator -> Pattern -> Pattern
 mkInfixAppPat lhs op rhs = mkAnn (child <> " " <> child <> " " <> child) $ UInfixAppPat lhs op rhs
 
 -- | Constructor application pattern (@ Point x y @)
-mkAppPat :: Name dom -> [Pattern dom] -> Pattern dom
+mkAppPat :: Name -> [Pattern] -> Pattern
 mkAppPat n pat = mkAnn (child <> child) $ UAppPat n (mkAnnList (after " " $ separatedBy " " list) pat)
 
 -- | Tuple pattern (@ (x,y) @)
-mkTuplePat :: [Pattern dom] -> Pattern dom
+mkTuplePat :: [Pattern] -> Pattern
 mkTuplePat pats = mkAnn ("(" <> child <> ")") $ UTuplePat (mkAnnList (separatedBy ", " list) pats)
 
 -- | Unboxed tuple pattern (@ (\# x, y \#) @)
-mkUnboxTuplePat :: [Pattern dom] -> Pattern dom
+mkUnboxTuplePat :: [Pattern] -> Pattern
 mkUnboxTuplePat pats = mkAnn ("(# " <> child <> " #)") $ UUnboxTuplePat (mkAnnList (separatedBy ", " list) pats)
 
 -- | List pattern (@ [1,2,a,x] @)
-mkListPat :: [Pattern dom] -> Pattern dom
+mkListPat :: [Pattern] -> Pattern
 mkListPat pats = mkAnn ("[" <> child <> "]") $ UListPat (mkAnnList (separatedBy ", " list) pats)
 
 -- | Parallel array pattern (@ [:1,2,a,x:] @)
-mkParArrayPat :: [Pattern dom] -> Pattern dom
+mkParArrayPat :: [Pattern] -> Pattern
 mkParArrayPat pats = mkAnn ("[:" <> child <> ":]") $ UParArrPat (mkAnnList (separatedBy ", " list) pats)
 
 -- | Parenthesised patterns
-mkParenPat :: Pattern dom -> Pattern dom
+mkParenPat :: Pattern -> Pattern
 mkParenPat = mkAnn ("(" <> child <> ")") . UParenPat
 
 -- | Record pattern (@ Point { x = 3, y } @)
-mkRecPat :: Name dom -> [PatternField dom] -> Pattern dom
+mkRecPat :: Name -> [PatternField] -> Pattern
 mkRecPat name flds = mkAnn (child <> "{ " <> child <> " }") $ URecPat name (mkAnnList (separatedBy ", " list) flds)
 
 -- | As-pattern (explicit name binding) (@ ls\@(hd:_) @)
-mkAsPat :: Name dom -> Pattern dom -> Pattern dom
+mkAsPat :: Name -> Pattern -> Pattern
 mkAsPat name pat = mkAnn (child <> "@" <> child) $ UAsPat name pat
 
 -- | Wildcard pattern: (@ _ @)
-mkWildPat :: Pattern dom
+mkWildPat :: Pattern
 mkWildPat = mkAnn "_" UWildPat
 
 -- | Irrefutable pattern (@ ~(x:_) @)
-mkIrrefutablePat :: Pattern dom -> Pattern dom
+mkIrrefutablePat :: Pattern -> Pattern
 mkIrrefutablePat = mkAnn ("~" <> child) . UIrrefutablePat
 
 -- | Bang pattern (@ !x @)
-mkBangPat :: Pattern dom -> Pattern dom
+mkBangPat :: Pattern -> Pattern
 mkBangPat = mkAnn ("!" <> child) . UBangPat
 
 -- | Pattern with explicit type signature (@ x :: Int @)
-mkTypeSigPat :: Pattern dom -> Type dom -> Pattern dom
+mkTypeSigPat :: Pattern -> Type -> Pattern
 mkTypeSigPat pat typ = mkAnn (child <> " :: " <> child) $ UTypeSigPat pat typ
 
 -- | View pattern (@ f -> Just 1 @)
-mkViewPat :: Expr dom -> Pattern dom -> Pattern dom
+mkViewPat :: Expr -> Pattern -> Pattern
 mkViewPat name pat = mkAnn (child <> " -> " <> child) $ UViewPat name pat
 
 -- | Splice patterns: @$(generateX inp)@
-mkSplicePat :: Splice dom -> Pattern dom
+mkSplicePat :: Splice -> Pattern
 mkSplicePat = mkAnn child . USplicePat
 
 -- | Quasi-quoted patterns: @[| 1 + 2 |]@
-mkQuasiQuotePat :: QuasiQuote dom -> Pattern dom
+mkQuasiQuotePat :: QuasiQuote -> Pattern
 mkQuasiQuotePat = mkAnn child . UQuasiQuotePat
 
 -- | Named field pattern (@ p = Point 3 2 @)
-mkPatternField :: Name dom -> Pattern dom -> PatternField dom
+mkPatternField :: Name -> Pattern -> PatternField
 mkPatternField name pat = mkAnn (child <> " = " <> child) $ UNormalFieldPattern name pat
 
 -- | Named field pun (@ p @)
-mkFieldPunPattern :: Name dom -> PatternField dom
+mkFieldPunPattern :: Name -> PatternField
 mkFieldPunPattern name = mkAnn child $ UFieldPunPattern name
 
 -- | Wildcard field pattern (@ .. @)
-mkFieldWildcardPattern :: PatternField dom
+mkFieldWildcardPattern :: PatternField
 mkFieldWildcardPattern = mkAnn child $ UFieldWildcardPattern $ mkAnn ".." FldWildcard
Language/Haskell/Tools/Rewrite/Create/Stmts.hs view
@@ -9,38 +9,38 @@ import Language.Haskell.Tools.Rewrite.ElementTypes
 
 -- | Creates a binding statement (@ x <- action @)
-mkBindStmt :: Pattern dom -> Expr dom -> Stmt dom
+mkBindStmt :: Pattern -> Expr -> Stmt
 mkBindStmt bound expr = mkAnn (child <> " <- " <> child) $ UBindStmt bound expr
 
 -- | Creates a non-binding statement (@ action @)
-mkExprStmt :: Expr dom -> Stmt dom
+mkExprStmt :: Expr -> Stmt
 mkExprStmt = mkAnn child . UExprStmt
 
 -- | Creates a let statement (@ let x = 3; y = 4 @)
-mkLetStmt :: [LocalBind dom] -> Stmt dom
+mkLetStmt :: [LocalBind] -> Stmt
 mkLetStmt = mkAnn ("let " <> child) . ULetStmt . mkAnnList (indented list)
 
 -- | Creates a recursive binding statement with (@ rec b <- f a c; c <- f b a @)
-mkRecStmt :: [Stmt dom] -> Stmt dom
+mkRecStmt :: [Stmt] -> Stmt
 mkRecStmt = mkAnn ("rec " <> child) . URecStmt . mkAnnList (indented list)
 
 -- * List comprehensions
 
 -- | Body of a list comprehension: (@ | x <- [1..10] @)
-mkListCompBody :: [CompStmt dom] -> ListCompBody dom
+mkListCompBody :: [CompStmt] -> ListCompBody
 mkListCompBody = mkAnn child . UListCompBody . mkAnnList (separatedBy " " list)
 
 -- | Normal monadic statement of a list comprehension
-mkCompStmt :: Stmt dom -> CompStmt dom
+mkCompStmt :: Stmt -> CompStmt
 mkCompStmt = mkAnn child . UCompStmt
 
 -- | Then statements by @TransformListComp@ (@ then sortWith by (x + y) @)
-mkThenStmt :: Expr dom -> Maybe (Expr dom) -> CompStmt dom
+mkThenStmt :: Expr -> Maybe Expr -> CompStmt
 mkThenStmt th by = mkAnn ("then " <> child) 
                      $ UThenStmt th $ mkAnnMaybe (after " by " opt) by
 
 -- | Grouping statements by @TransformListComp@ (@ then group by (x + y) using groupWith @) 
-mkGroupStmt :: Maybe (Expr dom) -> Maybe (Expr dom) -> CompStmt dom
+mkGroupStmt :: Maybe Expr -> Maybe Expr -> CompStmt
 mkGroupStmt by using = mkAnn ("then group" <> child) 
                          $ UGroupStmt (mkAnnMaybe (after " by " opt) by)
                                       (mkAnnMaybe (after " using " opt) using)
@@ -48,18 +48,18 @@ -- * Commands
 
 -- | Creates a binding command (@ x <- action @)
-mkBindCmd :: Pattern dom -> Cmd dom -> CmdStmt dom
+mkBindCmd :: Pattern -> Cmd -> CmdStmt
 mkBindCmd bound expr = mkAnn (child <> " <- " <> child) $ UBindStmt bound expr
 
 -- | Creates a non-binding command (@ action @)
-mkExprCmd :: Cmd dom -> CmdStmt dom
+mkExprCmd :: Cmd -> CmdStmt
 mkExprCmd = mkAnn child . UExprStmt
 
 -- | Creates a let command (@ let x = 3; y = 4 @)
-mkLetStmtCmd :: [LocalBind dom] -> CmdStmt dom
+mkLetStmtCmd :: [LocalBind] -> CmdStmt
 mkLetStmtCmd = mkAnn ("let " <> child) . ULetStmt . mkAnnList (indented list)
 
 -- | Creates a recursive binding command with (@ rec b <- f a c; c <- f b a @)
-mkRecCmd :: [CmdStmt dom] -> CmdStmt dom
+mkRecCmd :: [CmdStmt] -> CmdStmt
 mkRecCmd = mkAnn ("rec " <> child) . URecStmt . mkAnnList (indented list)
Language/Haskell/Tools/Rewrite/Create/TH.hs view
@@ -9,31 +9,31 @@ import Language.Haskell.Tools.Rewrite.ElementTypes
 
 -- | A simple name splice: @$generateX@
-mkIdSplice :: Name dom -> Splice dom
+mkIdSplice :: Name -> Splice
 mkIdSplice n = mkAnn ("$" <> child) $ UIdSplice n
 
 -- | A splice with parentheses: @$(generate input)@
-mkParenSplice :: Expr dom -> Splice dom
+mkParenSplice :: Expr -> Splice
 mkParenSplice n = mkAnn ("$(" <> child <> ")") $ UParenSplice n
 
 -- | Template haskell quasi-quotation: @[quoter|str]@  
-mkQuasiQuote :: Name dom -> String -> QuasiQuote dom
+mkQuasiQuote :: Name -> String -> QuasiQuote
 mkQuasiQuote n s = mkAnn ("[" <> child <> "|" <> child <> "|]")
                      $ UQuasiQuote n (mkAnn (fromString s) (QQString s))
 
 -- | Expression bracket (@ [| x + y |] @)
-mkExprBracket :: Expr dom -> Bracket dom
+mkExprBracket :: Expr -> Bracket
 mkExprBracket = mkAnn ("[|" <> child <> "|]") . UExprBracket
 
 -- | Pattern bracket (@ [p| Point x y |] @)
-mkPatternBracket :: Pattern dom -> Bracket dom
+mkPatternBracket :: Pattern -> Bracket
 mkPatternBracket = mkAnn ("[p|" <> child <> "|]") . UPatternBracket
 
 -- | Type bracket (@ [t| (Int,Int) |] @)
-mkTypeBracket :: Type dom -> Bracket dom
+mkTypeBracket :: Type -> Bracket
 mkTypeBracket = mkAnn ("[t|" <> child <> "|]") . UTypeBracket
 
 -- | Declaration bracket (@ [d| f :: Int -> Int; f x = x*x |] @)
-mkDeclsBracket :: [Decl dom] -> Bracket dom
+mkDeclsBracket :: [Decl] -> Bracket
 mkDeclsBracket = mkAnn ("[d|" <> child <> "|]") . UDeclsBracket . mkAnnList (indented list)
Language/Haskell/Tools/Rewrite/Create/Types.hs view
@@ -16,145 +16,145 @@ -- * Generation of types
 
 -- | Forall types (@ forall x y . type @)
-mkForallType :: [TyVar dom] -> Type dom -> Type dom
+mkForallType :: [TyVar] -> Type -> Type
 mkForallType vars t = mkAnn ("forall " <> child <> " . " <> child) (UTyForall (mkAnnList (separatedBy " " list) vars) t)
 
 -- | Simplified creation of type variables
-mkTypeVar' :: GHC.Name -> TyVar dom
+mkTypeVar' :: GHC.Name -> TyVar
 mkTypeVar' = mkTypeVar . mkUnqualName'
 
 -- | Type with a context (@ forall x y . type @)
-mkCtxType :: Context dom -> Type dom -> Type dom
+mkCtxType :: Context -> Type -> Type
 mkCtxType ctx t = mkAnn (child <> " " <> child) (UTyCtx ctx t)
 
 -- | Function types (@ a -> b @)
-mkFunctionType :: Type dom -> Type dom -> Type dom
+mkFunctionType :: Type -> Type -> Type
 mkFunctionType at rt = mkAnn (child <> " -> " <> child) (UTyFun at rt)
 
 -- | Tuple types (@ (a,b) @)
-mkTupleType :: [Type dom] -> Type dom
+mkTupleType :: [Type] -> Type
 mkTupleType args = mkAnn ("(" <> child <> ")") (UTyTuple (mkAnnList (separatedBy ", " list) args))
 
 -- | Unboxed tuple types (@ (\#a,b\#) @)
-mkUnboxedTupleType :: [Type dom] -> Type dom
+mkUnboxedTupleType :: [Type] -> Type
 mkUnboxedTupleType args = mkAnn ("(#" <> child <> "#)") (UTyUnbTuple (mkAnnList (separatedBy ", " list) args))
 
 -- | List type with special syntax (@ [a] @)
-mkListType :: Type dom -> Type dom
+mkListType :: Type -> Type
 mkListType = mkAnn ("[" <> child <> "]") . UTyList
 
 -- | Parallel array type (@ [:a:] @)
-mkParArrayType :: Type dom -> Type dom
+mkParArrayType :: Type -> Type
 mkParArrayType = mkAnn ("[:" <> child <> ":]") . UTyParArray
 
 -- | Type application (@ F a @)
-mkTypeApp :: Type dom -> Type dom -> Type dom
+mkTypeApp :: Type -> Type -> Type
 mkTypeApp ft at = mkAnn (child <> " " <> child) (UTyApp ft at)
 
 -- | Infix type constructor (@ (a <: b) @)
-mkInfixTypeApp :: Type dom -> Operator dom -> Type dom -> Type dom
+mkInfixTypeApp :: Type -> Operator -> Type -> Type
 mkInfixTypeApp left op right = mkAnn (child <> " " <> child <> " " <> child) (UTyInfix left op right)
 
 -- | Type surrounded by parentheses (@ (T a) @)
-mkParenType :: Type dom -> Type dom
+mkParenType :: Type -> Type
 mkParenType = mkAnn ("(" <> child <> ")") . UTyParen
 
 -- | Creates a simple type variable
-mkTypeVar :: Name dom -> TyVar dom
+mkTypeVar :: Name -> TyVar
 mkTypeVar n = mkAnn (child <> child) (UTyVarDecl n noth)
 
 -- | Creates a type variable with kind specification (@ t :: * @)
-mkKindedTypeVar :: Name dom -> Kind dom -> TyVar dom
+mkKindedTypeVar :: Name -> Kind -> TyVar
 mkKindedTypeVar n k = mkAnn (child <> child) (UTyVarDecl n (justVal (mkKindConstraint k)))
 
 -- | Type variable or constructor (@ a @)
-mkVarType :: Name dom -> Type dom
+mkVarType :: Name -> Type
 mkVarType = wrapperAnn . UTyVar
 
 -- | Type with explicit kind signature (@ a :: * @)
-mkKindedType :: Type dom -> Kind dom -> Type dom
+mkKindedType :: Type -> Kind -> Type
 mkKindedType t k = mkAnn (child <> " :: " <> child) (UTyKinded t k)
 
 -- | Strict type marked with @!@.
-mkBangType :: Type dom -> Type dom
+mkBangType :: Type -> Type
 mkBangType = mkAnn ("!" <> child) . UTyBang
 
 -- | Lazy type marked with @~@. (Should only be used if @Strict@ or @StrictData@ language extension is used)
-mkLazyType :: Type dom -> Type dom
+mkLazyType :: Type -> Type
 mkLazyType = mkAnn ("~" <> child) . UTyLazy
 
 -- | Strict type marked with UNPACK pragma. (Usually contains the bang mark.)
-mkUnpackType :: Type dom -> Type dom
+mkUnpackType :: Type -> Type
 mkUnpackType = mkAnn ("{-# UNPACK #-} " <> child) . UTyUnpack
 
 -- | Strict type marked with UNPACK pragma. (Usually contains the bang mark.)
-mkNoUnpackType :: Type dom -> Type dom
+mkNoUnpackType :: Type -> Type
 mkNoUnpackType = mkAnn ("{-# NOUNPACK #-} " <> child) . UTyNoUnpack
 
 -- | A wildcard type (@ _ @) with @-XPartialTypeSignatures@
-mkWildcardType :: Type dom
+mkWildcardType :: Type
 mkWildcardType = mkAnn "_" UTyWildcard
 
 -- | A named wildcard type (@ _t @) with @-XPartialTypeSignatures@
-mkNamedWildcardType :: Name dom -> Type dom
+mkNamedWildcardType :: Name -> Type
 mkNamedWildcardType = mkAnn ("_" <> child) . UTyNamedWildc
 
 -- | A Template Haskell splice type (@ $(genType) @).
-mkSpliceType :: Splice dom -> Type dom
+mkSpliceType :: Splice -> Type
 mkSpliceType = mkAnn child . UTySplice
 
 -- | A Template Haskell quasi-quote type (@ [quoter| ... ] @).
-mkQuasiQuoteType :: QuasiQuote dom -> Type dom
+mkQuasiQuoteType :: QuasiQuote -> Type
 mkQuasiQuoteType = mkAnn child . UTyQuasiQuote
 
 
 -- | Numeric value promoted to the kind level.
-mkPromotedIntType :: Integer -> Type dom
+mkPromotedIntType :: Integer -> Type
 mkPromotedIntType i = mkAnn child $ UTyPromoted $ mkAnn (fromString $ show i) (UPromotedInt i)
 
 -- | String value promoted to the kind level.
-mkPromotedStringType :: String -> Type dom
+mkPromotedStringType :: String -> Type
 mkPromotedStringType i = mkAnn child $ UTyPromoted $ mkAnn (fromString $ show i) (UPromotedString i)
 
 -- | A data constructor value promoted to the kind level.
-mkPromotedConType :: Name dom -> Type dom
+mkPromotedConType :: Name -> Type
 mkPromotedConType = mkAnn child . UTyPromoted . mkAnn child . UPromotedCon
 
 -- | A list of elements as a kind.
-mkPromotedListType :: [Type dom] -> Type dom
+mkPromotedListType :: [Type] -> Type
 mkPromotedListType
   = mkAnn child . UTyPromoted . mkAnn ("[" <> child <> "]") . UPromotedList . mkAnnList (separatedBy ", " list)
 
 -- | A tuple of elements as a kind.
-mkPromotedTupleType :: [Type dom] -> Type dom
+mkPromotedTupleType :: [Type] -> Type
 mkPromotedTupleType
   = mkAnn child . UTyPromoted . mkAnn ("(" <> child <> ")") . UPromotedTuple . mkAnnList (separatedBy ", " list)
 
 -- | Kind of the unit value @()@.
-mkPromotedUnitType :: Type dom
+mkPromotedUnitType :: Type
 mkPromotedUnitType = mkAnn child $ UTyPromoted $ mkAnn "()" UPromotedUnit
 
 -- * Generation of contexts
 
 -- | Creates a context of assertions (@ C a => ... @)
-mkContext :: Assertion dom -> Context dom
+mkContext :: Assertion -> Context
 mkContext = mkAnn (child <> " =>") . UContext
 
 -- * Generation of assertions
 
 -- | Class assertion (@Cls x@)
-mkClassAssert :: Name dom -> [Type dom] -> Assertion dom
+mkClassAssert :: Name -> [Type] -> Assertion
 -- fixme: class assertion without parameters should not have the last space
 mkClassAssert n args = mkAnn (child <> " " <> child) $ UClassAssert n (mkAnnList (separatedBy " " list) args)
 
 -- | Infix class assertion, also contains type equations (@ a ~ X y @)
-mkInfixAssert :: Type dom -> Operator dom -> Type dom -> Assertion dom
+mkInfixAssert :: Type -> Operator -> Type -> Assertion
 mkInfixAssert left op right = mkAnn (child <> " " <> child <> " " <> child) $ UInfixAssert left op right
 
 -- | Creates an assertion for implicit parameter binding (@ ?cmp :: a -> a -> Bool @)
-mkImplicitAssert :: Name dom -> Type dom -> Assertion dom
+mkImplicitAssert :: Name -> Type -> Assertion
 mkImplicitAssert n t = mkAnn (child <> " :: " <> child) $ UImplicitAssert n t
 
 -- | Creates a list of assertions (@ (Eq a, Show a) @)
-mkTupleAssertion :: [Assertion dom] -> Assertion dom
+mkTupleAssertion :: [Assertion] -> Assertion
 mkTupleAssertion ass = mkAnn ("(" <> child <> ")") $ UTupleAssert $ mkAnnList (separatedBy ", " list) ass
Language/Haskell/Tools/Rewrite/Create/Utils.hs view
@@ -9,26 +9,26 @@ fromTemplate :: src -> NodeInfo sema src
 fromTemplate = NodeInfo (error "The newly generated AST fragments have no semantic info, but a refactoring tries to use that information.")
 
-emptyList :: AnnList e dom
+emptyList :: AnnList e
 emptyList = AnnListG (fromTemplate list) []
 
-justVal :: Ann e dom SrcTemplateStage -> AnnMaybeG e dom SrcTemplateStage
+justVal :: Ann e IdDom SrcTemplateStage -> AnnMaybe e
 justVal e = AnnMaybeG (fromTemplate opt) (Just e)
 
-noth :: AnnMaybe e dom
+noth :: AnnMaybe e
 noth = AnnMaybeG (fromTemplate opt) Nothing
 
-mkAnn :: SpanInfo SrcTemplateStage -> e dom SrcTemplateStage -> Ann e dom SrcTemplateStage
+mkAnn :: SpanInfo SrcTemplateStage -> e IdDom SrcTemplateStage -> Ann e IdDom SrcTemplateStage
 mkAnn temp = Ann (fromTemplate temp)
 
 -- | Annotation for a simple wrapper AST node
-wrapperAnn :: e dom SrcTemplateStage -> Ann e dom SrcTemplateStage
+wrapperAnn :: e IdDom SrcTemplateStage -> Ann e IdDom SrcTemplateStage
 wrapperAnn = mkAnn child
 
 -- | Transforms the list of elements to an AnnListG with the given source template.
-mkAnnList :: ListInfo SrcTemplateStage -> [Ann e dom SrcTemplateStage] -> AnnList e dom
+mkAnnList :: ListInfo SrcTemplateStage -> [Ann e IdDom SrcTemplateStage] -> AnnList e
 mkAnnList temp = AnnListG (fromTemplate temp)
 
 -- | Transforms the Maybe element to an AnnMaybeG with the given source template.
-mkAnnMaybe :: OptionalInfo SrcTemplateStage -> Maybe (Ann e dom SrcTemplateStage) -> AnnMaybe e dom
+mkAnnMaybe :: OptionalInfo SrcTemplateStage -> Maybe (Ann e IdDom SrcTemplateStage) -> AnnMaybe e
 mkAnnMaybe temp = AnnMaybeG (fromTemplate temp)
Language/Haskell/Tools/Rewrite/ElementTypes.hs view
@@ -2,403 +2,403 @@ 
 import Language.Haskell.Tools.AST
 
-type AnnList node dom = AnnListG node dom SrcTemplateStage
-type AnnMaybe node dom = AnnMaybeG node dom SrcTemplateStage
+type AnnList node = AnnListG node IdDom SrcTemplateStage
+type AnnMaybe node = AnnMaybeG node IdDom SrcTemplateStage
 
 -- * Modules
 
 -- | The representation of a haskell module, that is a separate compilation unit.
 -- It may or may not have a header.
-type Module dom = Ann UModule dom SrcTemplateStage
+type Module = Ann UModule IdDom SrcTemplateStage
 
 -- | Module declaration with name and (optional) exports
-type ModuleHead dom = Ann UModuleHead dom SrcTemplateStage
+type ModuleHead = Ann UModuleHead IdDom SrcTemplateStage
 
 -- | A list of export specifications surrounded by parentheses
-type ExportSpecs dom = Ann UExportSpecs dom SrcTemplateStage
+type ExportSpecs = Ann UExportSpecs IdDom SrcTemplateStage
 
 -- | Export specifier
-type ExportSpec dom = Ann UExportSpec dom SrcTemplateStage
+type ExportSpec = Ann UExportSpec IdDom SrcTemplateStage
 
 -- | Marks a name to be imported or exported with related names (subspecifier)
-type IESpec dom = Ann UIESpec dom SrcTemplateStage
+type IESpec = Ann UIESpec IdDom SrcTemplateStage
 
 -- | Marks how related names will be imported or exported with a given name
-type SubSpec dom = Ann USubSpec dom SrcTemplateStage
+type SubSpec = Ann USubSpec IdDom SrcTemplateStage
 
 -- | Pragmas that must be used after the module head
-type ModulePragma dom = Ann UModulePragma dom SrcTemplateStage
+type ModulePragma = Ann UModulePragma IdDom SrcTemplateStage
 
 -- | Pragmas that must be used before defining the module
-type FilePragma dom = Ann UFilePragma dom SrcTemplateStage
+type FilePragma = Ann UFilePragma IdDom SrcTemplateStage
 
 -- | An import declaration: @import Module.Name@
-type ImportDecl dom = Ann UImportDecl dom SrcTemplateStage
+type ImportDecl = Ann UImportDecl IdDom SrcTemplateStage
 
 -- | Restriction on the imported names
-type ImportSpec dom = Ann UImportSpec dom SrcTemplateStage
+type ImportSpec = Ann UImportSpec IdDom SrcTemplateStage
 
 -- | Marks the import as qualified: @qualified@
-type ImportQualified dom = Ann UImportQualified dom SrcTemplateStage
+type ImportQualified = Ann UImportQualified IdDom SrcTemplateStage
 
 -- | Marks the import as source: @{-\# SOURCE \#-}@
-type ImportSource dom = Ann UImportSource dom SrcTemplateStage
+type ImportSource = Ann UImportSource IdDom SrcTemplateStage
 
 -- | Marks the import as safe: @safe@
-type ImportSafe dom = Ann UImportSafe dom SrcTemplateStage
+type ImportSafe = Ann UImportSafe IdDom SrcTemplateStage
 
 -- | Marks an imported name to belong to the type namespace: @type@
-type TypeNamespace dom = Ann UTypeNamespace dom SrcTemplateStage
+type TypeNamespace = Ann UTypeNamespace IdDom SrcTemplateStage
 
 -- | Renaming imports (@ as A @)
-type ImportRenaming dom = Ann UImportRenaming dom SrcTemplateStage
+type ImportRenaming = Ann UImportRenaming IdDom SrcTemplateStage
 
 -- | The name of a module
-type ModuleName dom = Ann UModuleName dom SrcTemplateStage
+type ModuleName = Ann UModuleName IdDom SrcTemplateStage
 
 -- | The name of the enabled language extension, for example (@ LambdaCase @)
-type LanguageExtension dom = Ann ULanguageExtension dom SrcTemplateStage
+type LanguageExtension = Ann ULanguageExtension IdDom SrcTemplateStage
 
 -- * Declarations
 
 -- | Haskell declaration
-type Decl dom = Ann UDecl dom SrcTemplateStage
+type Decl = Ann UDecl IdDom SrcTemplateStage
 
 -- | The list of declarations that can appear in a typeclass
-type ClassBody dom = Ann UClassBody dom SrcTemplateStage
+type ClassBody = Ann UClassBody IdDom SrcTemplateStage
 
 -- | Members of a class declaration
-type ClassElement dom = Ann UClassElement dom SrcTemplateStage
+type ClassElement = Ann UClassElement IdDom SrcTemplateStage
 
 -- The declared (possibly parameterized) type (@ A x :+: B y @).
-type DeclHead dom = Ann UDeclHead dom SrcTemplateStage
+type DeclHead = Ann UDeclHead IdDom SrcTemplateStage
 
 -- | Instance body is the implementation of the class functions (@ where a x = 1; b x = 2 @)
-type InstBody dom = Ann UInstBody dom SrcTemplateStage
+type InstBody = Ann UInstBody IdDom SrcTemplateStage
 
 -- | Declarations inside an instance declaration.
-type InstBodyDecl dom = Ann UInstBodyDecl dom SrcTemplateStage
+type InstBodyDecl = Ann UInstBodyDecl IdDom SrcTemplateStage
 
 -- | GADT constructor declaration (@ D1 :: { val :: Int } -> T String @)
-type GadtConDecl dom = Ann UGadtConDecl dom SrcTemplateStage
+type GadtConDecl = Ann UGadtConDecl IdDom SrcTemplateStage
 
 -- | Type of GADT constructors (can be record types: @{ val :: Int }@)
-type GadtConType dom = Ann UGadtConType dom SrcTemplateStage
+type GadtConType = Ann UGadtConType IdDom SrcTemplateStage
 
 -- | Marker for a field wildcard. Only needed to attach semantic information in a type-safe way.
-type FieldWildcard dom = Ann UFieldWildcard dom SrcTemplateStage
+type FieldWildcard = Ann UFieldWildcard IdDom SrcTemplateStage
 
 -- | A list of functional dependencies: @ | a -> b, c -> d @ separated by commas
-type FunDeps dom = Ann UFunDeps dom SrcTemplateStage
+type FunDeps = Ann UFunDeps IdDom SrcTemplateStage
 
 -- | A functional dependency, given on the form @l1 ... ln -> r1 ... rn@
-type FunDep dom = Ann UFunDep dom SrcTemplateStage
+type FunDep = Ann UFunDep IdDom SrcTemplateStage
 
 -- | A constructor declaration for a datatype
-type ConDecl dom = Ann UConDecl dom SrcTemplateStage
+type ConDecl = Ann UConDecl IdDom SrcTemplateStage
 
 -- | The @data@ or the @newtype@ keyword to define ADTs.
-type DataOrNewtypeKeyword dom = Ann UDataOrNewtypeKeyword dom SrcTemplateStage
+type DataOrNewtypeKeyword = Ann UDataOrNewtypeKeyword IdDom SrcTemplateStage
 
 -- | Field declaration (@ fld :: Int @)
-type FieldDecl dom = Ann UFieldDecl dom SrcTemplateStage
+type FieldDecl = Ann UFieldDecl IdDom SrcTemplateStage
 
 -- | A deriving clause following a data type declaration. (@ deriving Show @ or @ deriving (Show, Eq) @)
-type Deriving dom = Ann UDeriving dom SrcTemplateStage
+type Deriving = Ann UDeriving IdDom SrcTemplateStage
 
 -- | A deriving strategy (@stock@, @newtype@ or @anyclass@)
-type DeriveStrategy dom = Ann UDeriveStrategy dom SrcTemplateStage
+type DeriveStrategy = Ann UDeriveStrategy IdDom SrcTemplateStage
 
 -- | The instance declaration rule, which is, roughly, the part of the instance declaration before the where keyword.
-type InstanceRule dom = Ann UInstanceRule dom SrcTemplateStage
+type InstanceRule = Ann UInstanceRule IdDom SrcTemplateStage
 
 -- | The specification of the class instance declaration
-type InstanceHead dom = Ann UInstanceHead dom SrcTemplateStage
+type InstanceHead = Ann UInstanceHead IdDom SrcTemplateStage
 
 -- | Specialize pragma (@ {-# SPECIALISE f :: Int -> b -> b #-} @)
-type SpecializePragma dom = Ann USpecializePragma dom SrcTemplateStage
+type SpecializePragma = Ann USpecializePragma IdDom SrcTemplateStage
 
 -- | Overlap pragmas. Can be applied to class declarations and class instance declarations.
-type OverlapPragma dom = Ann UOverlapPragma dom SrcTemplateStage
+type OverlapPragma = Ann UOverlapPragma IdDom SrcTemplateStage
 
 -- | Type equations as found in closed type families (@ T A = S @)
-type TypeEqn dom = Ann UTypeEqn dom SrcTemplateStage
+type TypeEqn = Ann UTypeEqn IdDom SrcTemplateStage
 
 -- | Top level pragmas
-type TopLevelPragma dom = Ann UTopLevelPragma dom SrcTemplateStage
+type TopLevelPragma = Ann UTopLevelPragma IdDom SrcTemplateStage
 
 -- | A rewrite rule (@ "map/map" forall f g xs. map f (map g xs) = map (f.g) xs @)
-type Rule dom = Ann URule dom SrcTemplateStage
+type Rule = Ann URule IdDom SrcTemplateStage
 
 -- | A variable for a rewrite rule. With or without type signature.
-type RuleVar dom = Ann URuleVar dom SrcTemplateStage
+type RuleVar = Ann URuleVar IdDom SrcTemplateStage
 
 -- | Annotation allows you to connect an expression to any declaration.
-type AnnotationSubject dom = Ann UAnnotationSubject dom SrcTemplateStage
+type AnnotationSubject = Ann UAnnotationSubject IdDom SrcTemplateStage
 
 -- | Formulas of minimal annotations declaring which functions should be defined.
-type MinimalFormula dom = Ann UMinimalFormula dom SrcTemplateStage
+type MinimalFormula = Ann UMinimalFormula IdDom SrcTemplateStage
 
 -- | In-AST source ranges (for generated pragmas)
-type SourceRange dom = Ann USourceRange dom SrcTemplateStage
+type SourceRange = Ann USourceRange IdDom SrcTemplateStage
 
 -- | Open type and data families
-type TypeFamily dom = Ann UTypeFamily dom SrcTemplateStage
+type TypeFamily = Ann UTypeFamily IdDom SrcTemplateStage
 
 -- | Type family specification with kinds specification and injectivity.
-type TypeFamilySpec dom = Ann UTypeFamilySpec dom SrcTemplateStage
+type TypeFamilySpec = Ann UTypeFamilySpec IdDom SrcTemplateStage
 
 -- | Injectivity annotation for type families (@ = r | r -> a @)
-type InjectivityAnn dom = Ann UInjectivityAnn dom SrcTemplateStage
+type InjectivityAnn = Ann UInjectivityAnn IdDom SrcTemplateStage
 
 -- | Pattern synonyms: @ pattern Arrow t1 t2 = App "->" [t1, t2] @
-type PatternSynonym dom = Ann UPatternSynonym dom SrcTemplateStage
+type PatternSynonym = Ann UPatternSynonym IdDom SrcTemplateStage
 
 -- | Right-hand side of pattern synonym
-type PatSynRhs dom = Ann UPatSynRhs dom SrcTemplateStage
+type PatSynRhs = Ann UPatSynRhs IdDom SrcTemplateStage
 
 -- | Left hand side of a pattern synonym
-type PatSynLhs dom = Ann UPatSynLhs dom SrcTemplateStage
+type PatSynLhs = Ann UPatSynLhs IdDom SrcTemplateStage
 
 -- | Where clause of pattern synonym (explicit expression direction)
-type PatSynWhere dom = Ann UPatSynWhere dom SrcTemplateStage
+type PatSynWhere = Ann UPatSynWhere IdDom SrcTemplateStage
 
 -- | Pattern type signature declaration (@ pattern Succ :: Int -> Int @)
-type PatternSignature dom = Ann UPatternTypeSignature dom SrcTemplateStage
+type PatternSignature = Ann UPatternTypeSignature IdDom SrcTemplateStage
 
 -- | Role annotations for types
-type Role dom = Ann URole dom SrcTemplateStage
+type Role = Ann URole IdDom SrcTemplateStage
 
 -- | Call conventions of foreign functions
-type CallConv dom = Ann UCallConv dom SrcTemplateStage
+type CallConv = Ann UCallConv IdDom SrcTemplateStage
 
 -- | Safety annotations for foreign calls
-type Safety dom = Ann USafety dom SrcTemplateStage
+type Safety = Ann USafety IdDom SrcTemplateStage
 
 -- | A @CONLIKE@ modifier for an @INLINE@ pragma.
-type ConlikeAnnot dom = Ann UConlikeAnnot dom SrcTemplateStage
+type ConlikeAnnot = Ann UConlikeAnnot IdDom SrcTemplateStage
 
 -- | Controls the activation of a rewrite rule (@ [1] @)
-type PhaseControl dom = Ann UPhaseControl dom SrcTemplateStage
+type PhaseControl = Ann UPhaseControl IdDom SrcTemplateStage
 
 -- * Binds
 
 -- | Value binding for top-level and local bindings
-type ValueBind dom = Ann UValueBind dom SrcTemplateStage
+type ValueBind = Ann UValueBind IdDom SrcTemplateStage
 
 -- | Clause of function binding
-type Match dom = Ann UMatch dom SrcTemplateStage
+type Match = Ann UMatch IdDom SrcTemplateStage
 
 -- | Something on the left side of the match
-type MatchLhs dom = Ann UMatchLhs dom SrcTemplateStage
+type MatchLhs = Ann UMatchLhs IdDom SrcTemplateStage
 
 -- | Right hand side of a value binding (possible with guards): (@ = 3 @ or @ | x == 1 = 3; | otherwise = 4 @)
-type Rhs dom = Ann URhs dom SrcTemplateStage
+type Rhs = Ann URhs IdDom SrcTemplateStage
 
 -- | A guarded right-hand side of a value binding (@ | x > 3 = 2 @)
-type GuardedRhs dom = Ann UGuardedRhs dom SrcTemplateStage
+type GuardedRhs = Ann UGuardedRhs IdDom SrcTemplateStage
 
 -- | Guards for value bindings and pattern matches (@ Just v <- x, v > 1 @)
-type RhsGuard dom = Ann URhsGuard dom SrcTemplateStage
+type RhsGuard = Ann URhsGuard IdDom SrcTemplateStage
 
 -- | Bindings that are enabled in local blocks (where or let).
-type LocalBind dom = Ann ULocalBind dom SrcTemplateStage
+type LocalBind = Ann ULocalBind IdDom SrcTemplateStage
 
 -- | Local bindings attached to a declaration (@ where x = 42 @)
-type LocalBinds dom = Ann ULocalBinds dom SrcTemplateStage
+type LocalBinds = Ann ULocalBinds IdDom SrcTemplateStage
 
 -- | A fixity signature (@ infixl 5 +, - @).
-type FixitySignature dom = Ann UFixitySignature dom SrcTemplateStage
+type FixitySignature = Ann UFixitySignature IdDom SrcTemplateStage
 
 -- | A type signature (@ f :: Int -> Int @)
-type TypeSignature dom = Ann UTypeSignature dom SrcTemplateStage
+type TypeSignature = Ann UTypeSignature IdDom SrcTemplateStage
 
 -- * Types
 
 -- | Haskell types
-type Type dom = Ann UType dom SrcTemplateStage
+type Type = Ann UType IdDom SrcTemplateStage
 
 -- | Type variable declarations (with possible kind annotation)
-type TyVar dom = Ann UTyVar dom SrcTemplateStage
+type TyVar = Ann UTyVar IdDom SrcTemplateStage
 
 -- One or more assertions
-type Context dom = Ann UContext dom SrcTemplateStage
+type Context = Ann UContext IdDom SrcTemplateStage
 
 -- | A single assertion in the context
-type Assertion dom = Ann UAssertion dom SrcTemplateStage
+type Assertion = Ann UAssertion IdDom SrcTemplateStage
 
 -- * Kinds
 
 -- | Kind constraint (@ :: * -> * @)
-type KindConstraint dom = Ann UKindConstraint dom SrcTemplateStage
+type KindConstraint = Ann UKindConstraint IdDom SrcTemplateStage
 
 -- | Haskell kinds
-type Kind dom = Ann UKind dom SrcTemplateStage
+type Kind = Ann UKind IdDom SrcTemplateStage
 
 -- | Values promoted to the kind level
-type PromotedKind dom = Ann (UPromoted UKind) dom SrcTemplateStage
+type PromotedKind = Ann (UPromoted UKind) IdDom SrcTemplateStage
 
 -- * Expressions
 
 -- | Haskell expressions
-type Expr dom = Ann UExpr dom SrcTemplateStage
+type Expr = Ann UExpr IdDom SrcTemplateStage
 
 -- | Clause of case expression (@ Just x -> x + 1 @)
-type Alt dom = Ann UAlt dom SrcTemplateStage
+type Alt = Ann UAlt IdDom SrcTemplateStage
 
 -- | Right hand side of a match (possible with guards): (@ -> 3 @ or @ | x == 1 -> 3; | otherwise -> 4 @)
-type CaseRhs dom = Ann UCaseRhs dom SrcTemplateStage
+type CaseRhs = Ann UCaseRhs IdDom SrcTemplateStage
 
 -- | A guarded right-hand side of pattern matches binding (@ | x > 3 -> 2 @)
-type GuardedCaseRhs dom = Ann UGuardedCaseRhs dom SrcTemplateStage
+type GuardedCaseRhs = Ann UGuardedCaseRhs IdDom SrcTemplateStage
 
 -- | Field update expressions
-type FieldUpdate dom = Ann UFieldUpdate dom SrcTemplateStage
+type FieldUpdate = Ann UFieldUpdate IdDom SrcTemplateStage
 
 -- | An element of a tuple section that can be an expression or missing (indicating a value from a parameter)
-type TupSecElem dom = Ann UTupSecElem dom SrcTemplateStage
+type TupSecElem = Ann UTupSecElem IdDom SrcTemplateStage
 
 -- | Pragmas that can be applied to expressions
-type ExprPragma dom = Ann UExprPragma dom SrcTemplateStage
+type ExprPragma = Ann UExprPragma IdDom SrcTemplateStage
 
 -- | Special expressions for arrows
-type Cmd dom = Ann UCmd dom SrcTemplateStage
+type Cmd = Ann UCmd IdDom SrcTemplateStage
 
 -- | Clause of case expression for commands
-type CmdAlt dom = Ann UCmdAlt dom SrcTemplateStage
+type CmdAlt = Ann UCmdAlt IdDom SrcTemplateStage
 
 -- | Arrow directions
-type ArrowApp dom = Ann UArrowAppl dom SrcTemplateStage
+type ArrowApp = Ann UArrowAppl IdDom SrcTemplateStage
 
 -- * Statements
 
 -- | A statement in a do-notation
-type Stmt dom = Ann UStmt dom SrcTemplateStage
+type Stmt = Ann UStmt IdDom SrcTemplateStage
 
 -- | Keywords @do@ or @mdo@ to start a do-block
-type DoKind dom = Ann UDoKind dom SrcTemplateStage
+type DoKind = Ann UDoKind IdDom SrcTemplateStage
 
 -- | List comprehension statement
-type CompStmt dom = Ann UCompStmt dom SrcTemplateStage
+type CompStmt = Ann UCompStmt IdDom SrcTemplateStage
 
 -- | Body of a list comprehension: (@ | x <- [1..10] @)
-type ListCompBody dom = Ann UListCompBody dom SrcTemplateStage
+type ListCompBody = Ann UListCompBody IdDom SrcTemplateStage
 
 -- | A do-notation for arrows
-type CmdStmt dom = Ann UCmdStmt dom SrcTemplateStage
+type CmdStmt = Ann UCmdStmt IdDom SrcTemplateStage
 
 -- * Patterns
 
 -- | Representation of patterns for pattern bindings
-type Pattern dom = Ann UPattern dom SrcTemplateStage
+type Pattern = Ann UPattern IdDom SrcTemplateStage
 
 -- Field specification of a record pattern
-type PatternField dom = Ann UPatternField dom SrcTemplateStage
+type PatternField = Ann UPatternField IdDom SrcTemplateStage
 
 -- * Template Haskell
 
 -- | A template haskell splice
-type Splice dom = Ann USplice dom SrcTemplateStage
+type Splice = Ann USplice IdDom SrcTemplateStage
 
 -- | Template Haskell bracket expressions
-type Bracket dom = Ann UBracket dom SrcTemplateStage
+type Bracket = Ann UBracket IdDom SrcTemplateStage
 
 -- | Template haskell quasi-quotation: @[quoter|str]@
-type QuasiQuote dom = Ann UQuasiQuote dom SrcTemplateStage
+type QuasiQuote = Ann UQuasiQuote IdDom SrcTemplateStage
 
 -- * Literals
 
 -- | Haskell literals
-type Literal dom = Ann ULiteral dom SrcTemplateStage
+type Literal = Ann ULiteral IdDom SrcTemplateStage
 
 -- * Names
 
 -- | A definition that functions as an operator
-type Operator dom = Ann UOperator dom SrcTemplateStage
+type Operator = Ann UOperator IdDom SrcTemplateStage
 
 -- | A definition that functions as a name
-type Name dom = Ann UName dom SrcTemplateStage
+type Name = Ann UName IdDom SrcTemplateStage
 
 -- | Possible qualified names. Contains also implicit names.
 -- Linear implicit parameter: @%x@. Non-linear implicit parameter: @?x@.
-type QualifiedName dom = Ann UQualifiedName dom SrcTemplateStage
+type QualifiedName = Ann UQualifiedName IdDom SrcTemplateStage
 
 -- | Parts of a qualified name.
-type NamePart dom = Ann UNamePart dom SrcTemplateStage
+type NamePart = Ann UNamePart IdDom SrcTemplateStage
 
 -- | Program elements formatted as string literals (import packages, pragma texts)
-type StringNode dom = Ann UStringNode dom SrcTemplateStage
+type StringNode = Ann UStringNode IdDom SrcTemplateStage
 
 -- * Optional AST elements
 
-type MaybeContext dom = AnnMaybe UContext dom
-type MaybeDeriving dom = AnnMaybe UDeriving dom
-type MaybeDeriveStrategy dom = AnnMaybe UDeriveStrategy dom
-type MaybeLocalBinds dom = AnnMaybe ULocalBinds dom
-type MaybeTypeFamilySpec dom = AnnMaybe UTypeFamilySpec dom
-type MaybeKindConstraint dom = AnnMaybe UKindConstraint dom
-type MaybeClassBody dom = AnnMaybe UClassBody dom
-type MaybeInstBody dom = AnnMaybe UInstBody dom
-type MaybeExpr dom = AnnMaybe UExpr dom
-type MaybeExportSpecs dom = AnnMaybe UExportSpecs dom
-type MaybeImportQualified dom = AnnMaybe UImportQualified dom
-type MaybeImportSource dom = AnnMaybe UImportSource dom
-type MaybeImportSafe dom = AnnMaybe UImportSafe dom
-type MaybeImportSpec dom = AnnMaybe UImportSpec dom
-type MaybeModuleHead dom = AnnMaybe UModuleHead dom
-type MaybeModulePragma dom = AnnMaybe UModulePragma dom
-type MaybeSubSpec dom = AnnMaybe USubSpec dom
-type MaybeStringNode dom = AnnMaybe UStringNode dom
-type MaybeImportRenaming dom = AnnMaybe UImportRenaming dom
-type MaybeSafety dom = AnnMaybe USafety dom
-type MaybePhaseControl dom = AnnMaybe UPhaseControl dom
-type MaybeConlikeAnnot dom = AnnMaybe UConlikeAnnot dom
-type MaybeFunDeps dom = AnnMaybe UFunDeps dom
+type MaybeContext = AnnMaybe UContext
+type MaybeDeriving = AnnMaybe UDeriving
+type MaybeDeriveStrategy = AnnMaybe UDeriveStrategy
+type MaybeLocalBinds = AnnMaybe ULocalBinds
+type MaybeTypeFamilySpec = AnnMaybe UTypeFamilySpec
+type MaybeKindConstraint = AnnMaybe UKindConstraint
+type MaybeClassBody = AnnMaybe UClassBody
+type MaybeInstBody = AnnMaybe UInstBody
+type MaybeExpr = AnnMaybe UExpr
+type MaybeExportSpecs = AnnMaybe UExportSpecs
+type MaybeImportQualified = AnnMaybe UImportQualified
+type MaybeImportSource = AnnMaybe UImportSource
+type MaybeImportSafe = AnnMaybe UImportSafe
+type MaybeImportSpec = AnnMaybe UImportSpec
+type MaybeModuleHead = AnnMaybe UModuleHead
+type MaybeModulePragma = AnnMaybe UModulePragma
+type MaybeSubSpec = AnnMaybe USubSpec
+type MaybeStringNode = AnnMaybe UStringNode
+type MaybeImportRenaming = AnnMaybe UImportRenaming
+type MaybeSafety = AnnMaybe USafety
+type MaybePhaseControl = AnnMaybe UPhaseControl
+type MaybeConlikeAnnot = AnnMaybe UConlikeAnnot
+type MaybeFunDeps = AnnMaybe UFunDeps
 
 
 -- * AST elements with multiplicity
 
-type MatchList dom = AnnList UMatch dom
-type DeclList dom = AnnList UDecl dom
-type PatternList dom = AnnList UPattern dom
-type OperatorList dom = AnnList UOperator dom
-type NameList dom = AnnList UName dom
-type LocalBindList dom = AnnList ULocalBind dom
-type IESpecList dom = AnnList UIESpec dom
-type RhsGuardList dom = AnnList URhsGuard dom
-type GuardedRhsList dom = AnnList UGuardedRhs dom
-type GuardedCaseRhsList dom = AnnList UGuardedCaseRhs dom
-type ConDeclList dom = AnnList UConDecl dom
-type TypeEqnList dom = AnnList UTypeEqn dom
-type TypeList dom = AnnList UType dom
-type FieldDeclList dom = AnnList UFieldDecl dom
-type ExprList dom = AnnList UExpr dom
-type FieldUpdateList dom = AnnList UFieldUpdate dom
-type GadtConDeclList dom = AnnList UGadtConDecl dom
-type ClassElementList dom = AnnList UClassElement dom
-type InstBodyDeclList dom = AnnList UInstBodyDecl dom
-type InstanceHeadList dom = AnnList UInstanceHead dom
-type AltList dom = AnnList UAlt dom
-type StmtList dom = AnnList UStmt dom
-type KindList dom = AnnList UKind dom
-type TyVarList dom = AnnList UTyVar dom
-type ListCompBodyList dom = AnnList UListCompBody dom
-type ExportSpecList dom = AnnList UExportSpec dom
-type FilePragmaList dom = AnnList UFilePragma dom
-type ImportDeclList dom = AnnList UImportDecl dom
-type PatternFieldList dom = AnnList UPatternField dom
-type AssertionList dom = AnnList UAssertion dom
-type CompStmtList dom = AnnList UCompStmt dom
-type RuleList dom = AnnList URule dom
-type RuleVarList dom = AnnList URuleVar dom
-type RoleList dom = AnnList URole dom
-type MinimalFormulaList dom = AnnList UMinimalFormula dom
-type FunDepList dom = AnnList UFunDep dom
-type TupSecElemList dom = AnnList UTupSecElem dom
-type CmdList dom = AnnList UCmd dom
-type CmdAltList dom = AnnList UCmdAlt dom
-type CmdStmtList dom = AnnList UCmdStmt dom
-type LanguageExtensionList dom = AnnList ULanguageExtension dom
-type StringNodeList dom = AnnList UStringNode dom
-type NamePartList dom = AnnList UNamePart dom
-type DerivingList dom = AnnList UDeriving dom
+type MatchList = AnnList UMatch
+type DeclList = AnnList UDecl
+type PatternList = AnnList UPattern
+type OperatorList = AnnList UOperator
+type NameList = AnnList UName
+type LocalBindList = AnnList ULocalBind
+type IESpecList = AnnList UIESpec
+type RhsGuardList = AnnList URhsGuard
+type GuardedRhsList = AnnList UGuardedRhs
+type GuardedCaseRhsList = AnnList UGuardedCaseRhs
+type ConDeclList = AnnList UConDecl
+type TypeEqnList = AnnList UTypeEqn
+type TypeList = AnnList UType
+type FieldDeclList = AnnList UFieldDecl
+type ExprList = AnnList UExpr
+type FieldUpdateList = AnnList UFieldUpdate
+type GadtConDeclList = AnnList UGadtConDecl
+type ClassElementList = AnnList UClassElement
+type InstBodyDeclList = AnnList UInstBodyDecl
+type InstanceHeadList = AnnList UInstanceHead
+type AltList = AnnList UAlt
+type StmtList = AnnList UStmt
+type KindList = AnnList UKind
+type TyVarList = AnnList UTyVar
+type ListCompBodyList = AnnList UListCompBody
+type ExportSpecList = AnnList UExportSpec
+type FilePragmaList = AnnList UFilePragma
+type ImportDeclList = AnnList UImportDecl
+type PatternFieldList = AnnList UPatternField
+type AssertionList = AnnList UAssertion
+type CompStmtList = AnnList UCompStmt
+type RuleList = AnnList URule
+type RuleVarList = AnnList URuleVar
+type RoleList = AnnList URole
+type MinimalFormulaList = AnnList UMinimalFormula
+type FunDepList = AnnList UFunDep
+type TupSecElemList = AnnList UTupSecElem
+type CmdList = AnnList UCmd
+type CmdAltList = AnnList UCmdAlt
+type CmdStmtList = AnnList UCmdStmt
+type LanguageExtensionList = AnnList ULanguageExtension
+type StringNodeList = AnnList UStringNode
+type NamePartList = AnnList UNamePart
+type DerivingList = AnnList UDeriving
Language/Haskell/Tools/Rewrite/Match/Binds.hs view
@@ -6,77 +6,77 @@ import Language.Haskell.Tools.Rewrite.ElementTypes
 
 -- | Non-function binding (@ v = "12" @)
-pattern SimpleBind :: Pattern dom -> Rhs dom -> MaybeLocalBinds dom -> ValueBind dom
+pattern SimpleBind :: Pattern -> Rhs -> MaybeLocalBinds -> ValueBind
 pattern SimpleBind p r l <- Ann _ (USimpleBind p r l)
 
 -- | Function binding (@ f 0 = 1; f x = x @). All matches must have the same name.
-pattern FunctionBind :: MatchList dom -> ValueBind dom
+pattern FunctionBind :: MatchList -> ValueBind
 pattern FunctionBind matches <- Ann _ (UFunBind matches)
 
 -- | Clause of function binding
-pattern Match :: MatchLhs dom -> Rhs dom -> MaybeLocalBinds dom -> Match dom
+pattern Match :: MatchLhs -> Rhs -> MaybeLocalBinds -> Match
 pattern Match lhs rhs locs <- Ann _ (UMatch lhs rhs locs)
 
 -- | A match lhs with the function name and parameter names (@ f a b @)
-pattern MatchLhs :: Name dom -> PatternList dom -> MatchLhs dom
+pattern MatchLhs :: Name -> PatternList -> MatchLhs
 pattern MatchLhs n pats <- Ann _ (UNormalLhs n pats)
 
 -- | An infix match lhs for an operator (@ a + b @)
-pattern InfixLhs :: Pattern dom -> Operator dom -> Pattern dom -> PatternList dom -> MatchLhs dom
+pattern InfixLhs :: Pattern -> Operator -> Pattern -> PatternList -> MatchLhs
 pattern InfixLhs lhs op rhs pats <- Ann _ (UInfixLhs lhs op rhs pats)
 
 -- | Local bindings attached to a declaration (@ where x = 42 @)
-pattern LocalBinds :: LocalBindList dom -> LocalBinds dom
+pattern LocalBinds :: LocalBindList -> LocalBinds
 pattern LocalBinds binds <- Ann _ (ULocalBinds binds)
 
 -- | A local binding for a value
-pattern LocalValBind :: ValueBind dom -> LocalBind dom
+pattern LocalValBind :: ValueBind -> LocalBind
 pattern LocalValBind bind <- Ann _ (ULocalValBind bind)
 
 -- | A local type signature
-pattern LocalTypeSig :: TypeSignature dom -> LocalBind dom
+pattern LocalTypeSig :: TypeSignature -> LocalBind
 pattern LocalTypeSig typeSig <- Ann _ (ULocalSignature typeSig)
 
 -- | A local fixity declaration
-pattern LocalFixity :: FixitySignature dom -> LocalBind dom
+pattern LocalFixity :: FixitySignature -> LocalBind
 pattern LocalFixity fixity <- Ann _ (ULocalFixity fixity)
 
 -- | A type signature (@ f :: Int -> Int @)
-pattern TypeSignature :: NameList dom -> Type dom -> TypeSignature dom
+pattern TypeSignature :: NameList -> Type -> TypeSignature
 pattern TypeSignature n t <- Ann _ (UTypeSignature n t)
 
 -- | A left-associative fixity declaration (@ infixl 5 +, - @).
-pattern InfixL :: OperatorList dom -> FixitySignature dom
+pattern InfixL :: OperatorList -> FixitySignature
 pattern InfixL op <- Ann _ (UFixitySignature (Ann _ AssocLeft) _ op)
 
 -- | A right-associative fixity declaration (@ infixr 5 +, - @).
-pattern InfixR :: OperatorList dom -> FixitySignature dom
+pattern InfixR :: OperatorList -> FixitySignature
 pattern InfixR op <- Ann _ (UFixitySignature (Ann _ AssocRight) _ op)
 
 -- | A non-associative fixity declaration (@ infix 5 +, - @).
-pattern Infix :: OperatorList dom -> FixitySignature dom
+pattern Infix :: OperatorList -> FixitySignature
 pattern Infix op <- Ann _ (UFixitySignature (Ann _ AssocNone) _ op)
 
 -- | An unguarded right-hand-side (@ = 3 @)
-pattern UnguardedRhs :: Expr dom -> Rhs dom
+pattern UnguardedRhs :: Expr -> Rhs
 pattern UnguardedRhs expr <- Ann _ (UUnguardedRhs expr)
 
 -- | An unguarded right-hand-side (@ | x == 1 = 3; | otherwise = 4 @)
-pattern GuardedRhss :: GuardedRhsList dom -> Rhs dom
+pattern GuardedRhss :: GuardedRhsList -> Rhs
 pattern GuardedRhss rhss <- Ann _ (UGuardedRhss rhss)
 
 -- | A guarded right-hand side of a value binding (@ | x > 3 = 2 @)
-pattern GuardedRhs :: RhsGuardList dom -> Expr dom -> GuardedRhs dom
+pattern GuardedRhs :: RhsGuardList -> Expr -> GuardedRhs
 pattern GuardedRhs guards expr <- Ann _ (UGuardedRhs guards expr)
 
 -- | A bind statement in a pattern guard (@ Just v <- x @)
-pattern GuardBind :: Pattern dom -> Expr dom -> RhsGuard dom
+pattern GuardBind :: Pattern -> Expr -> RhsGuard
 pattern GuardBind pat expr <- Ann _ (UGuardBind pat expr)
 
 -- | A let statement in a pattern guard (@ let x = 3 @)
-pattern GuardLet :: LocalBindList dom -> RhsGuard dom
+pattern GuardLet :: LocalBindList -> RhsGuard
 pattern GuardLet binds <- Ann _ (UGuardLet binds)
 
 -- | An expression to check for a pattern guard
-pattern GuardCheck :: Expr dom -> RhsGuard dom
+pattern GuardCheck :: Expr -> RhsGuard
 pattern GuardCheck expr <- Ann _ (UGuardCheck expr)
Language/Haskell/Tools/Rewrite/Match/Decls.hs view
@@ -10,429 +10,429 @@ -- * Declarations
 
 -- | A type synonym ( @type String = [Char]@ )
-pattern TypeDecl :: DeclHead dom -> Type dom -> Decl dom
+pattern TypeDecl :: DeclHead -> Type -> Decl
 pattern TypeDecl dh typ <- Ann _ (UTypeDecl dh typ)
 
 -- | Standalone deriving declaration (@ deriving instance X T @)
-pattern StandaloneDeriving :: Maybe (DeriveStrategy dom) -> Maybe (OverlapPragma dom) -> InstanceRule dom -> Decl dom
+pattern StandaloneDeriving :: Maybe DeriveStrategy -> Maybe OverlapPragma -> InstanceRule -> Decl
 pattern StandaloneDeriving strat overlap instRule <- Ann _ (UDerivDecl (AnnMaybeG _ strat) (AnnMaybeG _ overlap) instRule)
 
 -- | Fixity declaration (@ infixl 5 +, - @)
-pattern FixityDecl :: FixitySignature dom -> Decl dom
+pattern FixityDecl :: FixitySignature -> Decl
 pattern FixityDecl fixity <- Ann _ (UFixityDecl fixity)
 
 -- | Default types (@ default (T1, T2) @)
-pattern DefaultDecl :: TypeList dom -> Decl dom
+pattern DefaultDecl :: TypeList -> Decl
 pattern DefaultDecl types <- Ann _ (UDefaultDecl types)
 
 -- | Type signature declaration (@ f :: Int -> Int @)
-pattern TypeSigDecl :: TypeSignature dom -> Decl dom
+pattern TypeSigDecl :: TypeSignature -> Decl
 pattern TypeSigDecl typeSig <- Ann _ (UTypeSigDecl typeSig)
 
 -- | Function or value binding (@ f x = 12 @)
-pattern ValueBinding :: ValueBind dom -> Decl dom
+pattern ValueBinding :: ValueBind -> Decl
 pattern ValueBinding bind <- Ann _ (UValueBinding bind)
 
 -- | A Template Haskell splice declaration (@ $(generateDecls) @)
-pattern SpliceDecl :: Splice dom -> Decl dom
+pattern SpliceDecl :: Splice -> Decl
 pattern SpliceDecl sp <- Ann _ (USpliceDecl sp)
 
 -- * Data type definitions
 
 -- | A data or newtype declaration. Empty data type declarations without
 -- where keyword are always belong to DataDecl.
-pattern DataDecl :: DataOrNewtypeKeyword dom -> MaybeContext dom -> DeclHead dom -> ConDeclList dom -> DerivingList dom -> Decl dom
+pattern DataDecl :: DataOrNewtypeKeyword -> MaybeContext -> DeclHead -> ConDeclList -> DerivingList -> Decl
 pattern DataDecl keyw ctx dh cons derivs <- Ann _ (UDataDecl keyw ctx dh cons derivs)
 
 -- | A GADT-style data or newtype declaration.
-pattern GADTDataDecl :: DataOrNewtypeKeyword dom -> MaybeContext dom -> DeclHead dom -> MaybeKindConstraint dome -> AnnListG UGadtConDecl dom stage -> DerivingList dom -> Decl dom
+pattern GADTDataDecl :: DataOrNewtypeKeyword -> MaybeContext -> DeclHead -> MaybeKindConstraint -> AnnList UGadtConDecl -> DerivingList -> Decl
 pattern GADTDataDecl keyw ctx dh kind cons derivs  <- Ann _ (UGDataDecl keyw ctx dh kind cons derivs )
 
 -- | GADT constructor declaration (@ D1 :: Int -> T String @)
-pattern GadtConDecl :: NameList dom -> Type dom -> GadtConDecl dom
+pattern GadtConDecl :: NameList -> Type -> GadtConDecl
 pattern GadtConDecl names typ <- Ann _ (UGadtConDecl names _ _ (Ann _ (UGadtNormalType typ)))
 
 -- | GADT constructor declaration with record syntax (@ D1 :: { val :: Int } -> T String @)
-pattern GadtRecordConDecl :: NameList dom -> FieldDeclList dom -> Type dom -> GadtConDecl dom
+pattern GadtRecordConDecl :: NameList -> FieldDeclList -> Type -> GadtConDecl
 pattern GadtRecordConDecl names fields typ <- Ann _ (UGadtConDecl names _ _ (Ann _ (UGadtRecordType fields typ)))
 
 -- | Ordinary data constructor (@ C t1 t2 @)
-pattern ConDecl :: Name dom -> TypeList dom -> ConDecl dom
+pattern ConDecl :: Name -> TypeList -> ConDecl
 pattern ConDecl name args <- Ann _ (UConDecl _ _ name args)
 
 -- | Creates a record data constructor (@ Point { x :: Double, y :: Double } @)
-pattern RecordConDecl :: Name dom -> FieldDeclList dom -> ConDecl dom
+pattern RecordConDecl :: Name -> FieldDeclList -> ConDecl
 pattern RecordConDecl name fields <- Ann _ (URecordDecl _ _ name fields)
 
 -- | Infix data constructor (@ t1 :+: t2 @)
-pattern InfixConDecl :: Type dom -> Operator dom -> Type dom -> ConDecl dom
+pattern InfixConDecl :: Type -> Operator -> Type -> ConDecl
 pattern InfixConDecl lhs op rhs <- Ann _ (UInfixConDecl _ _ lhs op rhs)
 
 -- | Field declaration (@ fld :: Int @)
-pattern FieldDecl :: NameList dom -> Type dom -> FieldDecl dom
+pattern FieldDecl :: NameList -> Type -> FieldDecl
 pattern FieldDecl names typ <- Ann _ (UFieldDecl names typ)
 
 -- | A deriving clause without parentheses (@ deriving Show @.
-pattern DerivingOne :: InstanceHead dom -> Deriving dom
+pattern DerivingOne :: InstanceHead -> Deriving
 pattern DerivingOne deriv <- Ann _ (UDerivingOne _ deriv)
 
 -- | A deriving clause without parentheses, with/witohut strategy (@ deriving stock Show @.
-pattern DerivingOne' :: MaybeDeriveStrategy dom -> InstanceHead dom -> Deriving dom
+pattern DerivingOne' :: MaybeDeriveStrategy -> InstanceHead -> Deriving
 pattern DerivingOne' strat deriv <- Ann _ (UDerivingOne strat deriv)
 
 -- | A deriving clause with parentheses @ deriving (Show, Eq) @)
-pattern DerivingMulti :: InstanceHeadList dom -> Deriving dom
+pattern DerivingMulti :: InstanceHeadList -> Deriving
 pattern DerivingMulti derivs <- Ann _ (UDerivings _ derivs)
 
 -- | A deriving clause with parentheses, with/witohut strategy (@ deriving stock (Show, Eq) @.
-pattern DerivingMulti' :: MaybeDeriveStrategy dom -> InstanceHeadList dom -> Deriving dom
+pattern DerivingMulti' :: MaybeDeriveStrategy -> InstanceHeadList -> Deriving
 pattern DerivingMulti' strat derivs <- Ann _ (UDerivings strat derivs)
 
-pattern DataKeyword :: DataOrNewtypeKeyword dom
+pattern DataKeyword :: DataOrNewtypeKeyword
 pattern DataKeyword <- Ann _ UDataKeyword
 
-pattern NewtypeKeyword :: DataOrNewtypeKeyword dom
+pattern NewtypeKeyword :: DataOrNewtypeKeyword
 pattern NewtypeKeyword <- Ann _ UNewtypeKeyword
 
 -- | A list of functional dependencies: @ | a -> b, c -> d @ separated by commas
-pattern FunDeps :: FunDepList dom -> FunDeps dom
+pattern FunDeps :: FunDepList -> FunDeps
 pattern FunDeps fds <- Ann _ (UFunDeps fds)
 
 -- | A functional dependency, given on the form @l1 ... ln -> r1 ... rn@
-pattern FunDep :: NameList dom -> NameList dom -> FunDep dom
+pattern FunDep :: NameList -> NameList -> FunDep
 pattern FunDep lhs rhs <- Ann _ (UFunDep lhs rhs)
 
 -- * Type class declarations
 
 -- | Type class declaration (@ class X a [where f = ...] @)
-pattern ClassDecl :: MaybeContext dom -> DeclHead dom -> MaybeFunDeps dom -> MaybeClassBody dom -> Decl dom
+pattern ClassDecl :: MaybeContext -> DeclHead -> MaybeFunDeps -> MaybeClassBody -> Decl
 pattern ClassDecl ctx dh fdeps body <- Ann _ (UClassDecl ctx dh fdeps body)
 
 -- | The list of declarations that can appear in a typeclass
-pattern ClassBody :: ClassElementList dom -> ClassBody dom
+pattern ClassBody :: ClassElementList -> ClassBody
 pattern ClassBody body <- Ann _ (UClassBody body)
 
 -- | Type signature: @ f :: A -> B @ as a class member
-pattern ClassElemSig :: TypeSignature dom -> ClassElement dom
+pattern ClassElemSig :: TypeSignature -> ClassElement
 pattern ClassElemSig typeSig <- Ann _ (UClsSig typeSig)
 
 -- | Default binding: @ f x = "aaa" @ as a class member
-pattern ClassElemDef :: ValueBind dom -> ClassElement dom
+pattern ClassElemDef :: ValueBind -> ClassElement
 pattern ClassElemDef def <- Ann _ (UClsDef def)
 
 -- | Declaration of an associated type synonym: @ type T x :: * @ in a class
-pattern ClassElemTypeFam :: DeclHead dom -> MaybeTypeFamilySpec dom -> ClassElement dom
+pattern ClassElemTypeFam :: DeclHead -> MaybeTypeFamilySpec -> ClassElement
 pattern ClassElemTypeFam dh tfSpec <- Ann _ (UClsTypeFam (Ann _ (UTypeFamily dh tfSpec)))
 
 -- | Declaration of an associated data synonym: @ data T x :: * @ in a class
-pattern ClassElemDataFam :: DeclHead dom -> MaybeKindConstraint dome -> ClassElement dom
+pattern ClassElemDataFam :: DeclHead -> MaybeKindConstraint -> ClassElement
 pattern ClassElemDataFam dh kind <- Ann _ (UClsTypeFam (Ann _ (UDataFamily dh kind)))
 
 -- | Default choice for type synonym: @ type T x = TE @ or @ type instance T x = TE @ in a class
-pattern ClsDefaultType :: DeclHead dom -> Type dom -> ClassElement dom
+pattern ClsDefaultType :: DeclHead -> Type -> ClassElement
 pattern ClsDefaultType dh typ <- Ann _ (UClsTypeDef dh typ)
 
 -- | Default signature (by using @DefaultSignatures@): @ default enum :: (Generic a, GEnum (Rep a)) => [a] @
-pattern ClsDefaultSig :: Name dom -> Type dom -> ClassElement dom
+pattern ClsDefaultSig :: Name -> Type -> ClassElement
 pattern ClsDefaultSig name typ <- Ann _ (UClsDefSig name typ)
 
 -- | Minimal pragma: @ {-\# MINIMAL (==) | (/=) \#-} @ in a class
-pattern ClsMinimal :: MinimalFormula dom -> ClassElement dom
+pattern ClsMinimal :: MinimalFormula -> ClassElement
 pattern ClsMinimal min <- Ann _ (UClsMinimal min)
 
-pattern MinimalName :: Name dom -> MinimalFormula dom
+pattern MinimalName :: Name -> MinimalFormula
 pattern MinimalName name <- Ann _ (UMinimalName name)
 
-pattern MinimalParen :: MinimalFormula dom -> MinimalFormula dom
+pattern MinimalParen :: MinimalFormula -> MinimalFormula
 pattern MinimalParen min <- Ann _ (UMinimalParen min)
 
 -- | One of the minimal formulas are needed (@ min1 | min2 @)
-pattern MinimalOr :: MinimalFormulaList dom -> MinimalFormula dom
+pattern MinimalOr :: MinimalFormulaList -> MinimalFormula
 pattern MinimalOr mins <- Ann _ (UMinimalOr mins)
 
 -- | Both of the minimal formulas are needed (@ min1 , min2 @)
-pattern MinimalAnd :: MinimalFormulaList dom -> MinimalFormula dom
+pattern MinimalAnd :: MinimalFormulaList -> MinimalFormula
 pattern MinimalAnd mins <- Ann _ (UMinimalAnd mins)
 
 -- * Declaration heads
 
 -- | Type or class name as a declaration head
-pattern NameDeclHead :: Name dom -> DeclHead dom
+pattern NameDeclHead :: Name -> DeclHead
 pattern NameDeclHead name <- Ann _ (UDeclHead name)
 
 -- | Parenthesized type as a declaration head
-pattern ParenDeclHead :: DeclHead dom -> DeclHead dom
+pattern ParenDeclHead :: DeclHead -> DeclHead
 pattern ParenDeclHead dh <- Ann _ (UDHParen dh)
 
 -- | Type application as a declaration head
-pattern DeclHeadApp :: DeclHead dom -> TyVar dom -> DeclHead dom
+pattern DeclHeadApp :: DeclHead -> TyVar -> DeclHead
 pattern DeclHeadApp dh tv <- Ann _ (UDHApp dh tv)
 
 -- | Infix type application as a declaration head
-pattern InfixDeclHead :: TyVar dom -> Operator dom -> TyVar dom -> DeclHead dom
+pattern InfixDeclHead :: TyVar -> Operator -> TyVar -> DeclHead
 pattern InfixDeclHead lhs op rhs <- Ann _ (UDHInfix lhs op rhs)
 
 -- * Type class instance declarations
 
 -- | Instance declaration (@ instance X T [where f = ...] @)
-pattern InstanceDecl :: InstanceRule dom -> MaybeInstBody dom -> Decl dom
+pattern InstanceDecl :: InstanceRule -> MaybeInstBody -> Decl
 pattern InstanceDecl instRule body <- Ann _ (UInstDecl _ instRule body)
 
 -- | Instance body is the implementation of the class functions (@ where a x = 1; b x = 2 @)
-pattern InstanceBody :: InstBodyDeclList dom -> InstBody dom
+pattern InstanceBody :: InstBodyDeclList -> InstBody
 pattern InstanceBody defs <- Ann _ (UInstBody defs)
 
 -- | A normal value binding (@ f x = 12 @) inside a class instance
-pattern InstanceBind :: ValueBind dom -> InstBodyDecl dom
+pattern InstanceBind :: ValueBind -> InstBodyDecl
 pattern InstanceBind bind <- Ann _ (UInstBodyNormalDecl bind)
 
 -- | Type signature in instance definition with @InstanceSigs@
-pattern InstanceTypeSig :: TypeSignature dom -> InstBodyDecl dom
+pattern InstanceTypeSig :: TypeSignature -> InstBodyDecl
 pattern InstanceTypeSig typeSig <- Ann _ (UInstBodyTypeSig typeSig)
 
 -- | An associated type definition (@ type A X = B @) in a class instance
-pattern InstanceTypeFamilyDef :: TypeEqn dom -> InstBodyDecl dom
+pattern InstanceTypeFamilyDef :: TypeEqn -> InstBodyDecl
 pattern InstanceTypeFamilyDef typeEq <- Ann _ (UInstBodyTypeDecl typeEq)
 
 -- | An associated data definition (@ data A X = B Int | C @) in a class instance
-pattern InstanceDataFamilyDef :: DataOrNewtypeKeyword dom -> InstanceRule dom -> ConDeclList dom -> DerivingList dom -> InstBodyDecl dom
+pattern InstanceDataFamilyDef :: DataOrNewtypeKeyword -> InstanceRule -> ConDeclList -> DerivingList -> InstBodyDecl
 pattern InstanceDataFamilyDef keyw instRule cons derivs  <- Ann _ (UInstBodyDataDecl keyw instRule cons derivs )
 
 -- | An associated data definition as a GADT (@ data A X where B :: Int -> A X @) in a class instance
-pattern InstanceDataFamilyGADTDef :: DataOrNewtypeKeyword dom -> InstanceRule dom -> MaybeKindConstraint dome -> AnnListG UGadtConDecl dom stage
-                                       -> DerivingList dom -> InstBodyDecl dom
+pattern InstanceDataFamilyGADTDef :: DataOrNewtypeKeyword -> InstanceRule -> MaybeKindConstraint -> AnnList UGadtConDecl
+                                       -> DerivingList -> InstBodyDecl
 pattern InstanceDataFamilyGADTDef keyw instRule kind cons derivs <- Ann _ (UInstBodyGadtDataDecl keyw instRule kind cons derivs)
 
 -- | Specialize instance pragma in a class instance  (no phase selection is allowed)
-pattern InstanceSpecializePragma :: Type dom -> InstBodyDecl dom
+pattern InstanceSpecializePragma :: Type -> InstBodyDecl
 pattern InstanceSpecializePragma typ <- Ann _ (USpecializeInstance typ)
 
 -- | Instance head as an instance rule (@ X a => Y a @)
-pattern InstanceRule :: AnnMaybeG (AnnListG UTyVar) dom stage -> MaybeContext dom -> InstanceHead dom -> InstanceRule dom
+pattern InstanceRule :: AnnMaybe (AnnListG UTyVar) -> MaybeContext -> InstanceHead -> InstanceRule
 pattern InstanceRule tvs ctx ih <- Ann _ (UInstanceRule tvs ctx ih)
 
 -- | Type or class name as an instance head
-pattern InstanceHead :: Name dom -> InstanceHead dom
+pattern InstanceHead :: Name -> InstanceHead
 pattern InstanceHead name <- Ann _ (UInstanceHeadCon name)
 
 -- | Infix application of the type/class name to the left operand as an instance head
-pattern InfixInstanceHead :: Type dom -> Operator dom -> InstanceHead dom
+pattern InfixInstanceHead :: Type -> Operator -> InstanceHead
 pattern InfixInstanceHead typ n <- Ann _ (UInstanceHeadInfix typ n)
 
 -- | Parenthesized instance head
-pattern ParenInstanceHead :: InstanceHead dom -> InstanceHead dom
+pattern ParenInstanceHead :: InstanceHead -> InstanceHead
 pattern ParenInstanceHead ih <- Ann _ (UInstanceHeadParen ih)
 
 -- | Type application as an instance head
-pattern AppInstanceHead :: InstanceHead dom -> Type dom -> InstanceHead dom
+pattern AppInstanceHead :: InstanceHead -> Type -> InstanceHead
 pattern AppInstanceHead fun arg <- Ann _ (UInstanceHeadApp fun arg)
 
 -- | @OVERLAP@ pragma
-pattern EnableOverlap :: OverlapPragma dom
+pattern EnableOverlap :: OverlapPragma
 pattern EnableOverlap <- Ann _ UEnableOverlap
 
 -- | @NO_OVERLAP@ pragma
-pattern DisableOverlap :: OverlapPragma dom
+pattern DisableOverlap :: OverlapPragma
 pattern DisableOverlap <- Ann _ UDisableOverlap
 
 -- | @OVERLAPPABLE@ pragma
-pattern Overlappable :: OverlapPragma dom
+pattern Overlappable :: OverlapPragma
 pattern Overlappable <- Ann _ UOverlappable
 
 -- | @OVERLAPPING@ pragma
-pattern Overlapping :: OverlapPragma dom
+pattern Overlapping :: OverlapPragma
 pattern Overlapping <- Ann _ UOverlapping
 
 -- | @OVERLAPS@ pragma
-pattern Overlaps :: OverlapPragma dom
+pattern Overlaps :: OverlapPragma
 pattern Overlaps <- Ann _ UOverlaps
 
 -- | @INCOHERENT@ pragma
-pattern IncoherentOverlap :: OverlapPragma dom
+pattern IncoherentOverlap :: OverlapPragma
 pattern IncoherentOverlap <- Ann _ UIncoherentOverlap
 
 -- * Type roles
 
 -- | Role annotations (@ type role Ptr representational @)
-pattern RoleDecl :: QualifiedName dom -> RoleList dom -> Decl dom
+pattern RoleDecl :: QualifiedName -> RoleList -> Decl
 pattern RoleDecl name roles <- Ann _ (URoleDecl name roles)
 
-pattern NominalRole :: Role dom
+pattern NominalRole :: Role
 pattern NominalRole <- Ann _ UNominal
 
-pattern RepresentationalRole :: Role dom
+pattern RepresentationalRole :: Role
 pattern RepresentationalRole <- Ann _ URepresentational
 
-pattern PhantomRole :: Role dom
+pattern PhantomRole :: Role
 pattern PhantomRole <- Ann _ UPhantom
 
 -- * Foreign imports and exports
 
 -- | Foreign import (@ foreign import foo :: Int -> IO Int @)
-pattern ForeignImport :: CallConv dom -> MaybeSafety dom -> Name dom -> Type dom -> Decl dom
+pattern ForeignImport :: CallConv -> MaybeSafety -> Name -> Type -> Decl
 pattern ForeignImport cc safety name typ <- Ann _ (UForeignImport cc safety name typ)
 
 -- | Foreign export (@ foreign export ccall foo :: Int -> IO Int @)
-pattern ForeignExport :: CallConv dom -> Name dom -> Type dom -> Decl dom
+pattern ForeignExport :: CallConv -> Name -> Type -> Decl
 pattern ForeignExport cc name typ <- Ann _ (UForeignExport cc name typ)
 
 -- | Specifies @stdcall@ calling convention for foreign import/export.
-pattern StdCall :: CallConv dom
+pattern StdCall :: CallConv
 pattern StdCall <- Ann _ UStdCall
 
 -- | Specifies @ccall@ calling convention for foreign import/export.
-pattern CCall :: CallConv dom
+pattern CCall :: CallConv
 pattern CCall <- Ann _ UCCall
 
 -- | Specifies @capi@ calling convention for foreign import/export.
-pattern CApi :: CallConv dom
+pattern CApi :: CallConv
 pattern CApi <- Ann _ UCApi
 
 -- | Specifies that the given foreign import is @unsafe@.
-pattern Unsafe :: Safety dom
+pattern Unsafe :: Safety
 pattern Unsafe <- Ann _ UUnsafe
 
 -- * Pattern synonyms
 
 -- | Pattern synonyms (@ pattern Arrow t1 t2 = App \"->\" [t1, t2] @)
-pattern PatternSynonym :: PatSynLhs dom -> PatSynRhs dom -> Decl dom
+pattern PatternSynonym :: PatSynLhs -> PatSynRhs -> Decl
 pattern PatternSynonym lhs rhs <- Ann _ (UPatternSynonymDecl (Ann _ (UPatternSynonym lhs rhs)))
 
 -- | A left hand side with a constructor name and arguments (@ Arrow t1 t2 @)
-pattern ConPatSyn :: Name dom -> NameList dom -> PatSynLhs dom
+pattern ConPatSyn :: Name -> NameList -> PatSynLhs
 pattern ConPatSyn con args <- Ann _ (UNormalPatSyn con args)
 
 -- | An infix pattern synonym left-hand side (@ t1 :+: t2 @)
-pattern InfixPatSyn :: Name dom -> Operator dom -> Name dom -> PatSynLhs dom
+pattern InfixPatSyn :: Name -> Operator -> Name -> PatSynLhs
 pattern InfixPatSyn lhs op rhs <- Ann _ (UInfixPatSyn lhs op rhs)
 
 -- | A record-style pattern synonym left-hand side (@ Arrow { arrowFrom, arrowTo } @)
-pattern RecordPatSyn :: Name dom -> NameList dom -> PatSynLhs dom
+pattern RecordPatSyn :: Name -> NameList -> PatSynLhs
 pattern RecordPatSyn con args <- Ann _ (URecordPatSyn con args)
 
 -- | An automatically two-way pattern synonym (@ = App \"Int\" [] @)
-pattern SymmetricPatSyn :: Pattern dom -> PatSynRhs dom
+pattern SymmetricPatSyn :: Pattern -> PatSynRhs
 pattern SymmetricPatSyn pat <- Ann _ (UBidirectionalPatSyn pat AnnNothing)
 
 -- | A pattern synonym that can be only used for pattenr matching but not for combining (@ <- App \"Int\" [] @)
-pattern OneWayPatSyn :: Pattern dom -> PatSynRhs dom
+pattern OneWayPatSyn :: Pattern -> PatSynRhs
 pattern OneWayPatSyn pat <- Ann _ (UOneDirectionalPatSyn pat)
 
 -- | A pattern synonym with the other direction explicitly specified (@ <- App \"Int\" [] where Int = App \"Int\" [] @)
-pattern TwoWayPatSyn :: Pattern dom -> MatchList dom -> PatSynRhs dom
+pattern TwoWayPatSyn :: Pattern -> MatchList -> PatSynRhs
 pattern TwoWayPatSyn pat match <- Ann _ (UBidirectionalPatSyn pat (AnnJust (Ann _ (UPatSynWhere match))))
 
 -- | Pattern type signature declaration (@ pattern Succ :: Int -> Int @)
-pattern PatternSignatureDecl :: PatternSignature dom -> Decl dom
+pattern PatternSignatureDecl :: PatternSignature -> Decl
 pattern PatternSignatureDecl patsig <- Ann _ (UPatTypeSigDecl patsig)
 
-pattern PatternSignature :: NameList dom -> Type dom -> PatternSignature dom
+pattern PatternSignature :: NameList -> Type -> PatternSignature
 pattern PatternSignature name typ <- Ann _ (UPatternTypeSignature name typ)
 
 -- * Type families
 
 -- | Type family declaration (@ type family A a :: * -> * @)
-pattern TypeFamily :: DeclHead dom -> MaybeTypeFamilySpec dom -> Decl dom
+pattern TypeFamily :: DeclHead -> MaybeTypeFamilySpec -> Decl
 pattern TypeFamily dh famSpec <- Ann _ (UTypeFamilyDecl (Ann _ (UTypeFamily dh famSpec)))
 
 -- | Data family declaration (@ data family A a :: * -> * @)
-pattern DataFamily :: DeclHead dom -> MaybeKindConstraint dom -> Decl dom
+pattern DataFamily :: DeclHead -> MaybeKindConstraint -> Decl
 pattern DataFamily dh kind <- Ann _ (UTypeFamilyDecl (Ann _ (UDataFamily dh kind)))
 
 -- | Type family instance declaration (@ type instance Fam T = AssignedT @)
-pattern TypeInstance :: InstanceRule dom -> Type dom -> Decl dom
+pattern TypeInstance :: InstanceRule -> Type -> Decl
 pattern TypeInstance instRule typ <- Ann _ (UTypeInstDecl instRule typ)
 
 -- | Data instance declaration (@ data instance Fam T = Con1 | Con2 @)
-pattern DataInstance :: DataOrNewtypeKeyword dom -> InstanceRule dom -> ConDeclList dom -> DerivingList dom -> Decl dom
+pattern DataInstance :: DataOrNewtypeKeyword -> InstanceRule -> ConDeclList -> DerivingList -> Decl
 pattern DataInstance keyw instRule cons derivs  <- Ann _ (UDataInstDecl keyw instRule cons derivs )
 
 -- | GADT-style data instance declaration (@ data instance Fam T where ... @)
-pattern GadtDataInstance :: DataOrNewtypeKeyword dom -> InstanceRule dom -> MaybeKindConstraint dome -> GadtConDeclList dom -> Decl dom
+pattern GadtDataInstance :: DataOrNewtypeKeyword -> InstanceRule -> MaybeKindConstraint -> GadtConDeclList -> Decl
 pattern GadtDataInstance keyw instRule kind cons  <- Ann _ (UGDataInstDecl keyw instRule kind cons )
 
 -- | A closed type family declaration
-pattern ClosedTypeFamily :: DeclHead dom -> MaybeTypeFamilySpec dom -> TypeEqnList dom -> Decl dom
+pattern ClosedTypeFamily :: DeclHead -> MaybeTypeFamilySpec -> TypeEqnList -> Decl
 pattern ClosedTypeFamily dh kind typeqs <- Ann _ (UClosedTypeFamilyDecl dh kind typeqs)
 
 -- | Specifies the kind of a type family (@ :: * -> * @)
-pattern TypeFamilyKindSpec :: KindConstraint dom -> TypeFamilySpec dom
+pattern TypeFamilyKindSpec :: KindConstraint -> TypeFamilySpec
 pattern TypeFamilyKindSpec kind <- Ann _ (UTypeFamilyKind kind)
 
 -- | Specifies the injectivity of a type family (@ = r | r -> a @)
-pattern TypeFamilyInjectivitySpec :: TyVar dom -> NameList dom -> TypeFamilySpec dom
+pattern TypeFamilyInjectivitySpec :: TyVar -> NameList -> TypeFamilySpec
 pattern TypeFamilyInjectivitySpec res dependent <- Ann _ (UTypeFamilyInjectivity (Ann _ (UInjectivityAnn res dependent)))
 
 -- | Type equations as found in closed type families (@ T A = S @)
-pattern TypeEqn :: Type dom -> Type dom -> TypeEqn dom
+pattern TypeEqn :: Type -> Type -> TypeEqn
 pattern TypeEqn lhs rhs <- Ann _ (UTypeEqn lhs rhs)
 
 -- * Top level pragmas
 
 -- | Top-level pragmas
-pattern PragmaDecl :: TopLevelPragma dom -> Decl dom
+pattern PragmaDecl :: TopLevelPragma -> Decl
 pattern PragmaDecl pragma <- Ann _ (UPragmaDecl pragma)
 
 -- | A pragma that introduces source rewrite rules (@ {-\# RULES "map/map" [2]  forall f g xs. map f (map g xs) = map (f.g) xs \#-} @)
-pattern RulePragma :: RuleList dom -> TopLevelPragma dom
+pattern RulePragma :: RuleList -> TopLevelPragma
 pattern RulePragma rules <- Ann _ (URulePragma rules)
 
 -- | A pragma that marks definitions as deprecated (@ {-\# DEPRECATED f "f will be replaced by g" \#-} @)
-pattern DeprPragma :: NameList dom -> String -> TopLevelPragma dom
+pattern DeprPragma :: NameList -> String -> TopLevelPragma
 pattern DeprPragma defs msg <- Ann _ (UDeprPragma defs (AnnList [Ann _ (UStringNode msg)]))
 
 -- | A pragma that marks definitions as deprecated (@ {-\# WARNING unsafePerformIO "you should know what you are doing" \#-} @)
-pattern WarningPragma :: NameList dom -> String -> TopLevelPragma dom
+pattern WarningPragma :: NameList -> String -> TopLevelPragma
 pattern WarningPragma defs msg <- Ann _ (UWarningPragma defs (AnnList [Ann _ (UStringNode msg)]))
 
 -- | A pragma that annotates a definition with an arbitrary value (@ {-\# ANN f 42 \#-} @)
-pattern AnnPragma :: AnnotationSubject dom -> Expr dom -> TopLevelPragma dom
+pattern AnnPragma :: AnnotationSubject -> Expr -> TopLevelPragma
 pattern AnnPragma subj ann <- Ann _ (UAnnPragma subj ann)
 
 -- | A pragma that marks a function for inlining to the compiler (@ {-\# INLINE thenUs \#-} @)
-pattern InlinePragma :: MaybeConlikeAnnot dom -> MaybePhaseControl dom -> Name dom -> TopLevelPragma dom
+pattern InlinePragma :: MaybeConlikeAnnot -> MaybePhaseControl -> Name -> TopLevelPragma
 pattern InlinePragma conlike phase name <- Ann _ (UInlinePragmaDecl (Ann _ (UInlinePragma conlike phase name)))
 
 -- | A pragma that forbids a function from being inlined by the compiler (@ {-\# NOINLINE f \#-} @)
-pattern NoInlinePragma :: Name dom -> TopLevelPragma dom
+pattern NoInlinePragma :: Name -> TopLevelPragma
 pattern NoInlinePragma name <- Ann _ (UInlinePragmaDecl (Ann _ (UNoInlinePragma name)))
 
 -- | A pragma that marks a function that it may be inlined by the compiler (@ {-\# INLINABLE thenUs \#-} @)
-pattern InlinablePragma :: MaybePhaseControl dom -> Name dom -> TopLevelPragma dom
+pattern InlinablePragma :: MaybePhaseControl -> Name -> TopLevelPragma
 pattern InlinablePragma phase name <- Ann _ (UInlinePragmaDecl (Ann _ (UInlinablePragma phase name)))
 
 -- | A pragma for maintaining line numbers in generated sources (@ {-\# LINE 123 \"somefile\" \#-} @)
-pattern LinePragma :: Int -> MaybeStringNode dom -> TopLevelPragma dom
+pattern LinePragma :: Int -> MaybeStringNode -> TopLevelPragma
 pattern LinePragma line filename <- Ann _ (ULinePragma (Ann _ (LineNumber line)) filename)
 
 -- | A pragma that tells the compiler that a polymorph function should be optimized for a given type (@ {-\# SPECIALISE f :: Int -> b -> b \#-} @)
-pattern SpecializePragma :: MaybePhaseControl dom -> Name dom -> TypeList dom -> TopLevelPragma dom
+pattern SpecializePragma :: MaybePhaseControl -> Name -> TypeList -> TopLevelPragma
 pattern SpecializePragma phase def specTypes <- Ann _ (USpecializeDecl (Ann _ (USpecializePragma phase def specTypes)))
 
 -- | Marks that the pragma should be applied from a given compile phase (@ [2] @)
-pattern PhaseControlFrom :: Integer -> PhaseControl dom
+pattern PhaseControlFrom :: Integer -> PhaseControl
 pattern PhaseControlFrom phaseNum <- Ann _ (UPhaseControl AnnNothing (AnnJust (Ann _ (PhaseNumber phaseNum))))
 
 -- | Marks that the pragma should be applied until a given compile phase (@ [~2] @)
-pattern PhaseControlUntil :: Integer -> PhaseControl dom
+pattern PhaseControlUntil :: Integer -> PhaseControl
 pattern PhaseControlUntil phaseNum <- Ann _ (UPhaseControl (AnnJust _) (AnnJust (Ann _ (PhaseNumber phaseNum))))
 
 -- | A rewrite rule (@ "map/map" forall f g xs. map f (map g xs) = map (f.g) xs @)
-pattern RewriteRule :: String -> MaybePhaseControl dom -> RuleVarList dom -> Expr dom -> Expr dom -> Rule dom
+pattern RewriteRule :: String -> MaybePhaseControl -> RuleVarList -> Expr -> Expr -> Rule
 pattern RewriteRule name phase vars lhs rhs <- Ann _ (URule (Ann _ (UStringNode name)) phase vars lhs rhs)
 
 -- | The definition with the given name is annotated
-pattern NameAnnotation :: Name dom -> AnnotationSubject dom
+pattern NameAnnotation :: Name -> AnnotationSubject
 pattern NameAnnotation name <- Ann _ (UNameAnnotation name)
 
 -- | A type with the given name is annotated
-pattern TypeAnnotation :: Name dom -> AnnotationSubject dom
+pattern TypeAnnotation :: Name -> AnnotationSubject
 pattern TypeAnnotation name <- Ann _ (UTypeAnnotation name)
 
 -- | The whole module is annotated
-pattern ModuleAnnotation :: AnnotationSubject dom
+pattern ModuleAnnotation :: AnnotationSubject
 pattern ModuleAnnotation <- Ann _ UModuleAnnotation
 
 -- | A @CONLIKE@ modifier for an @INLINE@ pragma.
-pattern ConlikeAnnotation :: ConlikeAnnot dom
+pattern ConlikeAnnotation :: ConlikeAnnot
 pattern ConlikeAnnotation <- Ann _ UConlikeAnnot
Language/Haskell/Tools/Rewrite/Match/Exprs.hs view
@@ -9,220 +9,220 @@ -- * Expressions
 
 -- | An expression for a variable or a data constructor (@ a @)
-pattern Var :: Name dom -> Expr dom
+pattern Var :: Name -> Expr
 pattern Var name <- Ann _ (UVar name)
 
 -- | A literal expression (@ 42 @)
-pattern Lit :: Literal dom -> Expr dom
+pattern Lit :: Literal -> Expr
 pattern Lit lit <- Ann _ (ULit lit)
 
 -- | An infix operator application (@ a + b @)
-pattern InfixApp :: Expr dom -> Operator dom -> Expr dom -> Expr dom
+pattern InfixApp :: Expr -> Operator -> Expr -> Expr
 pattern InfixApp lhs op rhs <- Ann _ (UInfixApp lhs op rhs)
 
 -- | Prefix operator application (@ -x @)
-pattern PrefixApp :: Operator dom -> Expr dom -> Expr dom
+pattern PrefixApp :: Operator -> Expr -> Expr
 pattern PrefixApp op rhs <- Ann _ (UPrefixApp op rhs)
 
 -- | Function application (@ f 4 @)
-pattern App :: Expr dom -> Expr dom -> Expr dom
+pattern App :: Expr -> Expr -> Expr
 pattern App f e <- Ann _ (UApp f e)
 
 -- | Lambda expression (@ \\a b -> a + b @)
-pattern Lambda :: PatternList dom -> Expr dom -> Expr dom
+pattern Lambda :: PatternList -> Expr -> Expr
 pattern Lambda pats rhs <- Ann _ (ULambda pats rhs)
 
 -- | Local binding (@ let x = 2; y = 3 in e x y @)
-pattern Let :: LocalBindList dom -> Expr dom -> Expr dom
+pattern Let :: LocalBindList -> Expr -> Expr
 pattern Let pats expr <- Ann _ (ULet pats expr)
 
 -- | If expression (@ if a then b else c @)
-pattern If :: Expr dom -> Expr dom -> Expr dom -> Expr dom
+pattern If :: Expr -> Expr -> Expr -> Expr
 pattern If cond then_ else_ <- Ann _ (UIf cond then_ else_)
 
 -- | Multi way if expressions with @MultiWayIf@ extension (@ if | guard1 -> expr1; guard2 -> expr2 @)
-pattern MultiIf :: GuardedCaseRhsList dom -> Expr dom
+pattern MultiIf :: GuardedCaseRhsList -> Expr
 pattern MultiIf cases <- Ann _ (UMultiIf cases)
 
 -- | Pattern matching expression (@ case expr of pat1 -> expr1; pat2 -> expr2 @)
-pattern Case :: Expr dom -> AltList dom -> Expr dom
+pattern Case :: Expr -> AltList -> Expr
 pattern Case expr cases <- Ann _ (UCase expr cases)
 
 -- | Do-notation expressions (@ do x <- act1; act2 @)
-pattern Do :: StmtList dom -> Expr dom
+pattern Do :: StmtList -> Expr
 pattern Do stmts <- Ann _ (UDo DoKeyword stmts)
 
-pattern ParArrayComp :: Expr dom -> ListCompBodyList dom -> Expr dom
+pattern ParArrayComp :: Expr -> ListCompBodyList -> Expr
 pattern ParArrayComp expr stmts <- Ann _ (UParArrayComp expr stmts)
 
 -- | Tuple expression (@ (e1, e2, e3) @)
-pattern Tuple :: ExprList dom -> Expr dom
+pattern Tuple :: ExprList -> Expr
 pattern Tuple exprs <- Ann _ (UTuple exprs)
 
 -- | Unboxed tuple expression (@ (\# e1, e2, e3 \#) @)
-pattern UnboxedTuple :: ExprList dom -> Expr dom
+pattern UnboxedTuple :: ExprList -> Expr
 pattern UnboxedTuple exprs <- Ann _ (UUnboxedTuple exprs)
 
 -- | Tuple section, enabled with @TupleSections@ (@ (a,,b) @). One of the elements must be missing.
-pattern TupleSection :: TupSecElemList dom -> Expr dom
+pattern TupleSection :: TupSecElemList -> Expr
 pattern TupleSection elems <- Ann _ (UTupleSection elems)
 
 -- | Unboxed tuple section enabled with @TupleSections@ (@ (# a,,b #) @). One of the elements must be missing.
-pattern UnboxedTupleSection :: TupSecElemList dom -> Expr dom
+pattern UnboxedTupleSection :: TupSecElemList -> Expr
 pattern UnboxedTupleSection elems <- Ann _ (UUnboxedTupSec elems)
 
 -- | List expression: @[1,2,3]@
-pattern List :: ExprList dom -> Expr dom
+pattern List :: ExprList -> Expr
 pattern List exprs <- Ann _ (UList exprs)
 
 -- | Parallel array expression: @[: 1,2,3 :]@
-pattern ParArray :: ExprList dom -> Expr dom
+pattern ParArray :: ExprList -> Expr
 pattern ParArray exprs <- Ann _ (UParArray exprs)
 
 -- | Parenthesized expression: @( a + b )@
-pattern Paren :: Expr dom -> Expr dom
+pattern Paren :: Expr -> Expr
 pattern Paren expr <- Ann _ (UParen expr)
 
 -- | Left operator section: @(1+)@
-pattern LeftSection :: Expr dom -> Operator dom -> Expr dom
+pattern LeftSection :: Expr -> Operator -> Expr
 pattern LeftSection lhs op <- Ann _ (ULeftSection lhs op)
 
 -- | Right operator section: @(+1)@
-pattern RightSection :: Operator dom -> Expr dom -> Expr dom
+pattern RightSection :: Operator -> Expr -> Expr
 pattern RightSection op lhs <- Ann _ (URightSection op lhs)
 
 -- | Record value construction: @Point { x = 3, y = -2 }@
-pattern RecCon :: Name dom -> FieldUpdateList dom -> Expr dom
+pattern RecCon :: Name -> FieldUpdateList -> Expr
 pattern RecCon name flds <- Ann _ (URecCon name flds)
 
 -- | Record value update: @p1 { x = 3, y = -2 }@
-pattern RecUpdate :: Expr dom -> FieldUpdateList dom -> Expr dom
+pattern RecUpdate :: Expr -> FieldUpdateList -> Expr
 pattern RecUpdate expr flds <- Ann _ (URecUpdate expr flds)
 
 -- | Enumeration expression (@ [1,3..10] @)
-pattern Enum :: Expr dom -> MaybeExpr dom -> MaybeExpr dom -> Expr dom
+pattern Enum :: Expr -> MaybeExpr -> MaybeExpr -> Expr
 pattern Enum from step to <- Ann _ (UEnum from step to)
 
 -- | Parallel array enumeration (@ [: 1,3 .. 10 :] @)
-pattern ParArrayEnum :: Expr dom -> MaybeExpr dom -> Expr dom -> Expr dom
+pattern ParArrayEnum :: Expr -> MaybeExpr -> Expr -> Expr
 pattern ParArrayEnum from step to <- Ann _ (UParArrayEnum from step to)
 
 -- | List comprehension (@ [ (x, y) | x <- xs | y <- ys ] @)
-pattern ListComp :: Expr dom -> ListCompBodyList dom -> Expr dom
+pattern ListComp :: Expr -> ListCompBodyList -> Expr
 pattern ListComp expr bodies <- Ann _ (UListComp expr bodies)
 
 -- | Parallel array comprehensions @ [: (x, y) | x <- xs , y <- ys :] @ enabled by @ParallelArrays@
-pattern ParArrayListComp :: Expr dom -> ListCompBodyList dom -> Expr dom
+pattern ParArrayListComp :: Expr -> ListCompBodyList -> Expr
 pattern ParArrayListComp expr bodies <- Ann _ (UParArrayComp expr bodies)
 
 -- | Explicit type signature (@ x :: Int @)
-pattern TypeSig :: Expr dom -> Type dom -> Expr dom
+pattern TypeSig :: Expr -> Type -> Expr
 pattern TypeSig lhs typ <- Ann _ (UTypeSig lhs typ)
 
 -- | Explicit type application (@ show \@Integer (read "5") @)
-pattern ExplicitTypeApp :: Expr dom -> Type dom -> Expr dom
+pattern ExplicitTypeApp :: Expr -> Type -> Expr
 pattern ExplicitTypeApp lhs typ <- Ann _ (UExplTypeApp lhs typ)
 
 -- | @'x@ for template haskell reifying of expressions
-pattern VarQuote :: Name dom -> Expr dom
+pattern VarQuote :: Name -> Expr
 pattern VarQuote name <- Ann _ (UVarQuote name)
 
 -- | @''T@ for template haskell reifying of types
-pattern TypeQuote :: Name dom -> Expr dom
+pattern TypeQuote :: Name -> Expr
 pattern TypeQuote name <- Ann _ (UTypeQuote name)
 
 -- | Template haskell bracket expression
-pattern BracketExpr :: Bracket dom -> Expr dom
+pattern BracketExpr :: Bracket -> Expr
 pattern BracketExpr brack <- Ann _ (UBracketExpr brack)
 
 -- | Template haskell splice expression, for example: @$(gen a)@ or @$x@
-pattern SpliceExpr :: Splice dom -> Expr dom
+pattern SpliceExpr :: Splice -> Expr
 pattern SpliceExpr splice <- Ann _ (USplice splice)
 
 -- | Template haskell quasi-quotation: @[$quoter|str]@
-pattern QuasiQuoteExpr :: QuasiQuote dom -> Expr dom
+pattern QuasiQuoteExpr :: QuasiQuote -> Expr
 pattern QuasiQuoteExpr qq <- Ann _ (UQuasiQuoteExpr qq)
 
 -- | Template haskell quasi-quotation: @[$quoter|str]@
-pattern ExprPragma :: ExprPragma dom -> Expr dom -> Expr dom
+pattern ExprPragma :: ExprPragma -> Expr -> Expr
 pattern ExprPragma pragma expr <- Ann _ (UExprPragma pragma expr)
 
 -- | Arrow definition: @proc a -> f -< a+1@
-pattern Proc :: Pattern dom -> Cmd dom -> Expr dom
+pattern Proc :: Pattern -> Cmd -> Expr
 pattern Proc pat cmd <- Ann _ (UProc pat cmd)
 
 -- | Arrow definition: @proc a -> f -< a+1@
-pattern ArrowApp :: Expr dom -> ArrowApp dom -> Expr dom -> Expr dom
+pattern ArrowApp :: Expr -> ArrowApp -> Expr -> Expr
 pattern ArrowApp lhs arrow rhs <- Ann _ (UArrowApp lhs arrow rhs)
 
 -- | Lambda case ( @\case 0 -> 1; 1 -> 2@ )
-pattern LambdaCase :: AltList dom -> Expr dom
+pattern LambdaCase :: AltList -> Expr
 pattern LambdaCase alts <- Ann _ (ULamCase alts)
 
 -- | Static pointer expression (@ static e @). The inner expression must be closed (cannot have variables bound outside)
-pattern StaticPointer :: Expr dom -> Expr dom
+pattern StaticPointer :: Expr -> Expr
 pattern StaticPointer expr <- Ann _ (UStaticPtr expr)
 
 
 -- * Field updates
 
 -- | Update of a field (@ x = 1 @)
-pattern NormalFieldUpdate :: Name dom -> Expr dom -> FieldUpdate dom
+pattern NormalFieldUpdate :: Name -> Expr -> FieldUpdate
 pattern NormalFieldUpdate n e <- Ann _ (UNormalFieldUpdate n e)
 
 -- | Update the field to the value of the same name (@ x @)
-pattern FieldPun :: Name dom -> FieldUpdate dom
+pattern FieldPun :: Name -> FieldUpdate
 pattern FieldPun n <- Ann _ (UFieldPun n)
 
 -- | Update the fields of the bounded names to their values (@ .. @). Must be the last initializer. Cannot be used in a record update expression.
-pattern FieldWildcard :: FieldWildcard dom -> FieldUpdate dom
+pattern FieldWildcard :: FieldWildcard -> FieldUpdate
 pattern FieldWildcard wc <- Ann _ (UFieldWildcard wc)
 
 -- * Tuple sections
 
 -- | An existing element in a tuple section
-pattern TupSecPresent :: Expr dom -> TupSecElem dom
+pattern TupSecPresent :: Expr -> TupSecElem
 pattern TupSecPresent expr <- Ann _ (Present expr)
 
 -- | A missing element in a tuple section
-pattern TupSecMissing :: TupSecElem dom
+pattern TupSecMissing :: TupSecElem
 pattern TupSecMissing <- Ann _ Missing
 
 -- * Pattern matching and guards
 
 -- | Clause of case expression (@ Just x -> x + 1 @)
-pattern Alt :: Pattern dom -> CaseRhs dom -> MaybeLocalBinds dom -> Alt dom
+pattern Alt :: Pattern -> CaseRhs -> MaybeLocalBinds -> Alt
 pattern Alt pat rhs locals <- Ann _ (UAlt pat rhs locals) 
 
 -- | Unguarded right-hand side a pattern match (@ -> 3 @)
-pattern CaseRhs :: Expr dom -> CaseRhs dom
+pattern CaseRhs :: Expr -> CaseRhs
 pattern CaseRhs e <- Ann _ (UUnguardedCaseRhs e)
 
 -- | Guarded right-hand sides of a pattern match (@ | x == 1 -> 3; | otherwise -> 4 @)
-pattern GuardedCaseRhss :: GuardedCaseRhsList dom -> CaseRhs dom
+pattern GuardedCaseRhss :: GuardedCaseRhsList -> CaseRhs
 pattern GuardedCaseRhss cases <- Ann _ (UGuardedCaseRhss cases)
 
 -- | A guarded right-hand side of pattern matches binding (@ | x > 3 -> 2 @)      
-pattern GuardedCaseRhs :: RhsGuardList dom -> Expr dom -> GuardedCaseRhs dom
+pattern GuardedCaseRhs :: RhsGuardList -> Expr -> GuardedCaseRhs
 pattern GuardedCaseRhs guards expr <- Ann _ (UGuardedCaseRhs guards expr)
 
 -- * Pragmas that can be applied to expressions
 
 -- | A @CORE@ pragma for adding notes to expressions.
-pattern CorePragma :: String -> ExprPragma dom
+pattern CorePragma :: String -> ExprPragma
 pattern CorePragma str <- Ann _ (UCorePragma (Ann _ (UStringNode str)))
 
 -- | An @SCC@ pragma for defining cost centers for profiling
-pattern SccPragma :: String -> ExprPragma dom
+pattern SccPragma :: String -> ExprPragma
 pattern SccPragma str <- Ann _ (USccPragma (Ann _ (UStringNode str)))
 
 -- | A pragma that describes if an expression was generated from a code fragment by an external tool (@ {-# GENERATED "Happy.y" 1:15-1:25 #-} @)
-pattern GeneratedPragma :: SourceRange dom -> ExprPragma dom
+pattern GeneratedPragma :: SourceRange -> ExprPragma
 pattern GeneratedPragma rng <- Ann _ (UGeneratedPragma rng)
 
 
 -- | In-AST source ranges (for generated pragmas)
-pattern SourceRange :: String -> Integer -> Integer -> Integer -> Integer -> SourceRange dom
+pattern SourceRange :: String -> Integer -> Integer -> Integer -> Integer -> SourceRange
 pattern SourceRange file fromLine fromCol toLine toCol 
           <- Ann _ (USourceRange 
                      (Ann _ (UStringNode file))
@@ -233,63 +233,65 @@ -- * Commands
 
 -- | An arrow application command (@ f -< x + 1 @)
-pattern ArrowAppCmd :: Expr dom -> ArrowApp dom -> Expr dom -> Cmd dom
+pattern ArrowAppCmd :: Expr -> ArrowApp -> Expr -> Cmd
 pattern ArrowAppCmd lhs arrow rhs <- Ann _ (UArrowAppCmd lhs arrow rhs)
 
 -- | A form command (@ (|untilA (increment -< x+y) (within 0.5 -< x)|) @)
-pattern ArrowFormCmd :: Expr dom -> CmdList dom -> Cmd dom
+pattern ArrowFormCmd :: Expr -> CmdList -> Cmd
 pattern ArrowFormCmd expr cmds <- Ann _ (UArrowFormCmd expr cmds)
 
 -- | A function application command
-pattern AppCmd :: Cmd dom -> Expr dom -> Cmd dom
+pattern AppCmd :: Cmd -> Expr -> Cmd
 pattern AppCmd cmd expr <- Ann _ (UAppCmd cmd expr)
 
 -- | An infix command application
-pattern InfixCmd :: Cmd dom -> Name dom -> Cmd dom -> Cmd dom
+pattern InfixCmd :: Cmd -> Name -> Cmd -> Cmd
 pattern InfixCmd lhs op rhs <- Ann _ (UInfixCmd lhs op rhs)
 
 -- | An infix command application
-pattern LambdaCmd :: PatternList dom -> Cmd dom -> Cmd dom
+pattern LambdaCmd :: PatternList -> Cmd -> Cmd
 pattern LambdaCmd pats cmd <- Ann _ (ULambdaCmd pats cmd)
 
 -- | A parenthesized command
-pattern ParenCmd :: Cmd dom -> Cmd dom
+pattern ParenCmd :: Cmd -> Cmd
 pattern ParenCmd cmd <- Ann _ (UParenCmd cmd)
 
 -- | A pattern match command
-pattern CaseCmd :: Expr dom -> CmdAltList dom -> Cmd dom
+pattern CaseCmd :: Expr -> CmdAltList -> Cmd
 pattern CaseCmd expr alts <- Ann _ (UCaseCmd expr alts)
 
 -- | An if command (@ if f x y then g -< x+1 else h -< y+2 @)
-pattern IfCmd :: Expr dom -> Cmd dom -> Cmd dom -> Cmd dom
+pattern IfCmd :: Expr -> Cmd -> Cmd -> Cmd
 pattern IfCmd pred then_ else_ <- Ann _ (UIfCmd pred then_ else_)
 
 -- | A local binding command (@ let z = x+y @)
-pattern LetCmd :: LocalBindList dom -> Cmd dom -> Cmd dom
+pattern LetCmd :: LocalBindList -> Cmd -> Cmd
 pattern LetCmd locals cmd <- Ann _ (ULetCmd locals cmd)
 
 -- | A local binding command (@ let z = x+y @)
-pattern DoCmd :: CmdStmtList dom -> Cmd dom
+pattern DoCmd :: CmdStmtList -> Cmd
 pattern DoCmd stmts <- Ann _ (UDoCmd stmts)
 
 
 -- | Left arrow application: @-<@
-pattern LeftAppl :: ArrowApp dom
+pattern LeftAppl :: ArrowApp
 pattern LeftAppl <- Ann _ ULeftAppl 
 
 -- | Right arrow application: @>-@
-pattern RightAppl :: ArrowApp dom
+pattern RightAppl :: ArrowApp
 pattern RightAppl <- Ann _ URightAppl 
 
 -- | Left arrow high application: @-<<@
-pattern LeftHighApp :: ArrowApp dom
+pattern LeftHighApp :: ArrowApp
 pattern LeftHighApp <- Ann _ ULeftHighApp 
 
 -- | Right arrow high application: @>>-@
-pattern RightHighApp :: ArrowApp dom
+pattern RightHighApp :: ArrowApp
 pattern RightHighApp <- Ann _ URightHighApp 
 
-
+-- | A hole expression @_@
+pattern Hole :: Expr
+pattern Hole <- Ann _ UHole
Language/Haskell/Tools/Rewrite/Match/Kinds.hs view
@@ -6,57 +6,57 @@ import Language.Haskell.Tools.Rewrite.ElementTypes
 
 -- | Kind constraint (@ :: * -> * @)
-pattern KindConstraint :: Kind dom -> KindConstraint dom
+pattern KindConstraint :: Kind -> KindConstraint
 pattern KindConstraint k <- Ann _ (UKindConstraint k)
 
 -- | @*@, the kind of types
-pattern StarKind :: Kind dom
+pattern StarKind :: Kind
 pattern StarKind <- Ann _ UStarKind
 
 -- | @#@, the kind of unboxed types
-pattern UnboxKind :: Kind dom
+pattern UnboxKind :: Kind
 pattern UnboxKind <- Ann _ UUnboxKind
 
 -- | @->@, the kind of type constructor
-pattern FunKind :: Kind dom -> Kind dom -> Kind dom
+pattern FunKind :: Kind -> Kind -> Kind
 pattern FunKind a r <- Ann _ (UFunKind a r)
 
 -- | A parenthesised kind
-pattern ParenKind :: Kind dom -> Kind dom
+pattern ParenKind :: Kind -> Kind
 pattern ParenKind k <- Ann _ (UParenKind k)
 
 -- | Kind variable (using @PolyKinds@ extension)
-pattern VarKind :: Name dom -> Kind dom
+pattern VarKind :: Name -> Kind
 pattern VarKind v <- Ann _ (UVarKind v)
 
 -- | Kind application (@ k1 k2 @)
-pattern AppKind :: Kind dom -> Kind dom -> Kind dom
+pattern AppKind :: Kind -> Kind -> Kind
 pattern AppKind f a <- Ann _ (UAppKind f a)
 
 -- | A list kind (@ [k] @)
-pattern ListKind :: Kind dom -> Kind dom
+pattern ListKind :: Kind -> Kind
 pattern ListKind k <- Ann _ (UListKind k)
 
 -- | Numeric value promoted to the kind level.
-pattern IntKind :: Integer -> Kind dom
+pattern IntKind :: Integer -> Kind
 pattern IntKind i <- Ann _ (UPromotedKind (Ann _ (UPromotedInt i)))
 
 -- | String value promoted to the kind level.
-pattern StringKind :: String -> Kind dom
+pattern StringKind :: String -> Kind
 pattern StringKind s <- Ann _ (UPromotedKind (Ann _ (UPromotedString s)))
 
 -- | A data constructor value promoted to the kind level.
-pattern ConKind :: Name dom -> Kind dom
+pattern ConKind :: Name -> Kind
 pattern ConKind s <- Ann _ (UPromotedKind (Ann _ (UPromotedCon s)))
 
 -- | A list of elements as a kind.
-pattern ListKindPromoted :: KindList dom -> Kind dom
+pattern ListKindPromoted :: KindList -> Kind
 pattern ListKindPromoted elems <- Ann _ (UPromotedKind (Ann _ (UPromotedList elems)))
 
 -- | A tuple of elements as a kind.
-pattern TupleKind :: KindList dom -> Kind dom
+pattern TupleKind :: KindList -> Kind
 pattern TupleKind elems <- Ann _ (UPromotedKind (Ann _ (UPromotedTuple elems)))
 
 -- | Kind of the unit value @()@. 
-pattern UnitKind :: Kind dom
+pattern UnitKind :: Kind
 pattern UnitKind <- Ann _ (UPromotedKind (Ann _ UPromotedUnit))
Language/Haskell/Tools/Rewrite/Match/Literals.hs view
@@ -6,41 +6,41 @@ import Language.Haskell.Tools.Rewrite.ElementTypes (Literal)
 
 -- | Character literal: @'c'@
-pattern CharLit :: Char -> Literal dom
+pattern CharLit :: Char -> Literal
 pattern CharLit c <- Ann _ (UCharLit c)
 
 -- | String literal: @"abc"@
-pattern StringLit :: String -> Literal dom
+pattern StringLit :: String -> Literal
 pattern StringLit s <- Ann _ (UStringLit s)
 
 -- | Integer literal: @12@
-pattern IntLit :: Integer -> Literal dom
+pattern IntLit :: Integer -> Literal
 pattern IntLit i <- Ann _ (UIntLit i)
 
 -- | Fractional literal: @3.14@
-pattern FracLit :: Rational -> Literal dom
+pattern FracLit :: Rational -> Literal
 pattern FracLit f <- Ann _ (UFracLit f)
 
 -- | Primitive integer literal (of type @Int#@): @32#@
-pattern PrimIntLit :: Integer -> Literal dom
+pattern PrimIntLit :: Integer -> Literal
 pattern PrimIntLit i <- Ann _ (UPrimIntLit i)
 
 -- | Primitive word literal (of type @Word#@): @32##@
-pattern PrimWordLit :: Integer -> Literal dom
+pattern PrimWordLit :: Integer -> Literal
 pattern PrimWordLit i <- Ann _ (UPrimWordLit i)
 
 -- | Primitive float literal (of type @Float#@): @3.14#@
-pattern PrimFloatLit :: Rational -> Literal dom
+pattern PrimFloatLit :: Rational -> Literal
 pattern PrimFloatLit i <- Ann _ (UPrimFloatLit i)
 
 -- | Primitive double literal (of type @Double#@): @3.14##@
-pattern PrimDoubleLit :: Rational -> Literal dom
+pattern PrimDoubleLit :: Rational -> Literal
 pattern PrimDoubleLit i <- Ann _ (UPrimDoubleLit i)
 
 -- | Primitive character literal (of type @Char#@): @'c'#@
-pattern PrimCharLit :: Char -> Literal dom
+pattern PrimCharLit :: Char -> Literal
 pattern PrimCharLit i <- Ann _ (UPrimCharLit i)
 
 -- | Primitive string literal (of type @Addr#@): @"xxx"#@
-pattern PrimStringLit :: String -> Literal dom
+pattern PrimStringLit :: String -> Literal
 pattern PrimStringLit s <- Ann _ (UPrimStringLit s)
Language/Haskell/Tools/Rewrite/Match/Modules.hs view
@@ -7,75 +7,75 @@ 
 -- | The representation of a haskell module, that is a separate compilation unit.
 -- It may or may not have a header.
-pattern Module :: FilePragmaList dom -> MaybeModuleHead dom
-              -> ImportDeclList dom -> DeclList dom -> Module dom
+pattern Module :: FilePragmaList -> MaybeModuleHead
+              -> ImportDeclList -> DeclList -> Module
 pattern Module filePrags head imps decls  <- Ann _ (UModule filePrags head imps decls )
 
 -- | Module declaration with name and (optional) exports
-pattern ModuleHead :: ModuleName dom -> MaybeModulePragma dom -> MaybeExportSpecs dom -> ModuleHead dom
+pattern ModuleHead :: ModuleName -> MaybeModulePragma -> MaybeExportSpecs -> ModuleHead
 pattern ModuleHead n pr es <- Ann _ (UModuleHead n pr es)
 
 -- | A list of export specifications surrounded by parentheses
-pattern ExportSpecs :: ExportSpecList dom -> ExportSpecs dom
+pattern ExportSpecs :: ExportSpecList -> ExportSpecs
 pattern ExportSpecs specs <- Ann _ (UExportSpecs specs)
 
 -- | Export a name and related names
-pattern ExportSpec :: IESpec dom -> ExportSpec dom
+pattern ExportSpec :: IESpec -> ExportSpec
 pattern ExportSpec ieSpec <- Ann _ (UDeclExport ieSpec)
 
 -- | The export of an imported module (@ module A @)
-pattern ModuleExport :: ModuleName dom -> ExportSpec dom
+pattern ModuleExport :: ModuleName -> ExportSpec
 pattern ModuleExport name <- Ann _ (UModuleExport name)
 
 -- | Marks a name to be imported or exported with related names (subspecifier)
-pattern IESpec :: Name dom -> MaybeSubSpec dom -> IESpec dom
+pattern IESpec :: Name -> MaybeSubSpec -> IESpec
 pattern IESpec name ss <- Ann _ (UIESpec _ name ss)
 
 -- | @(..)@: a class exported with all of its methods, or a datatype exported with all of its constructors.
-pattern SubAll :: SubSpec dom
+pattern SubAll :: SubSpec
 pattern SubAll <- Ann _ USubSpecAll
 
 -- | @(a,b,c)@: a class exported with some of its methods, or a datatype exported with some of its constructors.
-pattern SubList :: NameList dom -> SubSpec dom
+pattern SubList :: NameList -> SubSpec
 pattern SubList names <- Ann _ (USubSpecList names)
 
 
-pattern ImportDecl :: MaybeImportSource dom -> MaybeImportQualified dom 
-                        -> MaybeImportSafe dom -> MaybeStringNode dom
-                        -> ModuleName dom -> MaybeImportRenaming dom
-                        -> MaybeImportSpec dom -> ImportDecl dom       
+pattern ImportDecl :: MaybeImportSource -> MaybeImportQualified 
+                        -> MaybeImportSafe -> MaybeStringNode
+                        -> ModuleName -> MaybeImportRenaming
+                        -> MaybeImportSpec -> ImportDecl       
 pattern ImportDecl source qualified safe pkg name rename spec <- Ann _ (UImportDecl source qualified safe pkg name rename spec)
 
-pattern ImportRenaming :: ModuleName dom -> ImportRenaming dom
+pattern ImportRenaming :: ModuleName -> ImportRenaming
 pattern ImportRenaming name <- Ann _ (UImportRenaming name)
 
-pattern ImportSpecList :: IESpecList dom -> ImportSpec dom
+pattern ImportSpecList :: IESpecList -> ImportSpec
 pattern ImportSpecList ieSpecs <- Ann _ (UImportSpecList ieSpecs)
 
-pattern ImportHidingList :: IESpecList dom -> ImportSpec dom
+pattern ImportHidingList :: IESpecList -> ImportSpec
 pattern ImportHidingList hidings <- Ann _ (UImportSpecHiding hidings)
 
-pattern ModuleName :: String -> ModuleName dom
+pattern ModuleName :: String -> ModuleName
 pattern ModuleName s <- Ann _ (UModuleName s)
 
 -- * Pragmas
 
 -- | @LANGUAGE@ pragma, listing the enabled language extensions in that file
-pattern LanguagePragma :: LanguageExtensionList dom -> FilePragma dom
+pattern LanguagePragma :: LanguageExtensionList -> FilePragma
 pattern LanguagePragma exts <- Ann _ (ULanguagePragma exts)
 
 -- | @OPTIONS@ pragma, possibly qualified with a tool, e.g. OPTIONS_GHC
-pattern OptionsPragma :: String -> FilePragma dom
+pattern OptionsPragma :: String -> FilePragma
 pattern OptionsPragma opt <- Ann _ (UOptionsPragma (Ann _ (UStringNode opt)))
 
 -- | The name of the enabled language extension, for example (@ LambdaCase @)
-pattern LanguageExtension :: String -> LanguageExtension dom
+pattern LanguageExtension :: String -> LanguageExtension
 pattern LanguageExtension ext <- Ann _ (ULanguageExtension ext)
 
 -- | A warning pragma attached to the module
-pattern ModuleWarningPragma :: StringNodeList dom -> ModulePragma dom
+pattern ModuleWarningPragma :: StringNodeList -> ModulePragma
 pattern ModuleWarningPragma msgs <- Ann _ (UModuleWarningPragma msgs)
 
 -- | A deprecated pragma attached to the module
-pattern ModuleDeprecatedPragma :: StringNodeList dom -> ModulePragma dom
+pattern ModuleDeprecatedPragma :: StringNodeList -> ModulePragma
 pattern ModuleDeprecatedPragma msgs <- Ann _ (UModuleDeprecatedPragma msgs)
Language/Haskell/Tools/Rewrite/Match/Names.hs view
@@ -6,33 +6,33 @@ import Language.Haskell.Tools.Rewrite.ElementTypes
 
 -- | A normal operator used as an operator.
-pattern NormalOp :: QualifiedName dom -> Operator dom
+pattern NormalOp :: QualifiedName -> Operator
 pattern NormalOp n <- Ann _ (UNormalOp n)
 
 -- | A normal name used as an operator with backticks: @ a \`mod\` b @
-pattern BacktickOp :: QualifiedName dom -> Operator dom
+pattern BacktickOp :: QualifiedName -> Operator
 pattern BacktickOp n <- Ann _ (UBacktickOp n)
 
 -- | A normal, non-operator name.
-pattern NormalName :: QualifiedName dom -> Name dom
+pattern NormalName :: QualifiedName -> Name
 pattern NormalName n <- Ann _ (UNormalName n)
 
 -- | Parenthesized name: @ foldl (+) 0 @
-pattern ParenName :: QualifiedName dom -> Name dom
+pattern ParenName :: QualifiedName -> Name
 pattern ParenName n <- Ann _ (UParenName n)
 
 -- | Creates an implicit name: @ ?var @
-pattern ImplicitName :: QualifiedName dom -> Name dom
+pattern ImplicitName :: QualifiedName -> Name
 pattern ImplicitName n <- Ann _ (UImplicitName n)
 
 -- | Program elements formatted as string literals (import packages, pragma texts)
-pattern StringNode :: String -> StringNode dom
+pattern StringNode :: String -> StringNode
 pattern StringNode s <- Ann _ (UStringNode s )
 
 -- | Possibly qualified name.
-pattern QualifiedName :: NamePartList dom -> NamePart dom -> QualifiedName dom
+pattern QualifiedName :: NamePartList -> NamePart -> QualifiedName
 pattern QualifiedName quals unqual <- Ann _ (UQualifiedName quals unqual)
 
 -- | Parts of a qualified name.
-pattern NamePart :: String -> NamePart dom
+pattern NamePart :: String -> NamePart
 pattern NamePart str <- Ann _ (UNamePart str)
Language/Haskell/Tools/Rewrite/Match/Patterns.hs view
@@ -6,88 +6,88 @@ import Language.Haskell.Tools.Rewrite.ElementTypes
 
 -- | Pattern name binding
-pattern VarPat :: Name dom -> Pattern dom
+pattern VarPat :: Name -> Pattern
 pattern VarPat var <- Ann _ (UVarPat var)
 
 -- | Literal pattern
-pattern LitPat :: Literal dom -> Pattern dom
+pattern LitPat :: Literal -> Pattern
 pattern LitPat lit <- Ann _ (ULitPat lit)
 
 -- | Infix constructor application pattern (@ a :+: b @)
-pattern InfixAppPat :: Pattern dom -> Operator dom -> Pattern dom -> Pattern dom
+pattern InfixAppPat :: Pattern -> Operator -> Pattern -> Pattern
 pattern InfixAppPat lhs op rhs <- Ann _ (UInfixAppPat lhs op rhs)
 
 -- | Constructor application pattern (@ Point x y @)
-pattern AppPat :: Name dom -> PatternList dom -> Pattern dom
+pattern AppPat :: Name -> PatternList -> Pattern
 pattern AppPat n pat <- Ann _ (UAppPat n pat)
 
 -- | Tuple pattern (@ (x,y) @)
-pattern TuplePat :: PatternList dom -> Pattern dom
+pattern TuplePat :: PatternList -> Pattern
 pattern TuplePat pats <- Ann _ (UTuplePat pats)
 
 -- | Unboxed tuple pattern (@ (\# x, y \#) @)
-pattern UnboxTuplePat :: PatternList dom -> Pattern dom
+pattern UnboxTuplePat :: PatternList -> Pattern
 pattern UnboxTuplePat pats <- Ann _ (UUnboxTuplePat pats)
 
 -- | List pattern (@ [1,2,a,x] @)
-pattern ListPat :: PatternList dom -> Pattern dom
+pattern ListPat :: PatternList -> Pattern
 pattern ListPat pats <- Ann _ (UListPat pats)
 
 -- | Parallel array pattern (@ [:1,2,a,x:] @)
-pattern ParArrayPat :: PatternList dom -> Pattern dom
+pattern ParArrayPat :: PatternList -> Pattern
 pattern ParArrayPat pats <- Ann _ (UParArrPat pats)
 
 -- | Parenthesised patterns
-pattern ParenPat :: Pattern dom -> Pattern dom
+pattern ParenPat :: Pattern -> Pattern
 pattern ParenPat pat <- Ann _ (UParenPat pat)
 
 -- | Record pattern (@ Point { x = 3, y } @)
-pattern RecPat :: Name dom -> PatternFieldList dom -> Pattern dom
+pattern RecPat :: Name -> PatternFieldList -> Pattern
 pattern RecPat name flds <- Ann _ (URecPat name flds)
 
 -- | As-pattern (explicit name binding) (@ ls\@(hd:_) @)
-pattern AsPat :: Name dom -> Pattern dom -> Pattern dom
+pattern AsPat :: Name -> Pattern -> Pattern
 pattern AsPat name pat <- Ann _ (UAsPat name pat)
 
 -- | Wildcard pattern: (@ _ @)
-pattern WildPat :: Pattern dom
+pattern WildPat :: Pattern
 pattern WildPat <- Ann _ UWildPat
 
 -- | Irrefutable pattern (@ ~(x:_) @)
-pattern IrrefutablePat :: Pattern dom -> Pattern dom
+pattern IrrefutablePat :: Pattern -> Pattern
 pattern IrrefutablePat pat <- Ann _ (UIrrefutablePat pat)
 
 -- | Bang pattern (@ !x @)
-pattern BangPat :: Pattern dom -> Pattern dom
+pattern BangPat :: Pattern -> Pattern
 pattern BangPat pat <- Ann _ (UBangPat pat)
 
 -- | Pattern with explicit type signature (@ x :: Int @)
-pattern TypeSigPat :: Pattern dom -> Type dom -> Pattern dom
+pattern TypeSigPat :: Pattern -> Type -> Pattern
 pattern TypeSigPat pat typ <- Ann _ (UTypeSigPat pat typ)
 
 -- | View pattern (@ f -> Just 1 @)
-pattern ViewPat :: Expr dom -> Pattern dom -> Pattern dom
+pattern ViewPat :: Expr -> Pattern -> Pattern
 pattern ViewPat name pat <- Ann _ (UViewPat name pat)
 
 -- | Splice patterns: @$(generateX inp)@
-pattern SplicePat :: Splice dom -> Pattern dom
+pattern SplicePat :: Splice -> Pattern
 pattern SplicePat splice <- Ann _ (USplicePat splice)
 
 -- | Quasi-quoted patterns: @[| 1 + 2 |]@
-pattern QuasiQuotePat :: QuasiQuote dom -> Pattern dom
+pattern QuasiQuotePat :: QuasiQuote -> Pattern
 pattern QuasiQuotePat qq <- Ann _ (UQuasiQuotePat qq)
 
-pattern NPlusKPat :: Name dom -> Literal dom -> Pattern dom
+pattern NPlusKPat :: Name -> Literal -> Pattern
 pattern NPlusKPat name lit <- Ann _ (UNPlusKPat name lit)
 
 -- | Named field pattern (@ p = Point 3 2 @)
-pattern FieldPattern :: Name dom -> Pattern dom -> PatternField dom
+pattern FieldPattern :: Name -> Pattern -> PatternField
 pattern FieldPattern name pat <- Ann _ (UNormalFieldPattern name pat)
 
 -- | Named field pun (@ p @)
-pattern FieldPunPattern :: Name dom -> PatternField dom
+pattern FieldPunPattern :: Name -> PatternField
 pattern FieldPunPattern name <- Ann _ (UFieldPunPattern name)
 
 -- | Wildcard field pattern (@ .. @)
-pattern FieldWildcardPattern :: FieldWildcard dom -> PatternField dom
+pattern FieldWildcardPattern :: FieldWildcard -> PatternField
 pattern FieldWildcardPattern wildc <- Ann _ (UFieldWildcardPattern wildc)
Language/Haskell/Tools/Rewrite/Match/Stmts.hs view
@@ -8,59 +8,59 @@ -- * Do-notation
 
 -- | Binding statement (@ x <- action @)
-pattern BindStmt :: Pattern dom -> Expr dom -> Stmt dom
+pattern BindStmt :: Pattern -> Expr -> Stmt
 pattern BindStmt bound expr <- Ann _ (UBindStmt bound expr)
 
 -- | Non-binding statement (@ action @)
-pattern ExprStmt :: Expr dom -> Stmt dom
+pattern ExprStmt :: Expr -> Stmt
 pattern ExprStmt expr <- Ann _ (UExprStmt expr)
 
 -- | Let statement (@ let x = 3; y = 4 @)
-pattern LetStmt :: LocalBindList dom -> Stmt dom
+pattern LetStmt :: LocalBindList -> Stmt
 pattern LetStmt binds <- Ann _ (ULetStmt binds)
 
 -- | A recursive binding statement with (@ rec b <- f a c; c <- f b a @)
-pattern RecStmt :: StmtList dom -> Stmt dom
+pattern RecStmt :: StmtList -> Stmt
 pattern RecStmt stmts <- Ann _ (URecStmt stmts)
 
-pattern DoKeyword :: DoKind dom
+pattern DoKeyword :: DoKind
 pattern DoKeyword <- Ann _ UDoKeyword
 
-pattern MDoKeyword :: DoKind dom
+pattern MDoKeyword :: DoKind
 pattern MDoKeyword <- Ann _ UMDoKeyword
 
 -- * List comprehensions
 
 -- | Body of a list comprehension: (@ | x <- [1..10] @)
-pattern ListCompBody :: CompStmtList dom -> ListCompBody dom
+pattern ListCompBody :: CompStmtList -> ListCompBody
 pattern ListCompBody stmts <- Ann _ (UListCompBody stmts)
 
 -- | Normal monadic statement of a list comprehension
-pattern CompStmt :: Stmt dom -> CompStmt dom
+pattern CompStmt :: Stmt -> CompStmt
 pattern CompStmt stmt <- Ann _ (UCompStmt stmt)
 
 -- | Then statements by @TransformListComp@ (@ then sortWith by (x + y) @)
-pattern ThenStmt :: Expr dom -> MaybeExpr dom -> CompStmt dom
+pattern ThenStmt :: Expr -> MaybeExpr -> CompStmt
 pattern ThenStmt then_ by <- Ann _ (UThenStmt then_ by)
 
 -- | Grouping statements by @TransformListComp@ (@ then group by (x + y) using groupWith @) 
-pattern GroupStmt :: MaybeExpr dom -> MaybeExpr dom -> CompStmt dom
+pattern GroupStmt :: MaybeExpr -> MaybeExpr -> CompStmt
 pattern GroupStmt by using <- Ann _ (UGroupStmt by using)
 
 -- * Commands
 
 -- | Binding statement command (@ x <- action @)
-pattern BindStmtCmd :: Pattern dom -> Cmd dom -> CmdStmt dom
+pattern BindStmtCmd :: Pattern -> Cmd -> CmdStmt
 pattern BindStmtCmd bound expr <- Ann _ (UBindStmt bound expr)
 
 -- | Non-binding statement command (@ action @)
-pattern ExprStmtCmd :: Cmd dom -> CmdStmt dom
+pattern ExprStmtCmd :: Cmd -> CmdStmt
 pattern ExprStmtCmd expr <- Ann _ (UExprStmt expr)
 
 -- | Let statement command (@ let x = 3; y = 4 @)
-pattern LetStmtCmd :: LocalBindList dom -> CmdStmt dom
+pattern LetStmtCmd :: LocalBindList -> CmdStmt
 pattern LetStmtCmd binds <- Ann _ (ULetStmt binds)
 
 -- | A recursive binding statement command with (@ rec b <- f a c; c <- f b a @)
-pattern RecStmtCmd :: CmdStmtList dom -> CmdStmt dom
+pattern RecStmtCmd :: CmdStmtList -> CmdStmt
 pattern RecStmtCmd stmts <- Ann _ (URecStmt stmts)
Language/Haskell/Tools/Rewrite/Match/TH.hs view
@@ -6,31 +6,31 @@ import Language.Haskell.Tools.Rewrite.ElementTypes
 
 -- | A simple name splice: @$generateX@
-pattern IdSplice :: Name dom -> Splice dom
+pattern IdSplice :: Name -> Splice
 pattern IdSplice n <- Ann _ (UIdSplice n)
 
 -- | A splice with parentheses: @$(generate input)@
-pattern ParenSplice :: Expr dom -> Splice dom
+pattern ParenSplice :: Expr -> Splice
 pattern ParenSplice e <- Ann _ (UParenSplice e)
 
 -- | Template haskell quasi-quotation: @[quoter|str]@  
-pattern QuasiQuote :: Name dom -> String -> QuasiQuote dom
+pattern QuasiQuote :: Name -> String -> QuasiQuote
 pattern QuasiQuote n qqStr <- Ann _ (UQuasiQuote n (Ann _ (QQString qqStr)))
 
 -- | Expression bracket (@ [| x + y |] @)
-pattern ExprBracket :: Expr dom -> Bracket dom
+pattern ExprBracket :: Expr -> Bracket
 pattern ExprBracket e <- Ann _ (UExprBracket e)
 
 -- | Pattern bracket (@ [p| Point x y |] @)
-pattern PatternBracket :: Pattern dom -> Bracket dom
+pattern PatternBracket :: Pattern -> Bracket
 pattern PatternBracket p <- Ann _ (UPatternBracket p)
 
 -- | Type bracket (@ [t| (Int,Int) |] @)
-pattern TypeBracket :: Type dom -> Bracket dom
+pattern TypeBracket :: Type -> Bracket
 pattern TypeBracket t <- Ann _ (UTypeBracket t)
 
 -- | Declaration bracket (@ [d| f :: Int -> Int; f x = x*x |] @)
-pattern DeclsBracket :: DeclList dom -> Bracket dom
+pattern DeclsBracket :: DeclList -> Bracket
 pattern DeclsBracket d <- Ann _ (UDeclsBracket d)
Language/Haskell/Tools/Rewrite/Match/Types.hs view
@@ -8,139 +8,139 @@ -- * Types
 
 -- | Forall types (@ forall x y . type @)
-pattern ForallType :: TyVarList dom -> Type dom -> Type dom
+pattern ForallType :: TyVarList -> Type -> Type
 pattern ForallType vars t <- Ann _ (UTyForall vars t)
 
 -- | Type with a context (@ forall x y . type @)
-pattern CtxType :: Context dom -> Type dom -> Type dom
+pattern CtxType :: Context -> Type -> Type
 pattern CtxType ctx t <- Ann _ (UTyCtx ctx t)
 
 -- | Function types (@ a -> b @)
-pattern FunctionType :: Type dom -> Type dom -> Type dom
+pattern FunctionType :: Type -> Type -> Type
 pattern FunctionType at rt <- Ann _ (UTyFun at rt)
 
 -- | Tuple types (@ (a,b) @)
-pattern TupleType :: TypeList dom -> Type dom
+pattern TupleType :: TypeList -> Type
 pattern TupleType args <- Ann _ (UTyTuple args)
 
 -- | Unboxed tuple types (@ (\#a,b\#) @)
-pattern UnboxedTupleType :: TypeList dom -> Type dom
+pattern UnboxedTupleType :: TypeList -> Type
 pattern UnboxedTupleType args <- Ann _ (UTyUnbTuple args)
 
 -- | List type with special syntax (@ [a] @)
-pattern ListType :: Type dom -> Type dom
+pattern ListType :: Type -> Type
 pattern ListType t <- Ann _ (UTyList t)
 
 -- | Parallel array type (@ [:a:] @)
-pattern ParArrayType :: Type dom -> Type dom
+pattern ParArrayType :: Type -> Type
 pattern ParArrayType t <- Ann _ (UTyParArray t)
 
 -- | Type application (@ F a @)
-pattern TypeApp :: Type dom -> Type dom -> Type dom
+pattern TypeApp :: Type -> Type -> Type
 pattern TypeApp ft at <- Ann _ (UTyApp ft at)
 
 -- | Infix type constructor (@ (a <: b) @)
-pattern InfixTypeApp :: Type dom -> Operator dom -> Type dom -> Type dom
+pattern InfixTypeApp :: Type -> Operator -> Type -> Type
 pattern InfixTypeApp left op right <- Ann _ (UTyInfix left op right)
 
 -- | Type surrounded by parentheses (@ (T a) @)
-pattern ParenType :: Type dom -> Type dom
+pattern ParenType :: Type -> Type
 pattern ParenType t <- Ann _ (UTyParen t)
 
 -- | Type variable or constructor (@ a @)
-pattern VarType :: Name dom -> Type dom
+pattern VarType :: Name -> Type
 pattern VarType n <- Ann _ (UTyVar n)
 
 -- | Type with explicit kind signature (@ a :: * @)
-pattern KindedType :: Type dom -> Kind dom -> Type dom
+pattern KindedType :: Type -> Kind -> Type
 pattern KindedType t k <- Ann _ (UTyKinded t k)
 
 -- | Strict type marked with @!@.
-pattern BangType :: Type dom -> Type dom
+pattern BangType :: Type -> Type
 pattern BangType n <- Ann _ (UTyBang n)
 
 -- | Lazy type marked with @~@. (Should only be used if @Strict@ or @StrictData@ language extension is used)
-pattern LazyType :: Type dom -> Type dom
+pattern LazyType :: Type -> Type
 pattern LazyType n <- Ann _ (UTyLazy n)
 
 -- | Strict type marked with UNPACK pragma. (Usually contains the bang mark.)
-pattern UnpackType :: Type dom -> Type dom
+pattern UnpackType :: Type -> Type
 pattern UnpackType n <- Ann _ (UTyUnpack n)
 
 -- | Strict type marked with NOUNPACK pragma. (Usually contains the bang mark.)
-pattern NoUnpackType :: Type dom -> Type dom
+pattern NoUnpackType :: Type -> Type
 pattern NoUnpackType t <- Ann _ (UTyNoUnpack t)
 
 -- | A wildcard type (@ _ @) with @-XPartialTypeSignatures@
-pattern WildcardType :: Type dom
+pattern WildcardType :: Type
 pattern WildcardType <- Ann _ UTyWildcard
 
 -- | A named wildcard type (@ _t @) with @-XPartialTypeSignatures@
-pattern NamedWildcardType :: Name dom -> Type dom
+pattern NamedWildcardType :: Name -> Type
 pattern NamedWildcardType n <- Ann _ (UTyNamedWildc n)
 
 -- | A Template Haskell splice type (@ $(genType) @).
-pattern SpliceType :: Splice dom -> Type dom
+pattern SpliceType :: Splice -> Type
 pattern SpliceType spl <- Ann _ (UTySplice spl)
 
 -- | A Template Haskell splice type (@ $(genType) @).
-pattern QuasiQuoteType :: QuasiQuote dom -> Type dom
+pattern QuasiQuoteType :: QuasiQuote -> Type
 pattern QuasiQuoteType spl <- Ann _ (UTyQuasiQuote spl)
 
 -- | Numeric value promoted to the type level.
-pattern PromotedIntType :: Integer -> Type dom
+pattern PromotedIntType :: Integer -> Type
 pattern PromotedIntType i <- Ann _ (UTyPromoted (Ann _ (UPromotedInt i)))
 
 -- | String value promoted to the type level.
-pattern PromotedStringType :: String -> Type dom
+pattern PromotedStringType :: String -> Type
 pattern PromotedStringType s <- Ann _ (UTyPromoted (Ann _ (UPromotedString s)))
 
 -- | A data constructor value promoted to the type level.
-pattern PromotedConType :: Name dom -> Type dom
+pattern PromotedConType :: Name -> Type
 pattern PromotedConType s <- Ann _ (UTyPromoted (Ann _ (UPromotedCon s)))
 
 -- | A list of elements as a type.
-pattern PromotedListType :: TypeList dom -> Type dom
+pattern PromotedListType :: TypeList -> Type
 pattern PromotedListType elems <- Ann _ (UTyPromoted (Ann _ (UPromotedList elems)))
 
 -- | A tuple of elements as a type.
-pattern PromotedTupleType :: TypeList dom -> Type dom
+pattern PromotedTupleType :: TypeList -> Type
 pattern PromotedTupleType elems <- Ann _ (UTyPromoted (Ann _ (UPromotedTuple elems)))
 
 -- | Kind of the unit value @()@.
-pattern PromotedUnitType :: Type dom
+pattern PromotedUnitType :: Type
 pattern PromotedUnitType <- Ann _ (UTyPromoted (Ann _ UPromotedUnit))
 
 -- * Type variable
 
 -- | Type variable declaration
-pattern TyVarDecl :: Name dom -> TyVar dom
+pattern TyVarDecl :: Name -> TyVar
 pattern TyVarDecl n <- Ann _ (UTyVarDecl n _)
 
 -- | Kinded type variable declaration (@ v :: * @)
-pattern KindedTyVarDecl :: Name dom -> Kind dom -> TyVar dom
+pattern KindedTyVarDecl :: Name -> Kind -> TyVar
 pattern KindedTyVarDecl n k <- Ann _ (UTyVarDecl n (AnnJust (Ann _ (UKindConstraint k))))
 
 -- * Contexts
 
 -- | A context of assertions (@ C a => ... @)
-pattern Context :: Assertion dom -> Context dom
+pattern Context :: Assertion -> Context
 pattern Context n <- Ann _ (UContext n)
 
 -- * Assertions
 
 -- | Class assertion (@Cls x@)
-pattern ClassAssert :: Name dom -> TypeList dom -> Assertion dom
+pattern ClassAssert :: Name -> TypeList -> Assertion
 pattern ClassAssert n args <- Ann _ (UClassAssert n args)
 
 -- | Infix class assertion, also contains type equations (@ a ~ X y @)
-pattern InfixAssert :: Type dom -> Operator dom -> Type dom -> Assertion dom
+pattern InfixAssert :: Type -> Operator -> Type -> Assertion
 pattern InfixAssert left op right <- Ann _ (UInfixAssert left op right)
 
 -- | Assertion for implicit parameter binding (@ ?cmp :: a -> a -> Bool @)
-pattern ImplicitAssert :: Name dom -> Type dom -> Assertion dom
+pattern ImplicitAssert :: Name -> Type -> Assertion
 pattern ImplicitAssert n t <- Ann _ (UImplicitAssert n t)
 
 -- | A list of assertions (@ (Eq a, Show a) @)
-pattern TupleAssert :: [Assertion dom] -> Assertion dom
+pattern TupleAssert :: [Assertion] -> Assertion
 pattern TupleAssert ass <- Ann _ (UTupleAssert (AnnList ass))
haskell-tools-rewrite.cabal view
@@ -1,5 +1,5 @@ name:                haskell-tools-rewrite
-version:             1.0.0.1
+version:             1.0.0.2
 synopsis:            Facilities for generating new parts of the Haskell-Tools AST
 description:         Contains utility functions to generate parts of the Haskell-Tools AST. Generates these elements to be compatible with the source annotations that are already present on the AST. The package is divided into modules based on which language elements can the given module generate. This packages should be used during the transformations to generate parts of the new AST.
 homepage:            https://github.com/haskell-tools/haskell-tools
@@ -54,8 +54,8 @@   hs-source-dirs:      test
   main-is:             Main.hs
   build-depends:       base                      >= 4.10 && < 4.11
-                     , tasty                     >= 0.11 && < 0.12
-                     , tasty-hunit               >= 0.9 && < 0.10
+                     , tasty                     >= 0.11 && < 0.13
+                     , tasty-hunit               >= 0.9 && < 0.11
                      , directory                 >= 1.2 && < 1.4
                      , filepath                  >= 1.4 && < 2.0
                      , haskell-tools-ast         >= 1.0 && < 1.1