diff --git a/Language/Haskell/TH.hs b/Language/Haskell/TH.hs --- a/Language/Haskell/TH.hs +++ b/Language/Haskell/TH.hs @@ -4,6 +4,7 @@ -} +{-# LANGUAGE Safe #-} module Language.Haskell.TH( -- * The monad and its operations Q, @@ -34,6 +35,8 @@ lookupValueName, -- :: String -> Q (Maybe Name) -- *** Fixity lookup reifyFixity, + -- *** Type lookup + reifyType, -- *** Instance lookup reifyInstances, isInstance, diff --git a/Language/Haskell/TH/LanguageExtensions.hs b/Language/Haskell/TH/LanguageExtensions.hs --- a/Language/Haskell/TH/LanguageExtensions.hs +++ b/Language/Haskell/TH/LanguageExtensions.hs @@ -1,3 +1,4 @@ +{-# LANGUAGE Safe #-} ----------------------------------------------------------------------------- -- | -- Module : Language.Haskell.TH.LanguageExtensions diff --git a/Language/Haskell/TH/Lib.hs b/Language/Haskell/TH/Lib.hs --- a/Language/Haskell/TH/Lib.hs +++ b/Language/Haskell/TH/Lib.hs @@ -1,3 +1,5 @@ +{-# LANGUAGE Safe #-} + -- | -- Language.Haskell.TH.Lib contains lots of useful helper functions for -- generating and manipulating Template Haskell terms @@ -26,7 +28,7 @@ -- ** Constructors lifted to 'Q' -- *** Literals intPrimL, wordPrimL, floatPrimL, doublePrimL, integerL, rationalL, - charL, stringL, stringPrimL, charPrimL, + charL, stringL, stringPrimL, charPrimL, bytesPrimL, mkBytes, -- *** Patterns litP, varP, tupP, unboxedTupP, unboxedSumP, conP, uInfixP, parensP, infixP, tildeP, bangP, asP, wildP, recP, @@ -52,10 +54,10 @@ bindS, letS, noBindS, parS, recS, -- *** Types - forallT, varT, conT, appT, appKindT, arrowT, infixT, uInfixT, parensT, - equalityT, listT, tupleT, unboxedTupleT, unboxedSumT, sigT, litT, - wildCardT, promotedT, promotedTupleT, promotedNilT, promotedConsT, - implicitParamT, + forallT, forallVisT, varT, conT, appT, appKindT, arrowT, infixT, + uInfixT, parensT, equalityT, listT, tupleT, unboxedTupleT, unboxedSumT, + sigT, litT, wildCardT, promotedT, promotedTupleT, promotedNilT, + promotedConsT, implicitParamT, -- **** Type literals numTyLit, strTyLit, -- **** Strictness @@ -85,7 +87,7 @@ viaStrategy, DerivStrategy(..), -- **** Class classD, instanceD, instanceWithOverlapD, Overlap(..), - sigD, standaloneDerivD, standaloneDerivWithStrategyD, defaultSigD, + sigD, kiSigD, standaloneDerivD, standaloneDerivWithStrategyD, defaultSigD, -- **** Role annotations roleAnnotD, @@ -151,12 +153,17 @@ , derivClause , standaloneDerivWithStrategyD + , tupE + , unboxedTupE + , Role , InjectivityAnn ) import Language.Haskell.TH.Syntax import Control.Monad (liftM2) +import Foreign.ForeignPtr +import Data.Word import Prelude -- All definitions below represent the "old" API, since their definitions are @@ -303,3 +310,26 @@ ctxt' <- ctxt ty' <- ty return $ StandaloneDerivD mds ctxt' ty' + +------------------------------------------------------------------------------- +-- * Bytes literals + +-- | Create a Bytes datatype representing raw bytes to be embedded into the +-- program/library binary. +-- +-- @since 2.16.0.0 +mkBytes + :: ForeignPtr Word8 -- ^ Pointer to the data + -> Word -- ^ Offset from the pointer + -> Word -- ^ Number of bytes + -> Bytes +mkBytes = Bytes + +------------------------------------------------------------------------------- +-- * Tuple expressions + +tupE :: [ExpQ] -> ExpQ +tupE es = do { es1 <- sequence es; return (TupE $ map Just es1)} + +unboxedTupE :: [ExpQ] -> ExpQ +unboxedTupE es = do { es1 <- sequence es; return (UnboxedTupE $ map Just es1)} diff --git a/Language/Haskell/TH/Lib/Internal.hs b/Language/Haskell/TH/Lib/Internal.hs --- a/Language/Haskell/TH/Lib/Internal.hs +++ b/Language/Haskell/TH/Lib/Internal.hs @@ -1,3 +1,5 @@ +{-# LANGUAGE Safe #-} + -- | -- Language.Haskell.TH.Lib.Internal exposes some additional functionality that -- is used internally in GHC's integration with Template Haskell. This is not a @@ -86,6 +88,8 @@ stringL = StringL stringPrimL :: [Word8] -> Lit stringPrimL = StringPrimL +bytesPrimL :: Bytes -> Lit +bytesPrimL = BytesPrimL rationalL :: Rational -> Lit rationalL = RationalL @@ -284,11 +288,11 @@ lamCaseE :: [MatchQ] -> ExpQ lamCaseE ms = sequence ms >>= return . LamCaseE -tupE :: [ExpQ] -> ExpQ -tupE es = do { es1 <- sequence es; return (TupE es1)} +tupE :: [Maybe ExpQ] -> ExpQ +tupE es = do { es1 <- traverse sequence es; return (TupE es1)} -unboxedTupE :: [ExpQ] -> ExpQ -unboxedTupE es = do { es1 <- sequence es; return (UnboxedTupE es1)} +unboxedTupE :: [Maybe ExpQ] -> ExpQ +unboxedTupE es = do { es1 <- traverse sequence es; return (UnboxedTupE es1)} unboxedSumE :: ExpQ -> SumAlt -> SumArity -> ExpQ unboxedSumE e alt arity = do { e1 <- e; return (UnboxedSumE e1 alt arity) } @@ -433,6 +437,9 @@ sigD :: Name -> TypeQ -> DecQ sigD fun ty = liftM (SigD fun) $ ty +kiSigD :: Name -> KindQ -> DecQ +kiSigD fun ki = liftM (KiSigD fun) $ ki + forImpD :: Callconv -> Safety -> String -> Name -> TypeQ -> DecQ forImpD cc s str n ty = do ty' <- ty @@ -646,6 +653,9 @@ ty1 <- ty return $ ForallT tvars1 ctxt1 ty1 +forallVisT :: [TyVarBndrQ] -> TypeQ -> TypeQ +forallVisT tvars ty = ForallVisT <$> sequenceA tvars <*> ty + varT :: Name -> TypeQ varT = return . VarT @@ -754,13 +764,13 @@ sourceStrict = return SourceStrict {-# DEPRECATED isStrict - ["Use 'bang'. See https://ghc.haskell.org/trac/ghc/wiki/Migration/8.0. ", + ["Use 'bang'. See https://gitlab.haskell.org/ghc/ghc/wikis/migration/8.0. ", "Example usage: 'bang noSourceUnpackedness sourceStrict'"] #-} {-# DEPRECATED notStrict - ["Use 'bang'. See https://ghc.haskell.org/trac/ghc/wiki/Migration/8.0. ", + ["Use 'bang'. See https://gitlab.haskell.org/ghc/ghc/wikis/migration/8.0. ", "Example usage: 'bang noSourceUnpackedness noSourceStrictness'"] #-} {-# DEPRECATED unpacked - ["Use 'bang'. See https://ghc.haskell.org/trac/ghc/wiki/Migration/8.0. ", + ["Use 'bang'. See https://gitlab.haskell.org/ghc/ghc/wikis/migration/8.0. ", "Example usage: 'bang sourceUnpack sourceStrict'"] #-} isStrict, notStrict, unpacked :: Q Strict isStrict = bang noSourceUnpackedness sourceStrict diff --git a/Language/Haskell/TH/Lib/Map.hs b/Language/Haskell/TH/Lib/Map.hs --- a/Language/Haskell/TH/Lib/Map.hs +++ b/Language/Haskell/TH/Lib/Map.hs @@ -1,4 +1,5 @@ {-# LANGUAGE BangPatterns #-} +{-# LANGUAGE Safe #-} -- This is a non-exposed internal module -- diff --git a/Language/Haskell/TH/Ppr.hs b/Language/Haskell/TH/Ppr.hs --- a/Language/Haskell/TH/Ppr.hs +++ b/Language/Haskell/TH/Ppr.hs @@ -1,3 +1,4 @@ +{-# LANGUAGE Safe #-} -- | contains a prettyprinter for the -- Template Haskell datatypes @@ -123,7 +124,10 @@ pprInfixExp :: Exp -> Doc pprInfixExp (VarE v) = pprName' Infix v pprInfixExp (ConE v) = pprName' Infix v -pprInfixExp _ = text "<>" +pprInfixExp (UnboundVarE v) = pprName' Infix v +-- This case will only ever be reached in exceptional circumstances. +-- For example, when printing an error message in case of a malformed expression. +pprInfixExp e = text "`" <> ppr e <> text "`" pprExp :: Precedence -> Exp -> Doc pprExp _ (VarE v) = pprName' Applied v @@ -150,8 +154,12 @@ <+> text "->" <+> ppr e pprExp i (LamCaseE ms) = parensIf (i > noPrec) $ text "\\case" $$ nest nestDepth (ppr ms) -pprExp _ (TupE es) = parens (commaSep es) -pprExp _ (UnboxedTupE es) = hashParens (commaSep es) +pprExp i (TupE es) + | [Just e] <- es + = pprExp i (ConE (tupleDataName 1) `AppE` e) + | otherwise + = parens (commaSepWith (pprMaybeExp noPrec) es) +pprExp _ (UnboxedTupE es) = hashParens (commaSepWith (pprMaybeExp noPrec) es) pprExp _ (UnboxedSumE e alt arity) = unboxedSumBars (ppr e) alt arity -- Nesting in Cond is to avoid potential problems in do statements pprExp i (CondE guard true false) @@ -268,6 +276,7 @@ pprLit _ (CharPrimL c) = text (show c) <> char '#' pprLit _ (StringL s) = pprString s pprLit _ (StringPrimL s) = pprString (bytesToString s) <> char '#' +pprLit _ (BytesPrimL {}) = pprString "" pprLit i (RationalL rat) = parensIf (i > noPrec) $ integer (numerator rat) <+> char '/' <+> integer (denominator rat) @@ -287,7 +296,11 @@ pprPat :: Precedence -> Pat -> Doc pprPat i (LitP l) = pprLit i l pprPat _ (VarP v) = pprName' Applied v -pprPat _ (TupP ps) = parens (commaSep ps) +pprPat i (TupP ps) + | [_] <- ps + = pprPat i (ConP (tupleDataName 1) ps) + | otherwise + = parens (commaSep ps) pprPat _ (UnboxedTupP ps) = hashParens (commaSep ps) pprPat _ (UnboxedSumP p alt arity) = unboxedSumBars (ppr p) alt arity pprPat i (ConP s ps) = parensIf (i >= appPrec) $ pprName' Applied s @@ -337,6 +350,7 @@ text "instance" <+> maybe empty ppr_overlap o <+> pprCxt ctxt <+> ppr i $$ where_clause ds ppr_dec _ (SigD f t) = pprPrefixOcc f <+> dcolon <+> ppr t +ppr_dec _ (KiSigD f k) = text "type" <+> pprPrefixOcc f <+> dcolon <+> ppr k ppr_dec _ (ForeignD f) = ppr f ppr_dec _ (InfixD fx n) = pprFixity n fx ppr_dec _ (PragmaD p) = ppr p @@ -647,12 +661,23 @@ commaSepApplied = commaSepWith (pprName' Applied) pprForall :: [TyVarBndr] -> Cxt -> Doc -pprForall tvs cxt +pprForall = pprForall' ForallInvis + +pprForallVis :: [TyVarBndr] -> Cxt -> Doc +pprForallVis = pprForall' ForallVis + +pprForall' :: ForallVisFlag -> [TyVarBndr] -> Cxt -> Doc +pprForall' fvf tvs cxt -- even in the case without any tvs, there could be a non-empty -- context cxt (e.g., in the case of pattern synonyms, where there -- are multiple forall binders and contexts). | [] <- tvs = pprCxt cxt - | otherwise = text "forall" <+> hsep (map ppr tvs) <+> char '.' <+> pprCxt cxt + | otherwise = text "forall" <+> hsep (map ppr tvs) + <+> separator <+> pprCxt cxt + where + separator = case fvf of + ForallVis -> text "->" + ForallInvis -> char '.' pprRecFields :: [(Name, Strict, Type)] -> Type -> Doc pprRecFields vsts ty @@ -726,6 +751,7 @@ -- `Applied` is used here instead of `ppr` because of infix names (#13887) pprParendType (ConT c) = pprName' Applied c pprParendType (TupleT 0) = text "()" +pprParendType (TupleT 1) = pprParendType (ConT (tupleTypeName 1)) pprParendType (TupleT n) = parens (hcat (replicate (n-1) comma)) pprParendType (UnboxedTupleT n) = hashParens $ hcat $ replicate (n-1) comma pprParendType (UnboxedSumT arity) = hashParens $ hcat $ replicate (arity-1) bar @@ -734,6 +760,7 @@ pprParendType (LitT l) = pprTyLit l pprParendType (PromotedT c) = text "'" <> pprName' Applied c pprParendType (PromotedTupleT 0) = text "'()" +pprParendType (PromotedTupleT 1) = pprParendType (PromotedT (tupleDataName 1)) pprParendType (PromotedTupleT n) = quoteParens (hcat (replicate (n-1) comma)) pprParendType PromotedNilT = text "'[]" pprParendType PromotedConsT = text "'(:)" @@ -750,6 +777,7 @@ pprParendType (ImplicitParamT n t)= text ('?':n) <+> text "::" <+> ppr t pprParendType EqualityT = text "(~)" pprParendType t@(ForallT {}) = parens (ppr t) +pprParendType t@(ForallVisT {}) = parens (ppr t) pprParendType t@(AppT {}) = parens (ppr t) pprParendType t@(AppKindT {}) = parens (ppr t) @@ -759,6 +787,7 @@ instance Ppr Type where ppr (ForallT tvars ctxt ty) = sep [pprForall tvars ctxt, ppr ty] + ppr (ForallVisT tvars ty) = sep [pprForallVis tvars [], ppr ty] ppr ty = pprTyApp (split ty) -- Works, in a degnerate way, for SigT, and puts parens round (ty :: kind) -- See Note [Pretty-printing kind signatures] @@ -775,7 +804,7 @@ parens around it. E.g. the parens are required here: f :: (Int :: *) type instance F Int = (Bool :: *) -So we always print a SigT with parens (see Trac #10050). -} +So we always print a SigT with parens (see #10050). -} pprTyApp :: (Type, [TypeArg]) -> Doc pprTyApp (ArrowT, [TANormal arg1, TANormal arg2]) = sep [pprFunArgType arg1 <+> text "->", ppr arg2] @@ -783,17 +812,28 @@ sep [pprFunArgType arg1 <+> text "~", ppr arg2] pprTyApp (ListT, [TANormal arg]) = brackets (ppr arg) pprTyApp (TupleT n, args) - | length args == n = parens (commaSep args) + | length args == n + = if n == 1 + then pprTyApp (ConT (tupleTypeName 1), args) + else parens (commaSep args) pprTyApp (PromotedTupleT n, args) - | length args == n = quoteParens (commaSep args) + | length args == n + = if n == 1 + then pprTyApp (PromotedT (tupleDataName 1), args) + else quoteParens (commaSep args) pprTyApp (fun, args) = pprParendType fun <+> sep (map pprParendTypeArg args) pprFunArgType :: Type -> Doc -- Should really use a precedence argument -- Everything except forall and (->) binds more tightly than (->) pprFunArgType ty@(ForallT {}) = parens (ppr ty) +pprFunArgType ty@(ForallVisT {}) = parens (ppr ty) pprFunArgType ty@((ArrowT `AppT` _) `AppT` _) = parens (ppr ty) pprFunArgType ty@(SigT _ _) = parens (ppr ty) pprFunArgType ty = ppr ty + +data ForallVisFlag = ForallVis -- forall a -> {...} + | ForallInvis -- forall a. {...} + deriving Show data TypeArg = TANormal Type | TyArg Kind diff --git a/Language/Haskell/TH/PprLib.hs b/Language/Haskell/TH/PprLib.hs --- a/Language/Haskell/TH/PprLib.hs +++ b/Language/Haskell/TH/PprLib.hs @@ -1,4 +1,4 @@ -{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE FlexibleInstances, Safe #-} -- | Monadic front-end to Text.PrettyPrint @@ -36,14 +36,14 @@ import Language.Haskell.TH.Syntax - (Name(..), showName', NameFlavour(..), NameIs(..)) + (Uniq, Name(..), showName', NameFlavour(..), NameIs(..)) import qualified Text.PrettyPrint as HPJ import Control.Monad (liftM, liftM2, ap) import Language.Haskell.TH.Lib.Map ( Map ) import qualified Language.Haskell.TH.Lib.Map as Map ( lookup, insert, empty ) import Prelude hiding ((<>)) -infixl 6 <> +infixl 6 <> infixl 6 <+> infixl 5 $$, $+$ @@ -117,7 +117,7 @@ -- --------------------------------------------------------------------------- -- The "implementation" -type State = (Map Name Name, Int) +type State = (Map Name Name, Uniq) data PprM a = PprM { runPprM :: State -> (a, State) } pprName :: Name -> Doc diff --git a/Language/Haskell/TH/Quote.hs b/Language/Haskell/TH/Quote.hs --- a/Language/Haskell/TH/Quote.hs +++ b/Language/Haskell/TH/Quote.hs @@ -1,4 +1,4 @@ -{-# LANGUAGE RankNTypes, ScopedTypeVariables #-} +{-# LANGUAGE RankNTypes, ScopedTypeVariables, Safe #-} {- | Module : Language.Haskell.TH.Quote Description : Quasi-quoting support for Template Haskell diff --git a/Language/Haskell/TH/Syntax.hs b/Language/Haskell/TH/Syntax.hs --- a/Language/Haskell/TH/Syntax.hs +++ b/Language/Haskell/TH/Syntax.hs @@ -1,6 +1,8 @@ {-# LANGUAGE CPP, DeriveDataTypeable, DeriveGeneric, FlexibleInstances, DefaultSignatures, RankNTypes, RoleAnnotations, ScopedTypeVariables, + MagicHash, KindSignatures, PolyKinds, TypeApplications, DataKinds, + GADTs, UnboxedTuples, UnboxedSums, TypeInType, Trustworthy #-} {-# OPTIONS_GHC -fno-warn-inline-rule-shadowing #-} @@ -32,18 +34,23 @@ import Control.Monad (liftM) import Control.Monad.IO.Class (MonadIO (..)) import System.IO ( hPutStrLn, stderr ) -import Data.Char ( isAlpha, isAlphaNum, isUpper ) +import Data.Char ( isAlpha, isAlphaNum, isUpper, ord ) import Data.Int import Data.List.NonEmpty ( NonEmpty(..) ) import Data.Void ( Void, absurd ) import Data.Word import Data.Ratio +import GHC.CString ( unpackCString# ) import GHC.Generics ( Generic ) +import GHC.Types ( Int(..), Word(..), Char(..), Double(..), Float(..), + TYPE, RuntimeRep(..) ) +import GHC.Prim ( Int#, Word#, Char#, Double#, Float#, Addr# ) import GHC.Lexeme ( startsVarSym, startsVarId ) import GHC.ForeignSrcLang.Type import Language.Haskell.TH.LanguageExtensions import Numeric.Natural import Prelude +import Foreign.ForeignPtr import qualified Control.Monad.Fail as Fail @@ -69,6 +76,7 @@ -- True <=> type namespace, False <=> value namespace qReify :: Name -> m Info qReifyFixity :: Name -> m (Maybe Fixity) + qReifyType :: Name -> m Type qReifyInstances :: Name -> [Type] -> m [Dec] -- Is (n tys) an instance? -- Returns list of matching instance Decs @@ -125,6 +133,7 @@ qLookupName _ _ = badIO "lookupName" qReify _ = badIO "reify" qReifyFixity _ = badIO "reifyFixity" + qReifyType _ = badIO "reifyFixity" qReifyInstances _ _ = badIO "reifyInstances" qReifyRoles _ = badIO "reifyRoles" qReifyAnnotations _ = badIO "reifyAnnotations" @@ -148,7 +157,7 @@ ; fail "Template Haskell failure" } -- Global variable to generate unique symbols -counter :: IORef Int +counter :: IORef Uniq {-# NOINLINE counter #-} counter = unsafePerformIO (newIORef 0) @@ -200,20 +209,65 @@ ----------------------------------------------------- type role TExp nominal -- See Note [Role of TExp] -newtype TExp a = TExp { unType :: Exp } +newtype TExp (a :: TYPE (r :: RuntimeRep)) = TExp + { unType :: Exp -- ^ Underlying untyped Template Haskell expression + } +-- ^ Represents an expression which has type @a@. Built on top of 'Exp', typed +-- expressions allow for type-safe splicing via: +-- +-- - typed quotes, written as @[|| ... ||]@ where @...@ is an expression; if +-- that expression has type @a@, then the quotation has type +-- @'Q' ('TExp' a)@ +-- +-- - typed splices inside of typed quotes, written as @$$(...)@ where @...@ +-- is an arbitrary expression of type @'Q' ('TExp' a)@ +-- +-- Traditional expression quotes and splices let us construct ill-typed +-- expressions: +-- +-- >>> fmap ppr $ runQ [| True == $( [| "foo" |] ) |] +-- GHC.Types.True GHC.Classes.== "foo" +-- >>> GHC.Types.True GHC.Classes.== "foo" +-- error: +-- • Couldn't match expected type ‘Bool’ with actual type ‘[Char]’ +-- • In the second argument of ‘(==)’, namely ‘"foo"’ +-- In the expression: True == "foo" +-- In an equation for ‘it’: it = True == "foo" +-- +-- With typed expressions, the type error occurs when /constructing/ the +-- Template Haskell expression: +-- +-- >>> fmap ppr $ runQ [|| True == $$( [|| "foo" ||] ) ||] +-- error: +-- • Couldn't match type ‘[Char]’ with ‘Bool’ +-- Expected type: Q (TExp Bool) +-- Actual type: Q (TExp [Char]) +-- • In the Template Haskell quotation [|| "foo" ||] +-- In the expression: [|| "foo" ||] +-- In the Template Haskell splice $$([|| "foo" ||]) -unTypeQ :: Q (TExp a) -> Q Exp +-- | Discard the type annotation and produce a plain Template Haskell +-- expression +-- +-- Levity-polymorphic since /template-haskell-2.16.0.0/. +unTypeQ :: forall (r :: RuntimeRep) (a :: TYPE r). Q (TExp a) -> Q Exp unTypeQ m = do { TExp e <- m ; return e } -unsafeTExpCoerce :: Q Exp -> Q (TExp a) +-- | Annotate the Template Haskell expression with a type +-- +-- This is unsafe because GHC cannot check for you that the expression +-- really does have the type you claim it has. +-- +-- Levity-polymorphic since /template-haskell-2.16.0.0/. +unsafeTExpCoerce :: forall (r :: RuntimeRep) (a :: TYPE r). Q Exp -> Q (TExp a) unsafeTExpCoerce m = do { e <- m ; return (TExp e) } {- Note [Role of TExp] ~~~~~~~~~~~~~~~~~~~~~~ TExp's argument must have a nominal role, not phantom as would -be inferred (Trac #8459). Consider +be inferred (#8459). Consider e :: TExp Age e = MkAge 3 @@ -377,6 +431,14 @@ reifyFixity :: Name -> Q (Maybe Fixity) reifyFixity nm = Q (qReifyFixity nm) +{- | @reifyType nm@ attempts to find the type or kind of @nm@. For example, +@reifyType 'not@ returns @Bool -> Bool@, and +@reifyType ''Bool@ returns @Type@. +This works even if there's no explicit signature and the type or kind is inferred. +-} +reifyType :: Name -> Q Type +reifyType nm = Q (qReifyType nm) + {- | @reifyInstances nm tys@ returns a list of visible instances of @nm tys@. That is, if @nm@ is the name of a type class, then all instances of this class at the types @tys@ are returned. Alternatively, if @nm@ is the name of a data family or type family, @@ -568,6 +630,7 @@ qRecover = recover qReify = reify qReifyFixity = reifyFixity + qReifyType = reifyType qReifyInstances = reifyInstances qReifyRoles = reifyRoles qReifyAnnotations = reifyAnnotations @@ -609,17 +672,18 @@ -- | A 'Lift' instance can have any of its values turned into a Template -- Haskell expression. This is needed when a value used within a Template --- Haskell quotation is bound outside the Oxford brackets (@[| ... |]@) but not --- at the top level. As an example: +-- Haskell quotation is bound outside the Oxford brackets (@[| ... |]@ or +-- @[|| ... ||]@) but not at the top level. As an example: -- --- > add1 :: Int -> Q Exp --- > add1 x = [| x + 1 |] +-- > add1 :: Int -> Q (TExp Int) +-- > add1 x = [|| x + 1 ||] -- -- Template Haskell has no way of knowing what value @x@ will take on at -- splice-time, so it requires the type of @x@ to be an instance of 'Lift'. -- --- A 'Lift' instance must satisfy @$(lift x) ≡ x@ for all @x@, where @$(...)@ --- is a Template Haskell splice. +-- A 'Lift' instance must satisfy @$(lift x) ≡ x@ and @$$(liftTyped x) ≡ x@ +-- for all @x@, where @$(...)@ and @$$(...)@ are Template Haskell splices. +-- It is additionally expected that @'lift' x ≡ 'unTypeQ' ('liftTyped' x)@. -- -- 'Lift' instances can be derived automatically by use of the @-XDeriveLift@ -- GHC language extension: @@ -631,75 +695,141 @@ -- > -- > data Bar a = Bar1 a (Bar a) | Bar2 String -- > deriving Lift -class Lift t where +-- +-- Levity-polymorphic since /template-haskell-2.16.0.0/. +class Lift (t :: TYPE r) where -- | Turn a value into a Template Haskell expression, suitable for use in -- a splice. lift :: t -> Q Exp - default lift :: Data t => t -> Q Exp - lift = liftData + default lift :: (r ~ 'LiftedRep) => t -> Q Exp + lift = unTypeQ . liftTyped + -- | Turn a value into a Template Haskell typed expression, suitable for use + -- in a typed splice. + -- + -- @since 2.16.0.0 + liftTyped :: t -> Q (TExp t) + + -- If you add any instances here, consider updating test th/TH_Lift instance Lift Integer where + liftTyped x = unsafeTExpCoerce (lift x) lift x = return (LitE (IntegerL x)) instance Lift Int where + liftTyped x = unsafeTExpCoerce (lift x) lift x = return (LitE (IntegerL (fromIntegral x))) +-- | @since 2.16.0.0 +instance Lift Int# where + liftTyped x = unsafeTExpCoerce (lift x) + lift x = return (LitE (IntPrimL (fromIntegral (I# x)))) + instance Lift Int8 where + liftTyped x = unsafeTExpCoerce (lift x) lift x = return (LitE (IntegerL (fromIntegral x))) instance Lift Int16 where + liftTyped x = unsafeTExpCoerce (lift x) lift x = return (LitE (IntegerL (fromIntegral x))) instance Lift Int32 where + liftTyped x = unsafeTExpCoerce (lift x) lift x = return (LitE (IntegerL (fromIntegral x))) instance Lift Int64 where + liftTyped x = unsafeTExpCoerce (lift x) lift x = return (LitE (IntegerL (fromIntegral x))) +-- | @since 2.16.0.0 +instance Lift Word# where + liftTyped x = unsafeTExpCoerce (lift x) + lift x = return (LitE (WordPrimL (fromIntegral (W# x)))) + instance Lift Word where + liftTyped x = unsafeTExpCoerce (lift x) lift x = return (LitE (IntegerL (fromIntegral x))) instance Lift Word8 where + liftTyped x = unsafeTExpCoerce (lift x) lift x = return (LitE (IntegerL (fromIntegral x))) instance Lift Word16 where + liftTyped x = unsafeTExpCoerce (lift x) lift x = return (LitE (IntegerL (fromIntegral x))) instance Lift Word32 where + liftTyped x = unsafeTExpCoerce (lift x) lift x = return (LitE (IntegerL (fromIntegral x))) instance Lift Word64 where + liftTyped x = unsafeTExpCoerce (lift x) lift x = return (LitE (IntegerL (fromIntegral x))) instance Lift Natural where + liftTyped x = unsafeTExpCoerce (lift x) lift x = return (LitE (IntegerL (fromIntegral x))) instance Integral a => Lift (Ratio a) where + liftTyped x = unsafeTExpCoerce (lift x) lift x = return (LitE (RationalL (toRational x))) instance Lift Float where + liftTyped x = unsafeTExpCoerce (lift x) lift x = return (LitE (RationalL (toRational x))) +-- | @since 2.16.0.0 +instance Lift Float# where + liftTyped x = unsafeTExpCoerce (lift x) + lift x = return (LitE (FloatPrimL (toRational (F# x)))) + instance Lift Double where + liftTyped x = unsafeTExpCoerce (lift x) lift x = return (LitE (RationalL (toRational x))) +-- | @since 2.16.0.0 +instance Lift Double# where + liftTyped x = unsafeTExpCoerce (lift x) + lift x = return (LitE (DoublePrimL (toRational (D# x)))) + instance Lift Char where + liftTyped x = unsafeTExpCoerce (lift x) lift x = return (LitE (CharL x)) +-- | @since 2.16.0.0 +instance Lift Char# where + liftTyped x = unsafeTExpCoerce (lift x) + lift x = return (LitE (CharPrimL (C# x))) + instance Lift Bool where + liftTyped x = unsafeTExpCoerce (lift x) + lift True = return (ConE trueName) lift False = return (ConE falseName) +-- | Produces an 'Addr#' literal from the NUL-terminated C-string starting at +-- the given memory address. +-- +-- @since 2.16.0.0 +instance Lift Addr# where + liftTyped x = unsafeTExpCoerce (lift x) + lift x + = return (LitE (StringPrimL (map (fromIntegral . ord) (unpackCString# x)))) + instance Lift a => Lift (Maybe a) where + liftTyped x = unsafeTExpCoerce (lift x) + lift Nothing = return (ConE nothingName) lift (Just x) = liftM (ConE justName `AppE`) (lift x) instance (Lift a, Lift b) => Lift (Either a b) where + liftTyped x = unsafeTExpCoerce (lift x) + lift (Left x) = liftM (ConE leftName `AppE`) (lift x) lift (Right y) = liftM (ConE rightName `AppE`) (lift y) instance Lift a => Lift [a] where + liftTyped x = unsafeTExpCoerce (lift x) lift xs = do { xs' <- mapM lift xs; return (ListE xs') } liftString :: String -> Q Exp @@ -708,6 +838,8 @@ -- | @since 2.15.0.0 instance Lift a => Lift (NonEmpty a) where + liftTyped x = unsafeTExpCoerce (lift x) + lift (x :| xs) = do x' <- lift x xs' <- lift xs @@ -715,38 +847,174 @@ -- | @since 2.15.0.0 instance Lift Void where + liftTyped = pure . absurd lift = pure . absurd instance Lift () where + liftTyped x = unsafeTExpCoerce (lift x) lift () = return (ConE (tupleDataName 0)) instance (Lift a, Lift b) => Lift (a, b) where + liftTyped x = unsafeTExpCoerce (lift x) lift (a, b) - = liftM TupE $ sequence [lift a, lift b] + = liftM TupE $ sequence $ map (fmap Just) [lift a, lift b] instance (Lift a, Lift b, Lift c) => Lift (a, b, c) where + liftTyped x = unsafeTExpCoerce (lift x) lift (a, b, c) - = liftM TupE $ sequence [lift a, lift b, lift c] + = liftM TupE $ sequence $ map (fmap Just) [lift a, lift b, lift c] instance (Lift a, Lift b, Lift c, Lift d) => Lift (a, b, c, d) where + liftTyped x = unsafeTExpCoerce (lift x) lift (a, b, c, d) - = liftM TupE $ sequence [lift a, lift b, lift c, lift d] + = liftM TupE $ sequence $ map (fmap Just) [lift a, lift b, lift c, lift d] instance (Lift a, Lift b, Lift c, Lift d, Lift e) => Lift (a, b, c, d, e) where + liftTyped x = unsafeTExpCoerce (lift x) lift (a, b, c, d, e) - = liftM TupE $ sequence [lift a, lift b, lift c, lift d, lift e] + = liftM TupE $ sequence $ map (fmap Just) [ lift a, lift b + , lift c, lift d, lift e ] instance (Lift a, Lift b, Lift c, Lift d, Lift e, Lift f) => Lift (a, b, c, d, e, f) where + liftTyped x = unsafeTExpCoerce (lift x) lift (a, b, c, d, e, f) - = liftM TupE $ sequence [lift a, lift b, lift c, lift d, lift e, lift f] + = liftM TupE $ sequence $ map (fmap Just) [ lift a, lift b, lift c + , lift d, lift e, lift f ] instance (Lift a, Lift b, Lift c, Lift d, Lift e, Lift f, Lift g) => Lift (a, b, c, d, e, f, g) where + liftTyped x = unsafeTExpCoerce (lift x) lift (a, b, c, d, e, f, g) - = liftM TupE $ sequence [lift a, lift b, lift c, lift d, lift e, lift f, lift g] + = liftM TupE $ sequence $ map (fmap Just) [ lift a, lift b, lift c + , lift d, lift e, lift f, lift g ] +-- | @since 2.16.0.0 +instance Lift (# #) where + liftTyped x = unsafeTExpCoerce (lift x) + lift (# #) = return (ConE (unboxedTupleTypeName 0)) + +-- | @since 2.16.0.0 +instance (Lift a) => Lift (# a #) where + liftTyped x = unsafeTExpCoerce (lift x) + lift (# a #) + = liftM UnboxedTupE $ sequence $ map (fmap Just) [lift a] + +-- | @since 2.16.0.0 +instance (Lift a, Lift b) => Lift (# a, b #) where + liftTyped x = unsafeTExpCoerce (lift x) + lift (# a, b #) + = liftM UnboxedTupE $ sequence $ map (fmap Just) [lift a, lift b] + +-- | @since 2.16.0.0 +instance (Lift a, Lift b, Lift c) + => Lift (# a, b, c #) where + liftTyped x = unsafeTExpCoerce (lift x) + lift (# a, b, c #) + = liftM UnboxedTupE $ sequence $ map (fmap Just) [lift a, lift b, lift c] + +-- | @since 2.16.0.0 +instance (Lift a, Lift b, Lift c, Lift d) + => Lift (# a, b, c, d #) where + liftTyped x = unsafeTExpCoerce (lift x) + lift (# a, b, c, d #) + = liftM UnboxedTupE $ sequence $ map (fmap Just) [ lift a, lift b + , lift c, lift d ] + +-- | @since 2.16.0.0 +instance (Lift a, Lift b, Lift c, Lift d, Lift e) + => Lift (# a, b, c, d, e #) where + liftTyped x = unsafeTExpCoerce (lift x) + lift (# a, b, c, d, e #) + = liftM UnboxedTupE $ sequence $ map (fmap Just) [ lift a, lift b + , lift c, lift d, lift e ] + +-- | @since 2.16.0.0 +instance (Lift a, Lift b, Lift c, Lift d, Lift e, Lift f) + => Lift (# a, b, c, d, e, f #) where + liftTyped x = unsafeTExpCoerce (lift x) + lift (# a, b, c, d, e, f #) + = liftM UnboxedTupE $ sequence $ map (fmap Just) [ lift a, lift b, lift c + , lift d, lift e, lift f ] + +-- | @since 2.16.0.0 +instance (Lift a, Lift b, Lift c, Lift d, Lift e, Lift f, Lift g) + => Lift (# a, b, c, d, e, f, g #) where + liftTyped x = unsafeTExpCoerce (lift x) + lift (# a, b, c, d, e, f, g #) + = liftM UnboxedTupE $ sequence $ map (fmap Just) [ lift a, lift b, lift c + , lift d, lift e, lift f + , lift g ] + +-- | @since 2.16.0.0 +instance (Lift a, Lift b) => Lift (# a | b #) where + liftTyped x = unsafeTExpCoerce (lift x) + lift x + = case x of + (# y | #) -> UnboxedSumE <$> lift y <*> pure 1 <*> pure 2 + (# | y #) -> UnboxedSumE <$> lift y <*> pure 2 <*> pure 2 + +-- | @since 2.16.0.0 +instance (Lift a, Lift b, Lift c) + => Lift (# a | b | c #) where + liftTyped x = unsafeTExpCoerce (lift x) + lift x + = case x of + (# y | | #) -> UnboxedSumE <$> lift y <*> pure 1 <*> pure 3 + (# | y | #) -> UnboxedSumE <$> lift y <*> pure 2 <*> pure 3 + (# | | y #) -> UnboxedSumE <$> lift y <*> pure 3 <*> pure 3 + +-- | @since 2.16.0.0 +instance (Lift a, Lift b, Lift c, Lift d) + => Lift (# a | b | c | d #) where + liftTyped x = unsafeTExpCoerce (lift x) + lift x + = case x of + (# y | | | #) -> UnboxedSumE <$> lift y <*> pure 1 <*> pure 4 + (# | y | | #) -> UnboxedSumE <$> lift y <*> pure 2 <*> pure 4 + (# | | y | #) -> UnboxedSumE <$> lift y <*> pure 3 <*> pure 4 + (# | | | y #) -> UnboxedSumE <$> lift y <*> pure 4 <*> pure 4 + +-- | @since 2.16.0.0 +instance (Lift a, Lift b, Lift c, Lift d, Lift e) + => Lift (# a | b | c | d | e #) where + liftTyped x = unsafeTExpCoerce (lift x) + lift x + = case x of + (# y | | | | #) -> UnboxedSumE <$> lift y <*> pure 1 <*> pure 5 + (# | y | | | #) -> UnboxedSumE <$> lift y <*> pure 2 <*> pure 5 + (# | | y | | #) -> UnboxedSumE <$> lift y <*> pure 3 <*> pure 5 + (# | | | y | #) -> UnboxedSumE <$> lift y <*> pure 4 <*> pure 5 + (# | | | | y #) -> UnboxedSumE <$> lift y <*> pure 5 <*> pure 5 + +-- | @since 2.16.0.0 +instance (Lift a, Lift b, Lift c, Lift d, Lift e, Lift f) + => Lift (# a | b | c | d | e | f #) where + liftTyped x = unsafeTExpCoerce (lift x) + lift x + = case x of + (# y | | | | | #) -> UnboxedSumE <$> lift y <*> pure 1 <*> pure 6 + (# | y | | | | #) -> UnboxedSumE <$> lift y <*> pure 2 <*> pure 6 + (# | | y | | | #) -> UnboxedSumE <$> lift y <*> pure 3 <*> pure 6 + (# | | | y | | #) -> UnboxedSumE <$> lift y <*> pure 4 <*> pure 6 + (# | | | | y | #) -> UnboxedSumE <$> lift y <*> pure 5 <*> pure 6 + (# | | | | | y #) -> UnboxedSumE <$> lift y <*> pure 6 <*> pure 6 + +-- | @since 2.16.0.0 +instance (Lift a, Lift b, Lift c, Lift d, Lift e, Lift f, Lift g) + => Lift (# a | b | c | d | e | f | g #) where + liftTyped x = unsafeTExpCoerce (lift x) + lift x + = case x of + (# y | | | | | | #) -> UnboxedSumE <$> lift y <*> pure 1 <*> pure 7 + (# | y | | | | | #) -> UnboxedSumE <$> lift y <*> pure 2 <*> pure 7 + (# | | y | | | | #) -> UnboxedSumE <$> lift y <*> pure 3 <*> pure 7 + (# | | | y | | | #) -> UnboxedSumE <$> lift y <*> pure 4 <*> pure 7 + (# | | | | y | | #) -> UnboxedSumE <$> lift y <*> pure 5 <*> pure 7 + (# | | | | | y | #) -> UnboxedSumE <$> lift y <*> pure 6 <*> pure 7 + (# | | | | | | y #) -> UnboxedSumE <$> lift y <*> pure 7 <*> pure 7 + -- TH has a special form for literal strings, -- which we should take advantage of. -- NB: the lhs of the rule has no args, so that @@ -861,12 +1129,12 @@ * In such a case, we must take care to build the Name using mkNameG_v (for values), not mkNameG_d (for data constructors). - See Trac #10796. + See #10796. * The pseudo-constructor is named only by its string, here "pack". But 'dataToQa' needs the TyCon of its defining module, and has to assume it's defined in the same module as the TyCon itself. - But nothing enforces that; Trac #12596 shows what goes wrong if + But nothing enforces that; #12596 shows what goes wrong if "pack" is defined in a different module than the data type "Text". -} @@ -882,7 +1150,7 @@ where -- Make sure that VarE is used if the Constr value relies on a -- function underneath the surface (instead of a constructor). - -- See Trac #10796. + -- See #10796. varOrConE s = case nameSpace s of Just VarName -> return (VarE s) @@ -1050,8 +1318,8 @@ data NameFlavour = NameS -- ^ An unqualified name; dynamically bound | NameQ ModName -- ^ A qualified name; dynamically bound - | NameU !Int -- ^ A unique local name - | NameL !Int -- ^ Local name bound outside of the TH AST + | NameU !Uniq -- ^ A unique local name + | NameL !Uniq -- ^ Local name bound outside of the TH AST | NameG NameSpace PkgName ModName -- ^ Global name bound outside of the TH AST: -- An original name (occurrences only, not binders) -- Need the namespace too to be sure which @@ -1064,7 +1332,8 @@ -- in the same name space for now. deriving( Eq, Ord, Show, Data, Generic ) -type Uniq = Int +-- | @Uniq@ is used by GHC to distinguish names from each other. +type Uniq = Integer -- | The name without its module prefix. -- @@ -1175,7 +1444,7 @@ -- mkName "&." = Name "&." NameS -- The 'is_rev_mod' guards ensure that -- mkName ".&" = Name ".&" NameS - -- mkName "^.." = Name "^.." NameS -- Trac #8633 + -- mkName "^.." = Name "^.." NameS -- #8633 -- mkName "Data.Bits..&" = Name ".&" (NameQ "Data.Bits") -- This rather bizarre case actually happened; (.&.) is in Data.Bits split occ (c:rev) = split (c:occ) rev @@ -1265,20 +1534,8 @@ -- | Tuple type constructor tupleTypeName :: Int -> Name -tupleDataName 0 = mk_tup_name 0 DataName -tupleDataName 1 = error "tupleDataName 1" -tupleDataName n = mk_tup_name (n-1) DataName - -tupleTypeName 0 = mk_tup_name 0 TcClsName -tupleTypeName 1 = error "tupleTypeName 1" -tupleTypeName n = mk_tup_name (n-1) TcClsName - -mk_tup_name :: Int -> NameSpace -> Name -mk_tup_name n_commas space - = Name occ (NameG space (mkPkgName "ghc-prim") tup_mod) - where - occ = mkOccName ('(' : replicate n_commas ',' ++ ")") - tup_mod = mkModName "GHC.Tuple" +tupleDataName n = mk_tup_name n DataName True +tupleTypeName n = mk_tup_name n TcClsName True -- Unboxed tuple data and type constructors -- | Unboxed tuple data constructor @@ -1286,15 +1543,18 @@ -- | Unboxed tuple type constructor unboxedTupleTypeName :: Int -> Name -unboxedTupleDataName n = mk_unboxed_tup_name n DataName -unboxedTupleTypeName n = mk_unboxed_tup_name n TcClsName +unboxedTupleDataName n = mk_tup_name n DataName False +unboxedTupleTypeName n = mk_tup_name n TcClsName False -mk_unboxed_tup_name :: Int -> NameSpace -> Name -mk_unboxed_tup_name n space +mk_tup_name :: Int -> NameSpace -> Bool -> Name +mk_tup_name n space boxed = Name (mkOccName tup_occ) (NameG space (mkPkgName "ghc-prim") tup_mod) where - tup_occ | n == 1 = "Unit#" -- See Note [One-tuples] in TysWiredIn - | otherwise = "(#" ++ replicate n_commas ',' ++ "#)" + withParens thing + | boxed = "(" ++ thing ++ ")" + | otherwise = "(#" ++ thing ++ "#)" + tup_occ | n == 1 = if boxed then "Unit" else "Unit#" + | otherwise = withParens (replicate n_commas ',') n_commas = n - 1 tup_mod = mkModName "GHC.Tuple" @@ -1568,7 +1828,8 @@ | WordPrimL Integer | FloatPrimL Rational | DoublePrimL Rational - | StringPrimL [Word8] -- ^ A primitive C-style string, type Addr# + | StringPrimL [Word8] -- ^ A primitive C-style string, type 'Addr#' + | BytesPrimL Bytes -- ^ Some raw bytes, type 'Addr#': | CharPrimL Char deriving( Show, Eq, Ord, Data, Generic ) @@ -1576,6 +1837,24 @@ -- but that could complicate the -- supposedly-simple TH.Syntax literal type +-- | Raw bytes embedded into the binary. +-- +-- Avoid using Bytes constructor directly as it is likely to change in the +-- future. Use helpers such as `mkBytes` in Language.Haskell.TH.Lib instead. +data Bytes = Bytes + { bytesPtr :: ForeignPtr Word8 -- ^ Pointer to the data + , bytesOffset :: Word -- ^ Offset from the pointer + , bytesSize :: Word -- ^ Number of bytes + -- Maybe someday: + -- , bytesAlignement :: Word -- ^ Alignement constraint + -- , bytesReadOnly :: Bool -- ^ Shall we embed into a read-only + -- -- section or not + -- , bytesInitialized :: Bool -- ^ False: only use `bytesSize` to allocate + -- -- an uninitialized region + } + deriving (Eq,Ord,Data,Generic,Show) + + -- | Pattern in Haskell given in @{}@ data Pat = LitP Lit -- ^ @{ 5 or \'c\' }@ @@ -1618,11 +1897,15 @@ | InfixE (Maybe Exp) Exp (Maybe Exp) -- ^ @{x + y} or {(x+)} or {(+ x)} or {(+)}@ - -- It's a bit gruesome to use an Exp as the - -- operator, but how else can we distinguish - -- constructors from non-constructors? - -- Maybe there should be a var-or-con type? - -- Or maybe we should leave it to the String itself? + -- It's a bit gruesome to use an Exp as the operator when a Name + -- would suffice. Historically, Exp was used to make it easier to + -- distinguish between infix constructors and non-constructors. + -- This is a bit overkill, since one could just as well call + -- `startsConId` or `startsConSym` (from `GHC.Lexeme`) on a Name. + -- Unfortunately, changing this design now would involve lots of + -- code churn for consumers of the TH API, so we continue to use + -- an Exp as the operator and perform an extra check during conversion + -- to ensure that the Exp is a constructor or a variable (#16895). | UInfixE Exp Exp Exp -- ^ @{x + y}@ -- @@ -1632,8 +1915,28 @@ -- See "Language.Haskell.TH.Syntax#infix" | LamE [Pat] Exp -- ^ @{ \\ p1 p2 -> e }@ | LamCaseE [Match] -- ^ @{ \\case m1; m2 }@ - | TupE [Exp] -- ^ @{ (e1,e2) } @ - | UnboxedTupE [Exp] -- ^ @{ (\# e1,e2 \#) } @ + | TupE [Maybe Exp] -- ^ @{ (e1,e2) } @ + -- + -- The 'Maybe' is necessary for handling + -- tuple sections. + -- + -- > (1,) + -- + -- translates to + -- + -- > TupE [Just (LitE (IntegerL 1)),Nothing] + + | UnboxedTupE [Maybe Exp] -- ^ @{ (\# e1,e2 \#) } @ + -- + -- The 'Maybe' is necessary for handling + -- tuple sections. + -- + -- > (# 'c', #) + -- + -- translates to + -- + -- > UnboxedTupE [Just (LitE (CharL 'c')),Nothing] + | UnboxedSumE Exp SumAlt SumArity -- ^ @{ (\#|e|\#) }@ | CondE Exp Exp Exp -- ^ @{ if e1 then e2 else e3 }@ | MultiIfE [(Guard, Exp)] -- ^ @{ if | g1 -> e1 | g2 -> e2 }@ @@ -1717,6 +2020,7 @@ -- ^ @{ instance {\-\# OVERLAPS \#-\} -- Show w => Show [w] where ds }@ | SigD Name Type -- ^ @{ length :: [a] -> Int }@ + | KiSigD Name Kind -- ^ @{ type TypeRep :: k -> Type }@ | ForeignD Foreign -- ^ @{ foreign import ... } --{ foreign export ... }@ @@ -2049,6 +2353,7 @@ deriving( Show, Eq, Ord, Data, Generic ) data Type = ForallT [TyVarBndr] Cxt Type -- ^ @forall \. \ => \@ + | ForallVisT [TyVarBndr] Type -- ^ @forall \ -> \@ | AppT Type Type -- ^ @T a b@ | AppKindT Type Kind -- ^ @T \@k t@ | SigT Type Kind -- ^ @t :: k@ diff --git a/Setup.hs b/Setup.hs --- a/Setup.hs +++ b/Setup.hs @@ -1,4 +1,6 @@ module Main (main) where + import Distribution.Simple + main :: IO () main = defaultMain diff --git a/changelog.md b/changelog.md --- a/changelog.md +++ b/changelog.md @@ -1,7 +1,33 @@ # Changelog for [`template-haskell` package](http://hackage.haskell.org/package/template-haskell) -## 2.15.0.0 *May 2019 +## 2.16.0.0 *Jan 2020* + * Bundled with GHC 8.10.1 + + * Add support for tuple sections. (#15843) The type signatures of `TupE` and + `UnboxedTupE` have changed from `[Exp] -> Exp` to `[Maybe Exp] -> Exp`. + The type signatures of `tupE` and `unboxedTupE` remain the same for + backwards compatibility. + + * Introduce a `liftTyped` method to the `Lift` class and set the default + implementations of `lift` in terms of `liftTyped`. + + * Add a `ForallVisT` constructor to `Type` to represent visible, dependent + quantification. + + * Introduce support for `Bytes` literals (raw bytes embedded into the output + binary) + + * Make the `Lift` typeclass levity-polymorphic and add instances for unboxed + tuples, unboxed sums, `Int#`, `Word#`, `Addr#`, `Float#`, and `Double#`. + + * Introduce `reifyType` to reify the type or kind of a thing referenced by + `Name`. + +## 2.15.0.0 *May 2019* + + * Bundled with GHC 8.8.1 + * In `Language.Haskell.TH.Syntax`, `DataInstD`, `NewTypeInstD`, `TySynEqn`, and `RuleP` now all have a `Maybe [TyVarBndr]` argument, which contains a list of quantified type variables if an explicit `forall` is present, and @@ -22,7 +48,9 @@ * `addForeignFilePath` now support assembler sources (#16180). -## 2.14.0.0 *September 2018 +## 2.14.0.0 *September 2018* + + * Bundled with GHC 8.6.1 * Introduce an `addForeignFilePath` function, as well as a corresponding `qAddForeignFile` class method to `Quasi`. Unlike `addForeignFile`, which diff --git a/template-haskell.cabal b/template-haskell.cabal --- a/template-haskell.cabal +++ b/template-haskell.cabal @@ -1,14 +1,15 @@ +cabal-version: >=1.10 name: template-haskell -version: 2.15.0.0 +version: 2.16.0.0 + -- NOTE: Don't forget to update ./changelog.md license: BSD3 license-file: LICENSE category: Template Haskell maintainer: libraries@haskell.org -bug-reports: https://gitlab.haskell.org/ghc/ghc/issues +bug-reports: https://gitlab.haskell.org/ghc/ghc/issues/new synopsis: Support library for Template Haskell build-type: Simple -Cabal-Version: >= 1.10 description: This package provides modules containing facilities for manipulating Haskell source code using Template Haskell. @@ -51,8 +52,9 @@ Language.Haskell.TH.Lib.Map build-depends: - base >= 4.11 && < 4.14, - ghc-boot-th == 8.8.*, + base >= 4.11 && < 4.15, + ghc-boot-th == 8.10.1, + ghc-prim, pretty == 1.1.* ghc-options: -Wall