Language.Haskell.TH.Syntax

Abstract syntax definitions for Template Haskell.

Documentation

class MonadFail m => Quasi m where

Minimal complete definition

qNewName, qReport, qRecover, qLookupName, qReify, qReifyFixity, qReifyInstances, qReifyRoles, qReifyAnnotations, qReifyModule, qReifyConStrictness, qLocation, qRunIO, qAddDependentFile, qAddTopDecls, qAddModFinalizer, qGetQ, qPutQ, qIsExtEnabled, qExtsEnabled

Methods

qNewName :: String -> m Name

qReport :: Bool -> String -> m ()

qRecover :: m a -> m a -> m a

qLookupName :: Bool -> String -> m (Maybe Name)

qReify :: Name -> m Info

qReifyFixity :: Name -> m (Maybe Fixity)

qReifyInstances :: Name -> [Type] -> m [Dec]

qReifyRoles :: Name -> m [Role]

qReifyAnnotations :: Data a => AnnLookup -> m [a]

qReifyModule :: Module -> m ModuleInfo

qReifyConStrictness :: Name -> m [DecidedStrictness]

qLocation :: m Loc

qRunIO :: IO a -> m a

Input/output (dangerous)

qAddDependentFile :: FilePath -> m ()

qAddTopDecls :: [Dec] -> m ()

qAddModFinalizer :: Q () -> m ()

qGetQ :: Typeable a => m (Maybe a)

qPutQ :: Typeable a => a -> m ()

qIsExtEnabled :: Extension -> m Bool

qExtsEnabled :: m [Extension]

Instances

Quasi IO

Methods

qNewName :: String -> IO Name

qReport :: Bool -> String -> IO ()

qRecover :: IO a -> IO a -> IO a

qLookupName :: Bool -> String -> IO (Maybe Name)

qReify :: Name -> IO Info

qReifyFixity :: Name -> IO (Maybe Fixity)

qReifyInstances :: Name -> [Type] -> IO [Dec]

qReifyRoles :: Name -> IO [Role]

qReifyAnnotations :: Data a => AnnLookup -> IO [a]

qReifyModule :: Module -> IO ModuleInfo

qReifyConStrictness :: Name -> IO [DecidedStrictness]

qLocation :: IO Loc

qRunIO :: IO a -> IO a

qAddDependentFile :: FilePath -> IO ()

qAddTopDecls :: [Dec] -> IO ()

qAddModFinalizer :: Q () -> IO ()

qGetQ :: Typeable * a => IO (Maybe a)

qPutQ :: Typeable * a => a -> IO ()

qIsExtEnabled :: Extension -> IO Bool

qExtsEnabled :: IO [Extension]

Quasi Q

Methods

qNewName :: String -> Q Name

qReport :: Bool -> String -> Q ()

qRecover :: Q a -> Q a -> Q a

qLookupName :: Bool -> String -> Q (Maybe Name)

qReify :: Name -> Q Info

qReifyFixity :: Name -> Q (Maybe Fixity)

qReifyInstances :: Name -> [Type] -> Q [Dec]

qReifyRoles :: Name -> Q [Role]

qReifyAnnotations :: Data a => AnnLookup -> Q [a]

qReifyModule :: Module -> Q ModuleInfo

qReifyConStrictness :: Name -> Q [DecidedStrictness]

qLocation :: Q Loc

qRunIO :: IO a -> Q a

qAddDependentFile :: FilePath -> Q ()

qAddTopDecls :: [Dec] -> Q ()

qAddModFinalizer :: Q () -> Q ()

qGetQ :: Typeable * a => Q (Maybe a)

qPutQ :: Typeable * a => a -> Q ()

qIsExtEnabled :: Extension -> Q Bool

qExtsEnabled :: Q [Extension]

badIO :: String -> IO a

counter :: IORef Int

newtype Q a

Constructors

Q

Fields

• unQ :: forall m. Quasi m => m a

Instances

Monad Q

Methods

(>>=) :: Q a -> (a -> Q b) -> Q b

(>>) :: Q a -> Q b -> Q b

return :: a -> Q a

fail :: String -> Q a

Functor Q

Methods

fmap :: (a -> b) -> Q a -> Q b

(<$) :: a -> Q b -> Q a

MonadFail Q

Methods

fail :: String -> Q a

Applicative Q

Methods

pure :: a -> Q a

(<*>) :: Q (a -> b) -> Q a -> Q b

(*>) :: Q a -> Q b -> Q b

(<*) :: Q a -> Q b -> Q a

Quasi Q

Methods

qNewName :: String -> Q Name

qReport :: Bool -> String -> Q ()

qRecover :: Q a -> Q a -> Q a

qLookupName :: Bool -> String -> Q (Maybe Name)

qReify :: Name -> Q Info

qReifyFixity :: Name -> Q (Maybe Fixity)

qReifyInstances :: Name -> [Type] -> Q [Dec]

qReifyRoles :: Name -> Q [Role]

qReifyAnnotations :: Data a => AnnLookup -> Q [a]

qReifyModule :: Module -> Q ModuleInfo

qReifyConStrictness :: Name -> Q [DecidedStrictness]

qLocation :: Q Loc

qRunIO :: IO a -> Q a

qAddDependentFile :: FilePath -> Q ()

qAddTopDecls :: [Dec] -> Q ()

qAddModFinalizer :: Q () -> Q ()

qGetQ :: Typeable * a => Q (Maybe a)

qPutQ :: Typeable * a => a -> Q ()

qIsExtEnabled :: Extension -> Q Bool

qExtsEnabled :: Q [Extension]

runQ :: Quasi m => Q a -> m a

newtype TExp a

Constructors

TExp

Fields

• unType :: Exp

unTypeQ :: Q (TExp a) -> Q Exp

unsafeTExpCoerce :: Q Exp -> Q (TExp a)

newName :: String -> Q Name

Generate a fresh name, which cannot be captured.

For example, this:

f = $(do
  nm1 <- newName "x"
  let nm2 = mkName "x"
  return (LamE [VarP nm1] (LamE [VarP nm2] (VarE nm1)))
 )

will produce the splice

f = \x0 -> \x -> x0

In particular, the occurrence VarE nm1 refers to the binding VarP nm1, and is not captured by the binding VarP nm2.

Although names generated by newName cannot be captured, they can capture other names. For example, this:

g = $(do
  nm1 <- newName "x"
  let nm2 = mkName "x"
  return (LamE [VarP nm2] (LamE [VarP nm1] (VarE nm2)))
 )

will produce the splice

g = \x -> \x0 -> x0

since the occurrence VarE nm2 is captured by the innermost binding of x, namely VarP nm1.

report :: Bool -> String -> Q ()

Deprecated: Use reportError or reportWarning instead

Report an error (True) or warning (False), but carry on; use fail to stop.

reportError :: String -> Q ()

Report an error to the user, but allow the current splice's computation to carry on. To abort the computation, use fail.

reportWarning :: String -> Q ()

Report a warning to the user, and carry on.

recover

Arguments

:: Q a

handler to invoke on failure

-> Q a

computation to run

-> Q a

Recover from errors raised by reportError or fail.

lookupName :: Bool -> String -> Q (Maybe Name)

lookupTypeName :: String -> Q (Maybe Name)

Look up the given name in the (type namespace of the) current splice's scope. See Language.Haskell.TH.Syntax for more details.

lookupValueName :: String -> Q (Maybe Name)

Look up the given name in the (value namespace of the) current splice's scope. See Language.Haskell.TH.Syntax for more details.

The functions lookupTypeName and lookupValueName provide a way to query the current splice's context for what names are in scope. The function lookupTypeName queries the type namespace, whereas lookupValueName queries the value namespace, but the functions are otherwise identical.

A call lookupValueName s will check if there is a value with name s in scope at the current splice's location. If there is, the Name of this value is returned; if not, then Nothing is returned.

The returned name cannot be "captured". For example:

f = "global"
g = $( do
         Just nm <- lookupValueName "f"
         [| let f = "local" in $( varE nm ) |]

In this case, g = "global"; the call to lookupValueName returned the global f, and this name was not captured by the local definition of f.

The lookup is performed in the context of the top-level splice being run. For example:

f = "global"
g = $( [| let f = "local" in
           $(do
               Just nm <- lookupValueName "f"
               varE nm
            ) |] )

Again in this example, g = "global", because the call to lookupValueName queries the context of the outer-most $(...).

Operators should be queried without any surrounding parentheses, like so:

lookupValueName "+"

Qualified names are also supported, like so:

lookupValueName "Prelude.+"
lookupValueName "Prelude.map"

reify :: Name -> Q Info

reify looks up information about the Name.

It is sometimes useful to construct the argument name using lookupTypeName or lookupValueName to ensure that we are reifying from the right namespace. For instance, in this context:

data D = D

which D does reify (mkName "D") return information about? (Answer: D-the-type, but don't rely on it.) To ensure we get information about D-the-value, use lookupValueName:

do
  Just nm <- lookupValueName "D"
  reify nm

and to get information about D-the-type, use lookupTypeName.

reifyFixity :: Name -> Q (Maybe Fixity)

reifyFixity nm attempts to find a fixity declaration for nm. For example, if the function foo has the fixity declaration infixr 7 foo, then reifyFixity 'foo would return Just (Fixity 7 InfixR). If the function bar does not have a fixity declaration, then reifyFixity 'bar returns Nothing, so you may assume bar has defaultFixity.

reifyInstances :: Name -> [Type] -> Q [InstanceDec]

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, all instances of this family at the types tys are returned.

reifyRoles :: Name -> Q [Role]

reifyRoles nm returns the list of roles associated with the parameters of the tycon nm. Fails if nm cannot be found or is not a tycon. The returned list should never contain InferR.

reifyAnnotations :: Data a => AnnLookup -> Q [a]

reifyAnnotations target returns the list of annotations associated with target. Only the annotations that are appropriately typed is returned. So if you have Int and String annotations for the same target, you have to call this function twice.

reifyModule :: Module -> Q ModuleInfo

reifyModule mod looks up information about module mod. To look up the current module, call this function with the return value of thisModule.

reifyConStrictness :: Name -> Q [DecidedStrictness]

reifyConStrictness nm looks up the strictness information for the fields of the constructor with the name nm. Note that the strictness information that reifyConStrictness returns may not correspond to what is written in the source code. For example, in the following data declaration:

data Pair a = Pair a a

reifyConStrictness would return [DecidedLazy, DecidedLazy] under most circumstances, but it would return [DecidedStrict, DecidedStrict] if the -XStrictData language extension was enabled.

isInstance :: Name -> [Type] -> Q Bool

Is the list of instances returned by reifyInstances nonempty?

location :: Q Loc

The location at which this computation is spliced.

runIO :: IO a -> Q a

The runIO function lets you run an I/O computation in the Q monad. Take care: you are guaranteed the ordering of calls to runIO within a single Q computation, but not about the order in which splices are run.

Note: for various murky reasons, stdout and stderr handles are not necessarily flushed when the compiler finishes running, so you should flush them yourself.

addDependentFile :: FilePath -> Q ()

Record external files that runIO is using (dependent upon). The compiler can then recognize that it should re-compile the Haskell file when an external file changes.

Expects an absolute file path.

Notes:

• ghc -M does not know about these dependencies - it does not execute TH.
• The dependency is based on file content, not a modification time

addTopDecls :: [Dec] -> Q ()

Add additional top-level declarations. The added declarations will be type checked along with the current declaration group.

addModFinalizer :: Q () -> Q ()

Add a finalizer that will run in the Q monad after the current module has been type checked. This only makes sense when run within a top-level splice.

The finalizer is given the local type environment at the splice point. Thus reify is able to find the local definitions when executed inside the finalizer.

getQ :: Typeable a => Q (Maybe a)

Get state from the Q monad. Note that the state is local to the Haskell module in which the Template Haskell expression is executed.

putQ :: Typeable a => a -> Q ()

Replace the state in the Q monad. Note that the state is local to the Haskell module in which the Template Haskell expression is executed.

isExtEnabled :: Extension -> Q Bool

Determine whether the given language extension is enabled in the Q monad.

extsEnabled :: Q [Extension]

List all enabled language extensions.

returnQ :: a -> Q a

bindQ :: Q a -> (a -> Q b) -> Q b

sequenceQ :: [Q a] -> Q [a]

class Lift t where

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:

add1 :: Int -> Q Exp
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.

Lift instances can be derived automatically by use of the -XDeriveLift GHC language extension:

{-# LANGUAGE DeriveLift #-}
module Foo where

import Language.Haskell.TH.Syntax

data Bar a = Bar1 a (Bar a) | Bar2 String
  deriving Lift

Methods

lift :: t -> Q Exp

Turn a value into a Template Haskell expression, suitable for use in a splice.

lift :: Data t => t -> Q Exp

Turn a value into a Template Haskell expression, suitable for use in a splice.

Instances

Lift Bool

Methods

lift :: Bool -> Q Exp

Lift Char

Methods

lift :: Char -> Q Exp

Lift Double

Methods

lift :: Double -> Q Exp

Lift Float

Methods

lift :: Float -> Q Exp

Lift Int

Methods

lift :: Int -> Q Exp

Lift Int8

Methods

lift :: Int8 -> Q Exp

Lift Int16

Methods

lift :: Int16 -> Q Exp

Lift Int32

Methods

lift :: Int32 -> Q Exp

Lift Int64

Methods

lift :: Int64 -> Q Exp

Lift Integer

Methods

lift :: Integer -> Q Exp

Lift Word

Methods

lift :: Word -> Q Exp

Lift Word8

Methods

lift :: Word8 -> Q Exp

Lift Word16

Methods

lift :: Word16 -> Q Exp

Lift Word32

Methods

lift :: Word32 -> Q Exp

Lift Word64

Methods

lift :: Word64 -> Q Exp

Lift ()

Methods

lift :: () -> Q Exp

Lift Natural

Methods

lift :: Natural -> Q Exp

Lift a => Lift [a]

Methods

lift :: [a] -> Q Exp

Lift a => Lift (Maybe a)

Methods

lift :: Maybe a -> Q Exp

Integral a => Lift (Ratio a)

Methods

lift :: Ratio a -> Q Exp

(Lift a, Lift b) => Lift (Either a b)

Methods

lift :: Either a b -> Q Exp

(Lift a, Lift b) => Lift (a, b)

Methods

lift :: (a, b) -> Q Exp

(Lift a, Lift b, Lift c) => Lift (a, b, c)

Methods

lift :: (a, b, c) -> Q Exp

(Lift a, Lift b, Lift c, Lift d) => Lift (a, b, c, d)

Methods

lift :: (a, b, c, d) -> Q Exp

(Lift a, Lift b, Lift c, Lift d, Lift e) => Lift (a, b, c, d, e)

Methods

lift :: (a, b, c, d, e) -> Q Exp

(Lift a, Lift b, Lift c, Lift d, Lift e, Lift f) => Lift (a, b, c, d, e, f)

Methods

lift :: (a, b, c, d, e, f) -> Q Exp

(Lift a, Lift b, Lift c, Lift d, Lift e, Lift f, Lift g) => Lift (a, b, c, d, e, f, g)

Methods

lift :: (a, b, c, d, e, f, g) -> Q Exp

liftString :: String -> Q Exp

trueName :: Name

falseName :: Name

nothingName :: Name

justName :: Name

leftName :: Name

rightName :: Name

dataToQa :: forall a k q. Data a => (Name -> k) -> (Lit -> Q q) -> (k -> [Q q] -> Q q) -> (forall b. Data b => b -> Maybe (Q q)) -> a -> Q q

dataToQa is an internal utility function for constructing generic conversion functions from types with Data instances to various quasi-quoting representations. See the source of dataToExpQ and dataToPatQ for two example usages: mkCon, mkLit and appQ are overloadable to account for different syntax for expressions and patterns; antiQ allows you to override type-specific cases, a common usage is just const Nothing, which results in no overloading.

dataToExpQ :: Data a => (forall b. Data b => b -> Maybe (Q Exp)) -> a -> Q Exp

dataToExpQ converts a value to a 'Q Exp' representation of the same value, in the SYB style. It is generalized to take a function override type-specific cases; see liftData for a more commonly used variant.

liftData :: Data a => a -> Q Exp

liftData is a variant of lift in the Lift type class which works for any type with a Data instance.

dataToPatQ :: Data a => (forall b. Data b => b -> Maybe (Q Pat)) -> a -> Q Pat

dataToPatQ converts a value to a 'Q Pat' representation of the same value, in the SYB style. It takes a function to handle type-specific cases, alternatively, pass const Nothing to get default behavior.

newtype ModName

Constructors

ModName String

Instances

Eq ModName

Methods

(==) :: ModName -> ModName -> Bool

(/=) :: ModName -> ModName -> Bool

Data ModName

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ModName -> c ModName

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ModName

toConstr :: ModName -> Constr

dataTypeOf :: ModName -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c ModName)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ModName)

gmapT :: (forall b. Data b => b -> b) -> ModName -> ModName

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ModName -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ModName -> r

gmapQ :: (forall d. Data d => d -> u) -> ModName -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> ModName -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ModName -> m ModName

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ModName -> m ModName

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ModName -> m ModName

Ord ModName

Methods

compare :: ModName -> ModName -> Ordering

(<) :: ModName -> ModName -> Bool

(<=) :: ModName -> ModName -> Bool

(>) :: ModName -> ModName -> Bool

(>=) :: ModName -> ModName -> Bool

max :: ModName -> ModName -> ModName

min :: ModName -> ModName -> ModName

Show ModName

Methods

showsPrec :: Int -> ModName -> ShowS

show :: ModName -> String

showList :: [ModName] -> ShowS

Generic ModName

Associated Types

type Rep ModName :: * -> *

Methods

from :: ModName -> Rep ModName x

to :: Rep ModName x -> ModName

type Rep ModName

type Rep ModName = D1 (MetaData "ModName" "Language.Haskell.TH.Syntax" "template-haskell" True) (C1 (MetaCons "ModName" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String)))

newtype PkgName

Constructors

PkgName String

Instances

Eq PkgName

Methods

(==) :: PkgName -> PkgName -> Bool

(/=) :: PkgName -> PkgName -> Bool

Data PkgName

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PkgName -> c PkgName

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c PkgName

toConstr :: PkgName -> Constr

dataTypeOf :: PkgName -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c PkgName)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PkgName)

gmapT :: (forall b. Data b => b -> b) -> PkgName -> PkgName

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PkgName -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PkgName -> r

gmapQ :: (forall d. Data d => d -> u) -> PkgName -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> PkgName -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> PkgName -> m PkgName

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PkgName -> m PkgName

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PkgName -> m PkgName

Ord PkgName

Methods

compare :: PkgName -> PkgName -> Ordering

(<) :: PkgName -> PkgName -> Bool

(<=) :: PkgName -> PkgName -> Bool

(>) :: PkgName -> PkgName -> Bool

(>=) :: PkgName -> PkgName -> Bool

max :: PkgName -> PkgName -> PkgName

min :: PkgName -> PkgName -> PkgName

Show PkgName

Methods

showsPrec :: Int -> PkgName -> ShowS

show :: PkgName -> String

showList :: [PkgName] -> ShowS

Generic PkgName

Associated Types

type Rep PkgName :: * -> *

Methods

from :: PkgName -> Rep PkgName x

to :: Rep PkgName x -> PkgName

type Rep PkgName

type Rep PkgName = D1 (MetaData "PkgName" "Language.Haskell.TH.Syntax" "template-haskell" True) (C1 (MetaCons "PkgName" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String)))

data Module

Obtained from reifyModule and thisModule.

Constructors

Module PkgName ModName

Instances

Eq Module

Methods

(==) :: Module -> Module -> Bool

(/=) :: Module -> Module -> Bool

Data Module

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Module -> c Module

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Module

toConstr :: Module -> Constr

dataTypeOf :: Module -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Module)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Module)

gmapT :: (forall b. Data b => b -> b) -> Module -> Module

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r

gmapQ :: (forall d. Data d => d -> u) -> Module -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Module -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Module -> m Module

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Module -> m Module

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Module -> m Module

Ord Module

Methods

compare :: Module -> Module -> Ordering

(<) :: Module -> Module -> Bool

(<=) :: Module -> Module -> Bool

(>) :: Module -> Module -> Bool

(>=) :: Module -> Module -> Bool

max :: Module -> Module -> Module

min :: Module -> Module -> Module

Show Module

Methods

showsPrec :: Int -> Module -> ShowS

show :: Module -> String

showList :: [Module] -> ShowS

Generic Module

Associated Types

type Rep Module :: * -> *

Methods

from :: Module -> Rep Module x

to :: Rep Module x -> Module

Ppr Module

Methods

ppr :: Module -> Doc

ppr_list :: [Module] -> Doc

type Rep Module

type Rep Module = D1 (MetaData "Module" "Language.Haskell.TH.Syntax" "template-haskell" False) (C1 (MetaCons "Module" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 PkgName)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ModName))))

newtype OccName

Constructors

OccName String

Instances

Eq OccName

Methods

(==) :: OccName -> OccName -> Bool

(/=) :: OccName -> OccName -> Bool

Data OccName

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> OccName -> c OccName

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c OccName

toConstr :: OccName -> Constr

dataTypeOf :: OccName -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c OccName)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OccName)

gmapT :: (forall b. Data b => b -> b) -> OccName -> OccName

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OccName -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OccName -> r

gmapQ :: (forall d. Data d => d -> u) -> OccName -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> OccName -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> OccName -> m OccName

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> OccName -> m OccName

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> OccName -> m OccName

Ord OccName

Methods

compare :: OccName -> OccName -> Ordering

(<) :: OccName -> OccName -> Bool

(<=) :: OccName -> OccName -> Bool

(>) :: OccName -> OccName -> Bool

(>=) :: OccName -> OccName -> Bool

max :: OccName -> OccName -> OccName

min :: OccName -> OccName -> OccName

Show OccName

Methods

showsPrec :: Int -> OccName -> ShowS

show :: OccName -> String

showList :: [OccName] -> ShowS

Generic OccName

Associated Types

type Rep OccName :: * -> *

Methods

from :: OccName -> Rep OccName x

to :: Rep OccName x -> OccName

type Rep OccName

type Rep OccName = D1 (MetaData "OccName" "Language.Haskell.TH.Syntax" "template-haskell" True) (C1 (MetaCons "OccName" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String)))

mkModName :: String -> ModName

modString :: ModName -> String

mkPkgName :: String -> PkgName

pkgString :: PkgName -> String

mkOccName :: String -> OccName

occString :: OccName -> String

Much of Name API is concerned with the problem of name capture, which can be seen in the following example.

f expr = [| let x = 0 in $expr |]
...
g x = $( f [| x |] )
h y = $( f [| y |] )

A naive desugaring of this would yield:

g x = let x = 0 in x
h y = let x = 0 in y

All of a sudden, g and h have different meanings! In this case, we say that the x in the RHS of g has been captured by the binding of x in f.

What we actually want is for the x in f to be distinct from the x in g, so we get the following desugaring:

g x = let x' = 0 in x
h y = let x' = 0 in y

which avoids name capture as desired.

In the general case, we say that a Name can be captured if the thing it refers to can be changed by adding new declarations.

data Name

An abstract type representing names in the syntax tree.

Names can be constructed in several ways, which come with different name-capture guarantees (see Language.Haskell.TH.Syntax for an explanation of name capture):

• the built-in syntax 'f and ''T can be used to construct names, The expression 'f gives a Name which refers to the value f currently in scope, and ''T gives a Name which refers to the type T currently in scope. These names can never be captured.
• lookupValueName and lookupTypeName are similar to 'f and ''T respectively, but the Names are looked up at the point where the current splice is being run. These names can never be captured.
• newName monadically generates a new name, which can never be captured.
• mkName generates a capturable name.

Names constructed using newName and mkName may be used in bindings (such as let x = ... or x -> ...), but names constructed using lookupValueName, lookupTypeName, 'f, ''T may not.

Constructors

Name OccName NameFlavour

Instances

Eq Name

Methods

(==) :: Name -> Name -> Bool

(/=) :: Name -> Name -> Bool

Data Name

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Name -> c Name

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Name

toConstr :: Name -> Constr

dataTypeOf :: Name -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Name)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Name)

gmapT :: (forall b. Data b => b -> b) -> Name -> Name

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r

gmapQ :: (forall d. Data d => d -> u) -> Name -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Name -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Name -> m Name

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Name -> m Name

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Name -> m Name

Ord Name

Methods

compare :: Name -> Name -> Ordering

(<) :: Name -> Name -> Bool

(<=) :: Name -> Name -> Bool

(>) :: Name -> Name -> Bool

(>=) :: Name -> Name -> Bool

max :: Name -> Name -> Name

min :: Name -> Name -> Name

Show Name

Methods

showsPrec :: Int -> Name -> ShowS

show :: Name -> String

showList :: [Name] -> ShowS

Generic Name

Associated Types

type Rep Name :: * -> *

Methods

from :: Name -> Rep Name x

to :: Rep Name x -> Name

Ppr Name

Methods

ppr :: Name -> Doc

ppr_list :: [Name] -> Doc

type Rep Name

type Rep Name = D1 (MetaData "Name" "Language.Haskell.TH.Syntax" "template-haskell" False) (C1 (MetaCons "Name" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 OccName)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 NameFlavour))))

data NameFlavour

Constructors

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

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 thing we are naming

Instances

Eq NameFlavour

Methods

(==) :: NameFlavour -> NameFlavour -> Bool

(/=) :: NameFlavour -> NameFlavour -> Bool

Data NameFlavour

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NameFlavour -> c NameFlavour

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c NameFlavour

toConstr :: NameFlavour -> Constr

dataTypeOf :: NameFlavour -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c NameFlavour)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NameFlavour)

gmapT :: (forall b. Data b => b -> b) -> NameFlavour -> NameFlavour

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NameFlavour -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NameFlavour -> r

gmapQ :: (forall d. Data d => d -> u) -> NameFlavour -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> NameFlavour -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> NameFlavour -> m NameFlavour

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NameFlavour -> m NameFlavour

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NameFlavour -> m NameFlavour

Ord NameFlavour

Methods

compare :: NameFlavour -> NameFlavour -> Ordering

(<) :: NameFlavour -> NameFlavour -> Bool

(<=) :: NameFlavour -> NameFlavour -> Bool

(>) :: NameFlavour -> NameFlavour -> Bool

(>=) :: NameFlavour -> NameFlavour -> Bool

max :: NameFlavour -> NameFlavour -> NameFlavour

min :: NameFlavour -> NameFlavour -> NameFlavour

Show NameFlavour

Methods

showsPrec :: Int -> NameFlavour -> ShowS

show :: NameFlavour -> String

showList :: [NameFlavour] -> ShowS

Generic NameFlavour

Associated Types

type Rep NameFlavour :: * -> *

Methods

from :: NameFlavour -> Rep NameFlavour x

to :: Rep NameFlavour x -> NameFlavour

type Rep NameFlavour

type Rep NameFlavour = D1 (MetaData "NameFlavour" "Language.Haskell.TH.Syntax" "template-haskell" False) ((:+:) ((:+:) (C1 (MetaCons "NameS" PrefixI False) U1) (C1 (MetaCons "NameQ" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ModName)))) ((:+:) (C1 (MetaCons "NameU" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedUnpack) (Rec0 Int))) ((:+:) (C1 (MetaCons "NameL" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedUnpack) (Rec0 Int))) (C1 (MetaCons "NameG" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 NameSpace)) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 PkgName)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ModName))))))))

data NameSpace

Constructors

VarName

Variables

DataName

Data constructors

TcClsName

Type constructors and classes; Haskell has them in the same name space for now.

Instances

Eq NameSpace

Methods

(==) :: NameSpace -> NameSpace -> Bool

(/=) :: NameSpace -> NameSpace -> Bool

Data NameSpace

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NameSpace -> c NameSpace

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c NameSpace

toConstr :: NameSpace -> Constr

dataTypeOf :: NameSpace -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c NameSpace)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NameSpace)

gmapT :: (forall b. Data b => b -> b) -> NameSpace -> NameSpace

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NameSpace -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NameSpace -> r

gmapQ :: (forall d. Data d => d -> u) -> NameSpace -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> NameSpace -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> NameSpace -> m NameSpace

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NameSpace -> m NameSpace

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NameSpace -> m NameSpace

Ord NameSpace

Methods

compare :: NameSpace -> NameSpace -> Ordering

(<) :: NameSpace -> NameSpace -> Bool

(<=) :: NameSpace -> NameSpace -> Bool

(>) :: NameSpace -> NameSpace -> Bool

(>=) :: NameSpace -> NameSpace -> Bool

max :: NameSpace -> NameSpace -> NameSpace

min :: NameSpace -> NameSpace -> NameSpace

Show NameSpace

Methods

showsPrec :: Int -> NameSpace -> ShowS

show :: NameSpace -> String

showList :: [NameSpace] -> ShowS

Generic NameSpace

Associated Types

type Rep NameSpace :: * -> *

Methods

from :: NameSpace -> Rep NameSpace x

to :: Rep NameSpace x -> NameSpace

type Rep NameSpace

type Rep NameSpace = D1 (MetaData "NameSpace" "Language.Haskell.TH.Syntax" "template-haskell" False) ((:+:) (C1 (MetaCons "VarName" PrefixI False) U1) ((:+:) (C1 (MetaCons "DataName" PrefixI False) U1) (C1 (MetaCons "TcClsName" PrefixI False) U1)))

type Uniq = Int

nameBase :: Name -> String

The name without its module prefix.

Examples

>>> nameBase ''Data.Either.Either
"Either"
>>> nameBase (mkName "foo")
"foo"
>>> nameBase (mkName "Module.foo")
"foo"

nameModule :: Name -> Maybe String

Module prefix of a name, if it exists.

Examples

>>> nameModule ''Data.Either.Either
Just "Data.Either"
>>> nameModule (mkName "foo")
Nothing
>>> nameModule (mkName "Module.foo")
Just "Module"

namePackage :: Name -> Maybe String

A name's package, if it exists.

Examples

>>> namePackage ''Data.Either.Either
Just "base"
>>> namePackage (mkName "foo")
Nothing
>>> namePackage (mkName "Module.foo")
Nothing

nameSpace :: Name -> Maybe NameSpace

Returns whether a name represents an occurrence of a top-level variable (VarName), data constructor (DataName), type constructor, or type class (TcClsName). If we can't be sure, it returns Nothing.

Examples

>>> nameSpace 'Prelude.id
Just VarName
>>> nameSpace (mkName "id")
Nothing -- only works for top-level variable names
>>> nameSpace 'Data.Maybe.Just
Just DataName
>>> nameSpace ''Data.Maybe.Maybe
Just TcClsName
>>> nameSpace ''Data.Ord.Ord
Just TcClsName

mkName :: String -> Name

Generate a capturable name. Occurrences of such names will be resolved according to the Haskell scoping rules at the occurrence site.

For example:

f = [| pi + $(varE (mkName "pi")) |]
...
g = let pi = 3 in $f

In this case, g is desugared to

g = Prelude.pi + 3

Note that mkName may be used with qualified names:

mkName "Prelude.pi"

See also dyn for a useful combinator. The above example could be rewritten using dyn as

f = [| pi + $(dyn "pi") |]

mkNameU :: String -> Uniq -> Name

Only used internally

mkNameL :: String -> Uniq -> Name

Only used internally

mkNameG :: NameSpace -> String -> String -> String -> Name

Used for 'x etc, but not available to the programmer

mkNameS :: String -> Name

mkNameG_v :: String -> String -> String -> Name

mkNameG_tc :: String -> String -> String -> Name

mkNameG_d :: String -> String -> String -> Name

data NameIs

Constructors

Alone

Applied

Infix

showName :: Name -> String

showName' :: NameIs -> Name -> String

tupleDataName :: Int -> Name

Tuple data constructor

tupleTypeName :: Int -> Name

Tuple type constructor

mk_tup_name :: Int -> NameSpace -> Name

unboxedTupleDataName :: Int -> Name

Unboxed tuple data constructor

unboxedTupleTypeName :: Int -> Name

Unboxed tuple type constructor

mk_unboxed_tup_name :: Int -> NameSpace -> Name

data Loc

Constructors

Loc

Fields

• loc_filename :: String
• loc_package :: String
• loc_module :: String
• loc_start :: CharPos
• loc_end :: CharPos

Instances

Eq Loc

Methods

(==) :: Loc -> Loc -> Bool

(/=) :: Loc -> Loc -> Bool

Data Loc

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Loc -> c Loc

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Loc

toConstr :: Loc -> Constr

dataTypeOf :: Loc -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Loc)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Loc)

gmapT :: (forall b. Data b => b -> b) -> Loc -> Loc

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Loc -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Loc -> r

gmapQ :: (forall d. Data d => d -> u) -> Loc -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Loc -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Loc -> m Loc

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Loc -> m Loc

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Loc -> m Loc

Ord Loc

Methods

compare :: Loc -> Loc -> Ordering

(<) :: Loc -> Loc -> Bool

(<=) :: Loc -> Loc -> Bool

(>) :: Loc -> Loc -> Bool

(>=) :: Loc -> Loc -> Bool

max :: Loc -> Loc -> Loc

min :: Loc -> Loc -> Loc

Show Loc

Methods

showsPrec :: Int -> Loc -> ShowS

show :: Loc -> String

showList :: [Loc] -> ShowS

Generic Loc

Associated Types

type Rep Loc :: * -> *

Methods

from :: Loc -> Rep Loc x

to :: Rep Loc x -> Loc

Ppr Loc

Methods

ppr :: Loc -> Doc

ppr_list :: [Loc] -> Doc

type Rep Loc

type Rep Loc = D1 (MetaData "Loc" "Language.Haskell.TH.Syntax" "template-haskell" False) (C1 (MetaCons "Loc" PrefixI True) ((:*:) ((:*:) (S1 (MetaSel (Just Symbol "loc_filename") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String)) (S1 (MetaSel (Just Symbol "loc_package") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String))) ((:*:) (S1 (MetaSel (Just Symbol "loc_module") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String)) ((:*:) (S1 (MetaSel (Just Symbol "loc_start") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 CharPos)) (S1 (MetaSel (Just Symbol "loc_end") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 CharPos))))))

type CharPos

Arguments

 = (Int, Int)

Line and character position

data Info

Obtained from reify in the Q Monad.

Constructors

ClassI Dec [InstanceDec]

A class, with a list of its visible instances

ClassOpI Name Type ParentName

A class method

TyConI Dec

A "plain" type constructor. "Fancier" type constructors are returned using PrimTyConI or FamilyI as appropriate

FamilyI Dec [InstanceDec]

A type or data family, with a list of its visible instances. A closed type family is returned with 0 instances.

PrimTyConI Name Arity Unlifted

A "primitive" type constructor, which can't be expressed with a Dec. Examples: (->), Int#.

DataConI Name Type ParentName

A data constructor

VarI Name Type (Maybe Dec)

A "value" variable (as opposed to a type variable, see TyVarI).

The Maybe Dec field contains Just the declaration which defined the variable -- including the RHS of the declaration -- or else Nothing, in the case where the RHS is unavailable to the compiler. At present, this value is _always_ Nothing: returning the RHS has not yet been implemented because of lack of interest.

TyVarI Name Type

A type variable.

The Type field contains the type which underlies the variable. At present, this is always VarT theName, but future changes may permit refinement of this.

Instances

Eq Info

Methods

(==) :: Info -> Info -> Bool

(/=) :: Info -> Info -> Bool

Data Info

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Info -> c Info

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Info

toConstr :: Info -> Constr

dataTypeOf :: Info -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Info)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Info)

gmapT :: (forall b. Data b => b -> b) -> Info -> Info

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Info -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Info -> r

gmapQ :: (forall d. Data d => d -> u) -> Info -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Info -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Info -> m Info

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Info -> m Info

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Info -> m Info

Ord Info

Methods

compare :: Info -> Info -> Ordering

(<) :: Info -> Info -> Bool

(<=) :: Info -> Info -> Bool

(>) :: Info -> Info -> Bool

(>=) :: Info -> Info -> Bool

max :: Info -> Info -> Info

min :: Info -> Info -> Info

Show Info

Methods

showsPrec :: Int -> Info -> ShowS

show :: Info -> String

showList :: [Info] -> ShowS

Generic Info

Associated Types

type Rep Info :: * -> *

Methods

from :: Info -> Rep Info x

to :: Rep Info x -> Info

Ppr Info

Methods

ppr :: Info -> Doc

ppr_list :: [Info] -> Doc

type Rep Info

type Rep Info = D1 (MetaData "Info" "Language.Haskell.TH.Syntax" "template-haskell" False) ((:+:) ((:+:) ((:+:) (C1 (MetaCons "ClassI" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Dec)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [InstanceDec])))) (C1 (MetaCons "ClassOpI" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name)) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Type)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ParentName)))))) ((:+:) (C1 (MetaCons "TyConI" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Dec))) (C1 (MetaCons "FamilyI" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Dec)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [InstanceDec])))))) ((:+:) ((:+:) (C1 (MetaCons "PrimTyConI" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name)) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Arity)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Unlifted))))) (C1 (MetaCons "DataConI" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name)) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Type)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ParentName)))))) ((:+:) (C1 (MetaCons "VarI" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name)) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Type)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe Dec)))))) (C1 (MetaCons "TyVarI" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Type)))))))

data ModuleInfo

Obtained from reifyModule in the Q Monad.

Constructors

ModuleInfo [Module]

Contains the import list of the module.

Instances

Eq ModuleInfo

Methods

(==) :: ModuleInfo -> ModuleInfo -> Bool

(/=) :: ModuleInfo -> ModuleInfo -> Bool

Data ModuleInfo

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ModuleInfo -> c ModuleInfo

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ModuleInfo

toConstr :: ModuleInfo -> Constr

dataTypeOf :: ModuleInfo -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c ModuleInfo)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ModuleInfo)

gmapT :: (forall b. Data b => b -> b) -> ModuleInfo -> ModuleInfo

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ModuleInfo -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ModuleInfo -> r

gmapQ :: (forall d. Data d => d -> u) -> ModuleInfo -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> ModuleInfo -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo

Ord ModuleInfo

Methods

compare :: ModuleInfo -> ModuleInfo -> Ordering

(<) :: ModuleInfo -> ModuleInfo -> Bool

(<=) :: ModuleInfo -> ModuleInfo -> Bool

(>) :: ModuleInfo -> ModuleInfo -> Bool

(>=) :: ModuleInfo -> ModuleInfo -> Bool

max :: ModuleInfo -> ModuleInfo -> ModuleInfo

min :: ModuleInfo -> ModuleInfo -> ModuleInfo

Show ModuleInfo

Methods

showsPrec :: Int -> ModuleInfo -> ShowS

show :: ModuleInfo -> String

showList :: [ModuleInfo] -> ShowS

Generic ModuleInfo

Associated Types

type Rep ModuleInfo :: * -> *

Methods

from :: ModuleInfo -> Rep ModuleInfo x

to :: Rep ModuleInfo x -> ModuleInfo

Ppr ModuleInfo

Methods

ppr :: ModuleInfo -> Doc

ppr_list :: [ModuleInfo] -> Doc

type Rep ModuleInfo

type Rep ModuleInfo = D1 (MetaData "ModuleInfo" "Language.Haskell.TH.Syntax" "template-haskell" False) (C1 (MetaCons "ModuleInfo" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Module])))

type ParentName = Name

In ClassOpI and DataConI, name of the parent class or type

type Arity = Int

In PrimTyConI, arity of the type constructor

type Unlifted = Bool

In PrimTyConI, is the type constructor unlifted?

type InstanceDec = Dec

InstanceDec desribes a single instance of a class or type function. It is just a Dec, but guaranteed to be one of the following:

• InstanceD (with empty [Dec])
• DataInstD or NewtypeInstD (with empty derived [Name])
• TySynInstD

data Fixity

Constructors

Fixity Int FixityDirection

Instances

Eq Fixity

Methods

(==) :: Fixity -> Fixity -> Bool

(/=) :: Fixity -> Fixity -> Bool

Data Fixity

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Fixity -> c Fixity

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Fixity

toConstr :: Fixity -> Constr

dataTypeOf :: Fixity -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Fixity)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Fixity)

gmapT :: (forall b. Data b => b -> b) -> Fixity -> Fixity

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Fixity -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Fixity -> r

gmapQ :: (forall d. Data d => d -> u) -> Fixity -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Fixity -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Fixity -> m Fixity

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Fixity -> m Fixity

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Fixity -> m Fixity

Ord Fixity

Methods

compare :: Fixity -> Fixity -> Ordering

(<) :: Fixity -> Fixity -> Bool

(<=) :: Fixity -> Fixity -> Bool

(>) :: Fixity -> Fixity -> Bool

(>=) :: Fixity -> Fixity -> Bool

max :: Fixity -> Fixity -> Fixity

min :: Fixity -> Fixity -> Fixity

Show Fixity

Methods

showsPrec :: Int -> Fixity -> ShowS

show :: Fixity -> String

showList :: [Fixity] -> ShowS

Generic Fixity

Associated Types

type Rep Fixity :: * -> *

Methods

from :: Fixity -> Rep Fixity x

to :: Rep Fixity x -> Fixity

type Rep Fixity

type Rep Fixity = D1 (MetaData "Fixity" "Language.Haskell.TH.Syntax" "template-haskell" False) (C1 (MetaCons "Fixity" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Int)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 FixityDirection))))

data FixityDirection

Constructors

InfixL

InfixR

InfixN

Instances

Eq FixityDirection

Methods

(==) :: FixityDirection -> FixityDirection -> Bool

(/=) :: FixityDirection -> FixityDirection -> Bool

Data FixityDirection

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FixityDirection -> c FixityDirection

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FixityDirection

toConstr :: FixityDirection -> Constr

dataTypeOf :: FixityDirection -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c FixityDirection)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FixityDirection)

gmapT :: (forall b. Data b => b -> b) -> FixityDirection -> FixityDirection

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FixityDirection -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FixityDirection -> r

gmapQ :: (forall d. Data d => d -> u) -> FixityDirection -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> FixityDirection -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FixityDirection -> m FixityDirection

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FixityDirection -> m FixityDirection

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FixityDirection -> m FixityDirection

Ord FixityDirection

Methods

compare :: FixityDirection -> FixityDirection -> Ordering

(<) :: FixityDirection -> FixityDirection -> Bool

(<=) :: FixityDirection -> FixityDirection -> Bool

(>) :: FixityDirection -> FixityDirection -> Bool

(>=) :: FixityDirection -> FixityDirection -> Bool

max :: FixityDirection -> FixityDirection -> FixityDirection

min :: FixityDirection -> FixityDirection -> FixityDirection

Show FixityDirection

Methods

showsPrec :: Int -> FixityDirection -> ShowS

show :: FixityDirection -> String

showList :: [FixityDirection] -> ShowS

Generic FixityDirection

Associated Types

type Rep FixityDirection :: * -> *

Methods

from :: FixityDirection -> Rep FixityDirection x

to :: Rep FixityDirection x -> FixityDirection

type Rep FixityDirection

type Rep FixityDirection = D1 (MetaData "FixityDirection" "Language.Haskell.TH.Syntax" "template-haskell" False) ((:+:) (C1 (MetaCons "InfixL" PrefixI False) U1) ((:+:) (C1 (MetaCons "InfixR" PrefixI False) U1) (C1 (MetaCons "InfixN" PrefixI False) U1)))

maxPrecedence :: Int

Highest allowed operator precedence for Fixity constructor (answer: 9)

defaultFixity :: Fixity

Default fixity: infixl 9

When implementing antiquotation for quasiquoters, one often wants to parse strings into expressions:

parse :: String -> Maybe Exp

But how should we parse a + b * c? If we don't know the fixities of + and *, we don't know whether to parse it as a + (b * c) or (a + b) * c.

In cases like this, use UInfixE, UInfixP, or UInfixT, which stand for "unresolved infix expressionpatterntype", respectively. When the compiler is given a splice containing a tree of UInfixE applications such as

UInfixE
  (UInfixE e1 op1 e2)
  op2
  (UInfixE e3 op3 e4)

it will look up and the fixities of the relevant operators and reassociate the tree as necessary.

• trees will not be reassociated across ParensE, ParensP, or ParensT, which are of use for parsing expressions like

(a + b * c) + d * e

• InfixE, InfixP, and InfixT expressions are never reassociated.
• The UInfixE constructor doesn't support sections. Sections such as (a *) have no ambiguity, so InfixE suffices. For longer sections such as (a + b * c -), use an InfixE constructor for the outer-most section, and use UInfixE constructors for all other operators:

InfixE
  Just (UInfixE ...a + b * c...)
  op
  Nothing

Sections such as (a + b +) and ((a + b) +) should be rendered into Exps differently:

(+ a + b)   ---> InfixE Nothing + (Just $ UInfixE a + b)
                   -- will result in a fixity error if (+) is left-infix
(+ (a + b)) ---> InfixE Nothing + (Just $ ParensE $ UInfixE a + b)
                   -- no fixity errors

• Quoted expressions such as

[| a * b + c |] :: Q Exp
[p| a : b : c |] :: Q Pat
[t| T + T |] :: Q Type

will never contain UInfixE, UInfixP, UInfixT, InfixT, ParensE, ParensP, or ParensT constructors.

data Lit

Constructors

CharL Char

StringL String

IntegerL Integer

Used for overloaded and non-overloaded literals. We don't have a good way to represent non-overloaded literals at the moment. Maybe that doesn't matter?

RationalL Rational

IntPrimL Integer

WordPrimL Integer

FloatPrimL Rational

DoublePrimL Rational

StringPrimL [Word8]

A primitive C-style string, type Addr#

CharPrimL Char

Instances

Eq Lit

Methods

(==) :: Lit -> Lit -> Bool

(/=) :: Lit -> Lit -> Bool

Data Lit

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Lit -> c Lit

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Lit

toConstr :: Lit -> Constr

dataTypeOf :: Lit -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Lit)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Lit)

gmapT :: (forall b. Data b => b -> b) -> Lit -> Lit

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Lit -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Lit -> r

gmapQ :: (forall d. Data d => d -> u) -> Lit -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Lit -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Lit -> m Lit

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Lit -> m Lit

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Lit -> m Lit

Ord Lit

Methods

compare :: Lit -> Lit -> Ordering

(<) :: Lit -> Lit -> Bool

(<=) :: Lit -> Lit -> Bool

(>) :: Lit -> Lit -> Bool

(>=) :: Lit -> Lit -> Bool

max :: Lit -> Lit -> Lit

min :: Lit -> Lit -> Lit

Show Lit

Methods

showsPrec :: Int -> Lit -> ShowS

show :: Lit -> String

showList :: [Lit] -> ShowS

Generic Lit

Associated Types

type Rep Lit :: * -> *

Methods

from :: Lit -> Rep Lit x

to :: Rep Lit x -> Lit

Ppr Lit

Methods

ppr :: Lit -> Doc

ppr_list :: [Lit] -> Doc

type Rep Lit

type Rep Lit = D1 (MetaData "Lit" "Language.Haskell.TH.Syntax" "template-haskell" False) ((:+:) ((:+:) ((:+:) (C1 (MetaCons "CharL" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Char))) (C1 (MetaCons "StringL" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String)))) ((:+:) (C1 (MetaCons "IntegerL" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Integer))) ((:+:) (C1 (MetaCons "RationalL" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Rational))) (C1 (MetaCons "IntPrimL" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Integer)))))) ((:+:) ((:+:) (C1 (MetaCons "WordPrimL" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Integer))) (C1 (MetaCons "FloatPrimL" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Rational)))) ((:+:) (C1 (MetaCons "DoublePrimL" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Rational))) ((:+:) (C1 (MetaCons "StringPrimL" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Word8]))) (C1 (MetaCons "CharPrimL" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Char)))))))

data Pat

Pattern in Haskell given in {}

Constructors

LitP Lit

{ 5 or 'c' }

VarP Name

{ x }

TupP [Pat]

{ (p1,p2) }

UnboxedTupP [Pat]

{ (# p1,p2 #) }

ConP Name [Pat]

data T1 = C1 t1 t2; {C1 p1 p1} = e

InfixP Pat Name Pat

foo ({x :+ y}) = e

UInfixP Pat Name Pat

foo ({x :+ y}) = e

See Language.Haskell.TH.Syntax

ParensP Pat

{(p)}

See Language.Haskell.TH.Syntax

TildeP Pat

{ ~p }

BangP Pat

{ !p }

AsP Name Pat

{ x @ p }

WildP

{ _ }

RecP Name [FieldPat]

f (Pt { pointx = x }) = g x

ListP [Pat]

{ [1,2,3] }

SigP Pat Type

{ p :: t }

ViewP Exp Pat

{ e -> p }

Instances

Eq Pat

Methods

(==) :: Pat -> Pat -> Bool

(/=) :: Pat -> Pat -> Bool

Data Pat

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Pat -> c Pat

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Pat

toConstr :: Pat -> Constr

dataTypeOf :: Pat -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Pat)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pat)

gmapT :: (forall b. Data b => b -> b) -> Pat -> Pat

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pat -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pat -> r

gmapQ :: (forall d. Data d => d -> u) -> Pat -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Pat -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Pat -> m Pat

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Pat -> m Pat

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Pat -> m Pat

Ord Pat

Methods

compare :: Pat -> Pat -> Ordering

(<) :: Pat -> Pat -> Bool

(<=) :: Pat -> Pat -> Bool

(>) :: Pat -> Pat -> Bool

(>=) :: Pat -> Pat -> Bool

max :: Pat -> Pat -> Pat

min :: Pat -> Pat -> Pat

Show Pat

Methods

showsPrec :: Int -> Pat -> ShowS

show :: Pat -> String

showList :: [Pat] -> ShowS

Generic Pat

Associated Types

type Rep Pat :: * -> *

Methods

from :: Pat -> Rep Pat x

to :: Rep Pat x -> Pat

Ppr Pat

Methods

ppr :: Pat -> Doc

ppr_list :: [Pat] -> Doc

type Rep Pat

type Rep Pat = D1 (MetaData "Pat" "Language.Haskell.TH.Syntax" "template-haskell" False) ((:+:) ((:+:) ((:+:) ((:+:) (C1 (MetaCons "LitP" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Lit))) (C1 (MetaCons "VarP" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name)))) ((:+:) (C1 (MetaCons "TupP" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Pat]))) (C1 (MetaCons "UnboxedTupP" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Pat]))))) ((:+:) ((:+:) (C1 (MetaCons "ConP" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Pat])))) (C1 (MetaCons "InfixP" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Pat)) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Pat)))))) ((:+:) (C1 (MetaCons "UInfixP" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Pat)) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Pat))))) (C1 (MetaCons "ParensP" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Pat)))))) ((:+:) ((:+:) ((:+:) (C1 (MetaCons "TildeP" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Pat))) (C1 (MetaCons "BangP" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Pat)))) ((:+:) (C1 (MetaCons "AsP" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Pat)))) (C1 (MetaCons "WildP" PrefixI False) U1))) ((:+:) ((:+:) (C1 (MetaCons "RecP" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [FieldPat])))) (C1 (MetaCons "ListP" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Pat])))) ((:+:) (C1 (MetaCons "SigP" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Pat)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Type)))) (C1 (MetaCons "ViewP" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Pat))))))))

type FieldPat = (Name, Pat)

data Match

Constructors

Match Pat Body [Dec]

case e of { pat -> body where decs }

Instances

Eq Match

Methods

(==) :: Match -> Match -> Bool

(/=) :: Match -> Match -> Bool

Data Match

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Match -> c Match

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Match

toConstr :: Match -> Constr

dataTypeOf :: Match -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Match)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Match)

gmapT :: (forall b. Data b => b -> b) -> Match -> Match

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Match -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Match -> r

gmapQ :: (forall d. Data d => d -> u) -> Match -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Match -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Match -> m Match

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Match -> m Match

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Match -> m Match

Ord Match

Methods

compare :: Match -> Match -> Ordering

(<) :: Match -> Match -> Bool

(<=) :: Match -> Match -> Bool

(>) :: Match -> Match -> Bool

(>=) :: Match -> Match -> Bool

max :: Match -> Match -> Match

min :: Match -> Match -> Match

Show Match

Methods

showsPrec :: Int -> Match -> ShowS

show :: Match -> String

showList :: [Match] -> ShowS

Generic Match

Associated Types

type Rep Match :: * -> *

Methods

from :: Match -> Rep Match x

to :: Rep Match x -> Match

Ppr Match

Methods

ppr :: Match -> Doc

ppr_list :: [Match] -> Doc

type Rep Match

type Rep Match = D1 (MetaData "Match" "Language.Haskell.TH.Syntax" "template-haskell" False) (C1 (MetaCons "Match" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Pat)) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Body)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Dec])))))

data Clause

Constructors

Clause [Pat] Body [Dec]

f { p1 p2 = body where decs }

Instances

Eq Clause

Methods

(==) :: Clause -> Clause -> Bool

(/=) :: Clause -> Clause -> Bool

Data Clause

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Clause -> c Clause

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Clause

toConstr :: Clause -> Constr

dataTypeOf :: Clause -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Clause)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Clause)

gmapT :: (forall b. Data b => b -> b) -> Clause -> Clause

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Clause -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Clause -> r

gmapQ :: (forall d. Data d => d -> u) -> Clause -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Clause -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Clause -> m Clause

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Clause -> m Clause

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Clause -> m Clause

Ord Clause

Methods

compare :: Clause -> Clause -> Ordering

(<) :: Clause -> Clause -> Bool

(<=) :: Clause -> Clause -> Bool

(>) :: Clause -> Clause -> Bool

(>=) :: Clause -> Clause -> Bool

max :: Clause -> Clause -> Clause

min :: Clause -> Clause -> Clause

Show Clause

Methods

showsPrec :: Int -> Clause -> ShowS

show :: Clause -> String

showList :: [Clause] -> ShowS

Generic Clause

Associated Types

type Rep Clause :: * -> *

Methods

from :: Clause -> Rep Clause x

to :: Rep Clause x -> Clause

Ppr Clause

Methods

ppr :: Clause -> Doc

ppr_list :: [Clause] -> Doc

type Rep Clause

type Rep Clause = D1 (MetaData "Clause" "Language.Haskell.TH.Syntax" "template-haskell" False) (C1 (MetaCons "Clause" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Pat])) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Body)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Dec])))))

data Exp

Constructors

VarE Name

{ x }

ConE Name

data T1 = C1 t1 t2; p = {C1} e1 e2

LitE Lit

{ 5 or 'c'}

AppE Exp Exp

{ f x }

InfixE (Maybe Exp) Exp (Maybe Exp)

{x + y} or {(x+)} or {(+ x)} or {(+)}

UInfixE Exp Exp Exp

{x + y}

See Language.Haskell.TH.Syntax

ParensE Exp

{ (e) }

See Language.Haskell.TH.Syntax

LamE [Pat] Exp

{ \ p1 p2 -> e }

LamCaseE [Match]

{ \case m1; m2 }

TupE [Exp]

{ (e1,e2) }

UnboxedTupE [Exp]

{ (# e1,e2 #) }

CondE Exp Exp Exp

{ if e1 then e2 else e3 }

MultiIfE [(Guard, Exp)]

{ if | g1 -> e1 | g2 -> e2 }

LetE [Dec] Exp

{ let x=e1;   y=e2 in e3 }

CaseE Exp [Match]

{ case e of m1; m2 }

DoE [Stmt]

{ do { p <- e1; e2 }  }

CompE [Stmt]

{ [ (x,y) | x <- xs, y <- ys ] }

The result expression of the comprehension is the last of the Stmts, and should be a NoBindS.

E.g. translation:

[ f x | x <- xs ]

CompE [BindS (VarP x) (VarE xs), NoBindS (AppE (VarE f) (VarE x))]

ArithSeqE Range

{ [ 1 ,2 .. 10 ] }

ListE [Exp]

{ [1,2,3] }

SigE Exp Type

{ e :: t }

RecConE Name [FieldExp]

{ T { x = y, z = w } }

RecUpdE Exp [FieldExp]

{ (f x) { z = w } }

StaticE Exp

{ static e }

UnboundVarE Name

{ _x } (hole)

Instances

Eq Exp

Methods

(==) :: Exp -> Exp -> Bool

(/=) :: Exp -> Exp -> Bool

Data Exp

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Exp -> c Exp

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Exp

toConstr :: Exp -> Constr

dataTypeOf :: Exp -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Exp)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Exp)

gmapT :: (forall b. Data b => b -> b) -> Exp -> Exp

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Exp -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Exp -> r

gmapQ :: (forall d. Data d => d -> u) -> Exp -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Exp -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Exp -> m Exp

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Exp -> m Exp

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Exp -> m Exp

Ord Exp

Methods

compare :: Exp -> Exp -> Ordering

(<) :: Exp -> Exp -> Bool

(<=) :: Exp -> Exp -> Bool

(>) :: Exp -> Exp -> Bool

(>=) :: Exp -> Exp -> Bool

max :: Exp -> Exp -> Exp

min :: Exp -> Exp -> Exp

Show Exp

Methods

showsPrec :: Int -> Exp -> ShowS

show :: Exp -> String

showList :: [Exp] -> ShowS

Generic Exp

Associated Types

type Rep Exp :: * -> *

Methods

from :: Exp -> Rep Exp x

to :: Rep Exp x -> Exp

Ppr Exp

Methods

ppr :: Exp -> Doc

ppr_list :: [Exp] -> Doc

type Rep Exp

type Rep Exp = D1 (MetaData "Exp" "Language.Haskell.TH.Syntax" "template-haskell" False) ((:+:) ((:+:) ((:+:) ((:+:) (C1 (MetaCons "VarE" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name))) ((:+:) (C1 (MetaCons "ConE" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name))) (C1 (MetaCons "LitE" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Lit))))) ((:+:) (C1 (MetaCons "AppE" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp)))) ((:+:) (C1 (MetaCons "InfixE" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe Exp))) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe Exp)))))) (C1 (MetaCons "UInfixE" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp)) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp)))))))) ((:+:) ((:+:) (C1 (MetaCons "ParensE" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp))) ((:+:) (C1 (MetaCons "LamE" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Pat])) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp)))) (C1 (MetaCons "LamCaseE" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Match]))))) ((:+:) (C1 (MetaCons "TupE" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Exp]))) ((:+:) (C1 (MetaCons "UnboxedTupE" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Exp]))) (C1 (MetaCons "CondE" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp)) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp))))))))) ((:+:) ((:+:) ((:+:) (C1 (MetaCons "MultiIfE" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [(Guard, Exp)]))) ((:+:) (C1 (MetaCons "LetE" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Dec])) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp)))) (C1 (MetaCons "CaseE" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Match])))))) ((:+:) (C1 (MetaCons "DoE" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Stmt]))) ((:+:) (C1 (MetaCons "CompE" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Stmt]))) (C1 (MetaCons "ArithSeqE" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Range)))))) ((:+:) ((:+:) (C1 (MetaCons "ListE" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Exp]))) ((:+:) (C1 (MetaCons "SigE" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Type)))) (C1 (MetaCons "RecConE" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [FieldExp])))))) ((:+:) (C1 (MetaCons "RecUpdE" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [FieldExp])))) ((:+:) (C1 (MetaCons "StaticE" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp))) (C1 (MetaCons "UnboundVarE" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name))))))))

type FieldExp = (Name, Exp)

data Body

Constructors

GuardedB [(Guard, Exp)]

f p { | e1 = e2
      | e3 = e4 }
 where ds

NormalB Exp

f p { = e } where ds

Instances

Eq Body

Methods

(==) :: Body -> Body -> Bool

(/=) :: Body -> Body -> Bool

Data Body

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Body -> c Body

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Body

toConstr :: Body -> Constr

dataTypeOf :: Body -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Body)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Body)

gmapT :: (forall b. Data b => b -> b) -> Body -> Body

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Body -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Body -> r

gmapQ :: (forall d. Data d => d -> u) -> Body -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Body -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Body -> m Body

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Body -> m Body

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Body -> m Body

Ord Body

Methods

compare :: Body -> Body -> Ordering

(<) :: Body -> Body -> Bool

(<=) :: Body -> Body -> Bool

(>) :: Body -> Body -> Bool

(>=) :: Body -> Body -> Bool

max :: Body -> Body -> Body

min :: Body -> Body -> Body

Show Body

Methods

showsPrec :: Int -> Body -> ShowS

show :: Body -> String

showList :: [Body] -> ShowS

Generic Body

Associated Types

type Rep Body :: * -> *

Methods

from :: Body -> Rep Body x

to :: Rep Body x -> Body

type Rep Body

type Rep Body = D1 (MetaData "Body" "Language.Haskell.TH.Syntax" "template-haskell" False) ((:+:) (C1 (MetaCons "GuardedB" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [(Guard, Exp)]))) (C1 (MetaCons "NormalB" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp))))

data Guard

Constructors

NormalG Exp

f x { | odd x } = x

PatG [Stmt]

f x { | Just y <- x, Just z <- y } = z

Instances

Eq Guard

Methods

(==) :: Guard -> Guard -> Bool

(/=) :: Guard -> Guard -> Bool

Data Guard

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Guard -> c Guard

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Guard

toConstr :: Guard -> Constr

dataTypeOf :: Guard -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Guard)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Guard)

gmapT :: (forall b. Data b => b -> b) -> Guard -> Guard

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Guard -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Guard -> r

gmapQ :: (forall d. Data d => d -> u) -> Guard -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Guard -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Guard -> m Guard

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Guard -> m Guard

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Guard -> m Guard

Ord Guard

Methods

compare :: Guard -> Guard -> Ordering

(<) :: Guard -> Guard -> Bool

(<=) :: Guard -> Guard -> Bool

(>) :: Guard -> Guard -> Bool

(>=) :: Guard -> Guard -> Bool

max :: Guard -> Guard -> Guard

min :: Guard -> Guard -> Guard

Show Guard

Methods

showsPrec :: Int -> Guard -> ShowS

show :: Guard -> String

showList :: [Guard] -> ShowS

Generic Guard

Associated Types

type Rep Guard :: * -> *

Methods

from :: Guard -> Rep Guard x

to :: Rep Guard x -> Guard

type Rep Guard

type Rep Guard = D1 (MetaData "Guard" "Language.Haskell.TH.Syntax" "template-haskell" False) ((:+:) (C1 (MetaCons "NormalG" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp))) (C1 (MetaCons "PatG" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Stmt]))))

data Stmt

Constructors

BindS Pat Exp

LetS [Dec]

NoBindS Exp

ParS [[Stmt]]

Instances

Eq Stmt

Methods

(==) :: Stmt -> Stmt -> Bool

(/=) :: Stmt -> Stmt -> Bool

Data Stmt

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Stmt -> c Stmt

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Stmt

toConstr :: Stmt -> Constr

dataTypeOf :: Stmt -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Stmt)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Stmt)

gmapT :: (forall b. Data b => b -> b) -> Stmt -> Stmt

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Stmt -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Stmt -> r

gmapQ :: (forall d. Data d => d -> u) -> Stmt -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Stmt -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Stmt -> m Stmt

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Stmt -> m Stmt

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Stmt -> m Stmt

Ord Stmt

Methods

compare :: Stmt -> Stmt -> Ordering

(<) :: Stmt -> Stmt -> Bool

(<=) :: Stmt -> Stmt -> Bool

(>) :: Stmt -> Stmt -> Bool

(>=) :: Stmt -> Stmt -> Bool

max :: Stmt -> Stmt -> Stmt

min :: Stmt -> Stmt -> Stmt

Show Stmt

Methods

showsPrec :: Int -> Stmt -> ShowS

show :: Stmt -> String

showList :: [Stmt] -> ShowS

Generic Stmt

Associated Types

type Rep Stmt :: * -> *

Methods

from :: Stmt -> Rep Stmt x

to :: Rep Stmt x -> Stmt

Ppr Stmt

Methods

ppr :: Stmt -> Doc

ppr_list :: [Stmt] -> Doc

type Rep Stmt

type Rep Stmt = D1 (MetaData "Stmt" "Language.Haskell.TH.Syntax" "template-haskell" False) ((:+:) ((:+:) (C1 (MetaCons "BindS" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Pat)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp)))) (C1 (MetaCons "LetS" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Dec])))) ((:+:) (C1 (MetaCons "NoBindS" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp))) (C1 (MetaCons "ParS" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [[Stmt]])))))

data Range

Constructors

FromR Exp

FromThenR Exp Exp

FromToR Exp Exp

FromThenToR Exp Exp Exp

Instances

Eq Range

Methods

(==) :: Range -> Range -> Bool

(/=) :: Range -> Range -> Bool

Data Range

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Range -> c Range

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Range

toConstr :: Range -> Constr

dataTypeOf :: Range -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Range)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Range)

gmapT :: (forall b. Data b => b -> b) -> Range -> Range

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Range -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Range -> r

gmapQ :: (forall d. Data d => d -> u) -> Range -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Range -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Range -> m Range

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Range -> m Range

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Range -> m Range

Ord Range

Methods

compare :: Range -> Range -> Ordering

(<) :: Range -> Range -> Bool

(<=) :: Range -> Range -> Bool

(>) :: Range -> Range -> Bool

(>=) :: Range -> Range -> Bool

max :: Range -> Range -> Range

min :: Range -> Range -> Range

Show Range

Methods

showsPrec :: Int -> Range -> ShowS

show :: Range -> String

showList :: [Range] -> ShowS

Generic Range

Associated Types

type Rep Range :: * -> *

Methods

from :: Range -> Rep Range x

to :: Rep Range x -> Range

Ppr Range

Methods

ppr :: Range -> Doc

ppr_list :: [Range] -> Doc

type Rep Range

type Rep Range = D1 (MetaData "Range" "Language.Haskell.TH.Syntax" "template-haskell" False) ((:+:) ((:+:) (C1 (MetaCons "FromR" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp))) (C1 (MetaCons "FromThenR" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp))))) ((:+:) (C1 (MetaCons "FromToR" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp)))) (C1 (MetaCons "FromThenToR" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp)) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp)))))))

data Dec

Constructors

FunD Name [Clause]

{ f p1 p2 = b where decs }

ValD Pat Body [Dec]

{ p = b where decs }

DataD Cxt Name [TyVarBndr] (Maybe Kind) [Con] Cxt

{ data Cxt x => T x = A x | B (T x)
       deriving (Z,W)}

NewtypeD Cxt Name [TyVarBndr] (Maybe Kind) Con Cxt

{ newtype Cxt x => T x = A (B x)
       deriving (Z,W Q)}

TySynD Name [TyVarBndr] Type

{ type T x = (x,x) }

ClassD Cxt Name [TyVarBndr] [FunDep] [Dec]

{ class Eq a => Ord a where ds }

InstanceD (Maybe Overlap) Cxt Type [Dec]

{ instance {-# OVERLAPS #-}
        Show w => Show [w] where ds }

SigD Name Type

{ length :: [a] -> Int }

ForeignD Foreign

{ foreign import ... }
{ foreign export ... }

InfixD Fixity Name

{ infix 3 foo }

PragmaD Pragma

{ {-# INLINE [1] foo #-} }

DataFamilyD Name [TyVarBndr] (Maybe Kind)

{ data family T a b c :: * }

DataInstD Cxt Name [Type] (Maybe Kind) [Con] Cxt

{ data instance Cxt x => T [x]
       = A x | B (T x) deriving (Z,W)}

NewtypeInstD Cxt Name [Type] (Maybe Kind) Con Cxt

{ newtype instance Cxt x => T [x]
        = A (B x) deriving (Z,W)}

TySynInstD Name TySynEqn

{ type instance ... }

OpenTypeFamilyD TypeFamilyHead

{ type family T a b c = (r :: *) | r -> a b }

ClosedTypeFamilyD TypeFamilyHead [TySynEqn]

{ type family F a b = (r :: *) | r -> a where ... }

RoleAnnotD Name [Role]

{ type role T nominal representational }

StandaloneDerivD Cxt Type

{ deriving instance Ord a => Ord (Foo a) }

DefaultSigD Name Type

{ default size :: Data a => a -> Int }

Instances

Eq Dec

Methods

(==) :: Dec -> Dec -> Bool

(/=) :: Dec -> Dec -> Bool

Data Dec

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Dec -> c Dec

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Dec

toConstr :: Dec -> Constr

dataTypeOf :: Dec -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Dec)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Dec)

gmapT :: (forall b. Data b => b -> b) -> Dec -> Dec

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Dec -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Dec -> r

gmapQ :: (forall d. Data d => d -> u) -> Dec -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Dec -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Dec -> m Dec

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Dec -> m Dec

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Dec -> m Dec

Ord Dec

Methods

compare :: Dec -> Dec -> Ordering

(<) :: Dec -> Dec -> Bool

(<=) :: Dec -> Dec -> Bool

(>) :: Dec -> Dec -> Bool

(>=) :: Dec -> Dec -> Bool

max :: Dec -> Dec -> Dec

min :: Dec -> Dec -> Dec

Show Dec

Methods

showsPrec :: Int -> Dec -> ShowS

show :: Dec -> String

showList :: [Dec] -> ShowS

Generic Dec

Associated Types

type Rep Dec :: * -> *

Methods

from :: Dec -> Rep Dec x

to :: Rep Dec x -> Dec

Ppr Dec

Methods

ppr :: Dec -> Doc

ppr_list :: [Dec] -> Doc

type Rep Dec

type Rep Dec = D1 (MetaData "Dec" "Language.Haskell.TH.Syntax" "template-haskell" False) ((:+:) ((:+:) ((:+:) ((:+:) (C1 (MetaCons "FunD" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Clause])))) (C1 (MetaCons "ValD" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Pat)) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Body)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Dec])))))) ((:+:) (C1 (MetaCons "DataD" PrefixI False) ((:*:) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Cxt)) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [TyVarBndr])))) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe Kind))) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Con])) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Cxt)))))) ((:+:) (C1 (MetaCons "NewtypeD" PrefixI False) ((:*:) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Cxt)) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [TyVarBndr])))) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe Kind))) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Con)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Cxt)))))) (C1 (MetaCons "TySynD" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name)) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [TyVarBndr])) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Type)))))))) ((:+:) ((:+:) (C1 (MetaCons "ClassD" PrefixI False) ((:*:) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Cxt)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name))) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [TyVarBndr])) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [FunDep])) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Dec])))))) (C1 (MetaCons "InstanceD" PrefixI False) ((:*:) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe Overlap))) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Cxt))) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Type)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Dec])))))) ((:+:) (C1 (MetaCons "SigD" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Type)))) ((:+:) (C1 (MetaCons "ForeignD" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Foreign))) (C1 (MetaCons "InfixD" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Fixity)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name)))))))) ((:+:) ((:+:) ((:+:) (C1 (MetaCons "PragmaD" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Pragma))) (C1 (MetaCons "DataFamilyD" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name)) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [TyVarBndr])) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe Kind))))))) ((:+:) (C1 (MetaCons "DataInstD" PrefixI False) ((:*:) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Cxt)) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Type])))) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe Kind))) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Con])) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Cxt)))))) ((:+:) (C1 (MetaCons "NewtypeInstD" PrefixI False) ((:*:) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Cxt)) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Type])))) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe Kind))) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Con)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Cxt)))))) (C1 (MetaCons "TySynInstD" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 TySynEqn))))))) ((:+:) ((:+:) (C1 (MetaCons "OpenTypeFamilyD" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 TypeFamilyHead))) (C1 (MetaCons "ClosedTypeFamilyD" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 TypeFamilyHead)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [TySynEqn]))))) ((:+:) (C1 (MetaCons "RoleAnnotD" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Role])))) ((:+:) (C1 (MetaCons "StandaloneDerivD" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Cxt)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Type)))) (C1 (MetaCons "DefaultSigD" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Type)))))))))

data Overlap

Varieties of allowed instance overlap.

Constructors

Overlappable

May be overlapped by more specific instances

Overlapping

May overlap a more general instance

Overlaps

Both Overlapping and Overlappable

Incoherent

Both Overlappable and Overlappable, and pick an arbitrary one if multiple choices are available.

Instances

Eq Overlap

Methods

(==) :: Overlap -> Overlap -> Bool

(/=) :: Overlap -> Overlap -> Bool

Data Overlap

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Overlap -> c Overlap

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Overlap

toConstr :: Overlap -> Constr

dataTypeOf :: Overlap -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Overlap)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Overlap)

gmapT :: (forall b. Data b => b -> b) -> Overlap -> Overlap

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Overlap -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Overlap -> r

gmapQ :: (forall d. Data d => d -> u) -> Overlap -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Overlap -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Overlap -> m Overlap

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Overlap -> m Overlap

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Overlap -> m Overlap

Ord Overlap

Methods

compare :: Overlap -> Overlap -> Ordering

(<) :: Overlap -> Overlap -> Bool

(<=) :: Overlap -> Overlap -> Bool

(>) :: Overlap -> Overlap -> Bool

(>=) :: Overlap -> Overlap -> Bool

max :: Overlap -> Overlap -> Overlap

min :: Overlap -> Overlap -> Overlap

Show Overlap

Methods

showsPrec :: Int -> Overlap -> ShowS

show :: Overlap -> String

showList :: [Overlap] -> ShowS

Generic Overlap

Associated Types

type Rep Overlap :: * -> *

Methods

from :: Overlap -> Rep Overlap x

to :: Rep Overlap x -> Overlap

type Rep Overlap

type Rep Overlap = D1 (MetaData "Overlap" "Language.Haskell.TH.Syntax" "template-haskell" False) ((:+:) ((:+:) (C1 (MetaCons "Overlappable" PrefixI False) U1) (C1 (MetaCons "Overlapping" PrefixI False) U1)) ((:+:) (C1 (MetaCons "Overlaps" PrefixI False) U1) (C1 (MetaCons "Incoherent" PrefixI False) U1)))

data TypeFamilyHead

Common elements of OpenTypeFamilyD and ClosedTypeFamilyD. By analogy with with "head" for type classes and type class instances as defined in Type classes: an exploration of the design space, the TypeFamilyHead is defined to be the elements of the declaration between type family and where.

Constructors

TypeFamilyHead Name [TyVarBndr] FamilyResultSig (Maybe InjectivityAnn)

Instances

Eq TypeFamilyHead

Methods

(==) :: TypeFamilyHead -> TypeFamilyHead -> Bool

(/=) :: TypeFamilyHead -> TypeFamilyHead -> Bool

Data TypeFamilyHead

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TypeFamilyHead -> c TypeFamilyHead

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TypeFamilyHead

toConstr :: TypeFamilyHead -> Constr

dataTypeOf :: TypeFamilyHead -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c TypeFamilyHead)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TypeFamilyHead)

gmapT :: (forall b. Data b => b -> b) -> TypeFamilyHead -> TypeFamilyHead

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TypeFamilyHead -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TypeFamilyHead -> r

gmapQ :: (forall d. Data d => d -> u) -> TypeFamilyHead -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> TypeFamilyHead -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> TypeFamilyHead -> m TypeFamilyHead

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TypeFamilyHead -> m TypeFamilyHead

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TypeFamilyHead -> m TypeFamilyHead

Ord TypeFamilyHead

Methods

compare :: TypeFamilyHead -> TypeFamilyHead -> Ordering

(<) :: TypeFamilyHead -> TypeFamilyHead -> Bool

(<=) :: TypeFamilyHead -> TypeFamilyHead -> Bool

(>) :: TypeFamilyHead -> TypeFamilyHead -> Bool

(>=) :: TypeFamilyHead -> TypeFamilyHead -> Bool

max :: TypeFamilyHead -> TypeFamilyHead -> TypeFamilyHead

min :: TypeFamilyHead -> TypeFamilyHead -> TypeFamilyHead

Show TypeFamilyHead

Methods

showsPrec :: Int -> TypeFamilyHead -> ShowS

show :: TypeFamilyHead -> String

showList :: [TypeFamilyHead] -> ShowS

Generic TypeFamilyHead

Associated Types

type Rep TypeFamilyHead :: * -> *

Methods

from :: TypeFamilyHead -> Rep TypeFamilyHead x

to :: Rep TypeFamilyHead x -> TypeFamilyHead

type Rep TypeFamilyHead

type Rep TypeFamilyHead = D1 (MetaData "TypeFamilyHead" "Language.Haskell.TH.Syntax" "template-haskell" False) (C1 (MetaCons "TypeFamilyHead" PrefixI False) ((:*:) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [TyVarBndr]))) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 FamilyResultSig)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe InjectivityAnn))))))

data TySynEqn

One equation of a type family instance or closed type family. The arguments are the left-hand-side type patterns and the right-hand-side result.

Constructors

TySynEqn [Type] Type

Instances

Eq TySynEqn

Methods

(==) :: TySynEqn -> TySynEqn -> Bool

(/=) :: TySynEqn -> TySynEqn -> Bool

Data TySynEqn

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TySynEqn -> c TySynEqn

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TySynEqn

toConstr :: TySynEqn -> Constr

dataTypeOf :: TySynEqn -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c TySynEqn)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TySynEqn)

gmapT :: (forall b. Data b => b -> b) -> TySynEqn -> TySynEqn

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TySynEqn -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TySynEqn -> r

gmapQ :: (forall d. Data d => d -> u) -> TySynEqn -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> TySynEqn -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> TySynEqn -> m TySynEqn

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TySynEqn -> m TySynEqn

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TySynEqn -> m TySynEqn

Ord TySynEqn

Methods

compare :: TySynEqn -> TySynEqn -> Ordering

(<) :: TySynEqn -> TySynEqn -> Bool

(<=) :: TySynEqn -> TySynEqn -> Bool

(>) :: TySynEqn -> TySynEqn -> Bool

(>=) :: TySynEqn -> TySynEqn -> Bool

max :: TySynEqn -> TySynEqn -> TySynEqn

min :: TySynEqn -> TySynEqn -> TySynEqn

Show TySynEqn

Methods

showsPrec :: Int -> TySynEqn -> ShowS

show :: TySynEqn -> String

showList :: [TySynEqn] -> ShowS

Generic TySynEqn

Associated Types

type Rep TySynEqn :: * -> *

Methods

from :: TySynEqn -> Rep TySynEqn x

to :: Rep TySynEqn x -> TySynEqn

type Rep TySynEqn

type Rep TySynEqn = D1 (MetaData "TySynEqn" "Language.Haskell.TH.Syntax" "template-haskell" False) (C1 (MetaCons "TySynEqn" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Type])) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Type))))

data FunDep

Constructors

FunDep [Name] [Name]

Instances

Eq FunDep

Methods

(==) :: FunDep -> FunDep -> Bool

(/=) :: FunDep -> FunDep -> Bool

Data FunDep

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FunDep -> c FunDep

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FunDep

toConstr :: FunDep -> Constr

dataTypeOf :: FunDep -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c FunDep)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FunDep)

gmapT :: (forall b. Data b => b -> b) -> FunDep -> FunDep

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FunDep -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FunDep -> r

gmapQ :: (forall d. Data d => d -> u) -> FunDep -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> FunDep -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FunDep -> m FunDep

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FunDep -> m FunDep

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FunDep -> m FunDep

Ord FunDep

Methods

compare :: FunDep -> FunDep -> Ordering

(<) :: FunDep -> FunDep -> Bool

(<=) :: FunDep -> FunDep -> Bool

(>) :: FunDep -> FunDep -> Bool

(>=) :: FunDep -> FunDep -> Bool

max :: FunDep -> FunDep -> FunDep

min :: FunDep -> FunDep -> FunDep

Show FunDep

Methods

showsPrec :: Int -> FunDep -> ShowS

show :: FunDep -> String

showList :: [FunDep] -> ShowS

Generic FunDep

Associated Types

type Rep FunDep :: * -> *

Methods

from :: FunDep -> Rep FunDep x

to :: Rep FunDep x -> FunDep

Ppr FunDep

Methods

ppr :: FunDep -> Doc

ppr_list :: [FunDep] -> Doc

type Rep FunDep

type Rep FunDep = D1 (MetaData "FunDep" "Language.Haskell.TH.Syntax" "template-haskell" False) (C1 (MetaCons "FunDep" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Name])) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Name]))))

data FamFlavour

Constructors

TypeFam

DataFam

Instances

Eq FamFlavour

Methods

(==) :: FamFlavour -> FamFlavour -> Bool

(/=) :: FamFlavour -> FamFlavour -> Bool

Data FamFlavour

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FamFlavour -> c FamFlavour

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FamFlavour

toConstr :: FamFlavour -> Constr

dataTypeOf :: FamFlavour -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c FamFlavour)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FamFlavour)

gmapT :: (forall b. Data b => b -> b) -> FamFlavour -> FamFlavour

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FamFlavour -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FamFlavour -> r

gmapQ :: (forall d. Data d => d -> u) -> FamFlavour -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> FamFlavour -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FamFlavour -> m FamFlavour

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FamFlavour -> m FamFlavour

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FamFlavour -> m FamFlavour

Ord FamFlavour

Methods

compare :: FamFlavour -> FamFlavour -> Ordering

(<) :: FamFlavour -> FamFlavour -> Bool

(<=) :: FamFlavour -> FamFlavour -> Bool

(>) :: FamFlavour -> FamFlavour -> Bool

(>=) :: FamFlavour -> FamFlavour -> Bool

max :: FamFlavour -> FamFlavour -> FamFlavour

min :: FamFlavour -> FamFlavour -> FamFlavour

Show FamFlavour

Methods

showsPrec :: Int -> FamFlavour -> ShowS

show :: FamFlavour -> String

showList :: [FamFlavour] -> ShowS

Generic FamFlavour

Associated Types

type Rep FamFlavour :: * -> *

Methods

from :: FamFlavour -> Rep FamFlavour x

to :: Rep FamFlavour x -> FamFlavour

Ppr FamFlavour

Methods

ppr :: FamFlavour -> Doc

ppr_list :: [FamFlavour] -> Doc

type Rep FamFlavour

type Rep FamFlavour = D1 (MetaData "FamFlavour" "Language.Haskell.TH.Syntax" "template-haskell" False) ((:+:) (C1 (MetaCons "TypeFam" PrefixI False) U1) (C1 (MetaCons "DataFam" PrefixI False) U1))

data Foreign

Constructors

ImportF Callconv Safety String Name Type

ExportF Callconv String Name Type

Instances

Eq Foreign

Methods

(==) :: Foreign -> Foreign -> Bool

(/=) :: Foreign -> Foreign -> Bool

Data Foreign

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Foreign -> c Foreign

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Foreign

toConstr :: Foreign -> Constr

dataTypeOf :: Foreign -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Foreign)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Foreign)

gmapT :: (forall b. Data b => b -> b) -> Foreign -> Foreign

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Foreign -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Foreign -> r

gmapQ :: (forall d. Data d => d -> u) -> Foreign -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Foreign -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Foreign -> m Foreign

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Foreign -> m Foreign

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Foreign -> m Foreign

Ord Foreign

Methods

compare :: Foreign -> Foreign -> Ordering

(<) :: Foreign -> Foreign -> Bool

(<=) :: Foreign -> Foreign -> Bool

(>) :: Foreign -> Foreign -> Bool

(>=) :: Foreign -> Foreign -> Bool

max :: Foreign -> Foreign -> Foreign

min :: Foreign -> Foreign -> Foreign

Show Foreign

Methods

showsPrec :: Int -> Foreign -> ShowS

show :: Foreign -> String

showList :: [Foreign] -> ShowS

Generic Foreign

Associated Types

type Rep Foreign :: * -> *

Methods

from :: Foreign -> Rep Foreign x

to :: Rep Foreign x -> Foreign

Ppr Foreign

Methods

ppr :: Foreign -> Doc

ppr_list :: [Foreign] -> Doc

type Rep Foreign

type Rep Foreign = D1 (MetaData "Foreign" "Language.Haskell.TH.Syntax" "template-haskell" False) ((:+:) (C1 (MetaCons "ImportF" PrefixI False) ((:*:) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Callconv)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Safety))) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String)) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Type)))))) (C1 (MetaCons "ExportF" PrefixI False) ((:*:) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Callconv)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String))) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Type))))))

data Callconv

Constructors

CCall

StdCall

CApi

Prim

JavaScript

Instances

Eq Callconv

Methods

(==) :: Callconv -> Callconv -> Bool

(/=) :: Callconv -> Callconv -> Bool

Data Callconv

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Callconv -> c Callconv

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Callconv

toConstr :: Callconv -> Constr

dataTypeOf :: Callconv -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Callconv)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Callconv)

gmapT :: (forall b. Data b => b -> b) -> Callconv -> Callconv

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Callconv -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Callconv -> r

gmapQ :: (forall d. Data d => d -> u) -> Callconv -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Callconv -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Callconv -> m Callconv

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Callconv -> m Callconv

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Callconv -> m Callconv

Ord Callconv

Methods

compare :: Callconv -> Callconv -> Ordering

(<) :: Callconv -> Callconv -> Bool

(<=) :: Callconv -> Callconv -> Bool

(>) :: Callconv -> Callconv -> Bool

(>=) :: Callconv -> Callconv -> Bool

max :: Callconv -> Callconv -> Callconv

min :: Callconv -> Callconv -> Callconv

Show Callconv

Methods

showsPrec :: Int -> Callconv -> ShowS

show :: Callconv -> String

showList :: [Callconv] -> ShowS

Generic Callconv

Associated Types

type Rep Callconv :: * -> *

Methods

from :: Callconv -> Rep Callconv x

to :: Rep Callconv x -> Callconv

type Rep Callconv

type Rep Callconv = D1 (MetaData "Callconv" "Language.Haskell.TH.Syntax" "template-haskell" False) ((:+:) ((:+:) (C1 (MetaCons "CCall" PrefixI False) U1) (C1 (MetaCons "StdCall" PrefixI False) U1)) ((:+:) (C1 (MetaCons "CApi" PrefixI False) U1) ((:+:) (C1 (MetaCons "Prim" PrefixI False) U1) (C1 (MetaCons "JavaScript" PrefixI False) U1))))

data Safety

Constructors

Unsafe

Safe

Interruptible

Instances

Eq Safety

Methods

(==) :: Safety -> Safety -> Bool

(/=) :: Safety -> Safety -> Bool

Data Safety

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Safety -> c Safety

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Safety

toConstr :: Safety -> Constr

dataTypeOf :: Safety -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Safety)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Safety)

gmapT :: (forall b. Data b => b -> b) -> Safety -> Safety

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Safety -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Safety -> r

gmapQ :: (forall d. Data d => d -> u) -> Safety -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Safety -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Safety -> m Safety

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Safety -> m Safety

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Safety -> m Safety

Ord Safety

Methods

compare :: Safety -> Safety -> Ordering

(<) :: Safety -> Safety -> Bool

(<=) :: Safety -> Safety -> Bool

(>) :: Safety -> Safety -> Bool

(>=) :: Safety -> Safety -> Bool

max :: Safety -> Safety -> Safety

min :: Safety -> Safety -> Safety

Show Safety

Methods

showsPrec :: Int -> Safety -> ShowS

show :: Safety -> String

showList :: [Safety] -> ShowS

Generic Safety

Associated Types

type Rep Safety :: * -> *

Methods

from :: Safety -> Rep Safety x

to :: Rep Safety x -> Safety

type Rep Safety

type Rep Safety = D1 (MetaData "Safety" "Language.Haskell.TH.Syntax" "template-haskell" False) ((:+:) (C1 (MetaCons "Unsafe" PrefixI False) U1) ((:+:) (C1 (MetaCons "Safe" PrefixI False) U1) (C1 (MetaCons "Interruptible" PrefixI False) U1)))

data Pragma

Constructors

InlineP Name Inline RuleMatch Phases

SpecialiseP Name Type (Maybe Inline) Phases

SpecialiseInstP Type

RuleP String [RuleBndr] Exp Exp Phases

AnnP AnnTarget Exp

LineP Int String

Instances

Eq Pragma

Methods

(==) :: Pragma -> Pragma -> Bool

(/=) :: Pragma -> Pragma -> Bool

Data Pragma

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Pragma -> c Pragma

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Pragma

toConstr :: Pragma -> Constr

dataTypeOf :: Pragma -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Pragma)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pragma)

gmapT :: (forall b. Data b => b -> b) -> Pragma -> Pragma

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pragma -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pragma -> r

gmapQ :: (forall d. Data d => d -> u) -> Pragma -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Pragma -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Pragma -> m Pragma

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Pragma -> m Pragma

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Pragma -> m Pragma

Ord Pragma

Methods

compare :: Pragma -> Pragma -> Ordering

(<) :: Pragma -> Pragma -> Bool

(<=) :: Pragma -> Pragma -> Bool

(>) :: Pragma -> Pragma -> Bool

(>=) :: Pragma -> Pragma -> Bool

max :: Pragma -> Pragma -> Pragma

min :: Pragma -> Pragma -> Pragma

Show Pragma

Methods

showsPrec :: Int -> Pragma -> ShowS

show :: Pragma -> String

showList :: [Pragma] -> ShowS

Generic Pragma

Associated Types

type Rep Pragma :: * -> *

Methods

from :: Pragma -> Rep Pragma x

to :: Rep Pragma x -> Pragma

Ppr Pragma

Methods

ppr :: Pragma -> Doc

ppr_list :: [Pragma] -> Doc

type Rep Pragma

type Rep Pragma = D1 (MetaData "Pragma" "Language.Haskell.TH.Syntax" "template-haskell" False) ((:+:) ((:+:) (C1 (MetaCons "InlineP" PrefixI False) ((:*:) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Inline))) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 RuleMatch)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Phases))))) ((:+:) (C1 (MetaCons "SpecialiseP" PrefixI False) ((:*:) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Type))) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe Inline))) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Phases))))) (C1 (MetaCons "SpecialiseInstP" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Type))))) ((:+:) (C1 (MetaCons "RuleP" PrefixI False) ((:*:) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [RuleBndr]))) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp)) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Phases)))))) ((:+:) (C1 (MetaCons "AnnP" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 AnnTarget)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp)))) (C1 (MetaCons "LineP" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Int)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String)))))))

data Inline

Constructors

NoInline

Inline

Inlinable

Instances

Eq Inline

Methods

(==) :: Inline -> Inline -> Bool

(/=) :: Inline -> Inline -> Bool

Data Inline

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Inline -> c Inline

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Inline

toConstr :: Inline -> Constr

dataTypeOf :: Inline -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Inline)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Inline)

gmapT :: (forall b. Data b => b -> b) -> Inline -> Inline

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Inline -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Inline -> r

gmapQ :: (forall d. Data d => d -> u) -> Inline -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Inline -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Inline -> m Inline

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Inline -> m Inline

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Inline -> m Inline

Ord Inline

Methods

compare :: Inline -> Inline -> Ordering

(<) :: Inline -> Inline -> Bool

(<=) :: Inline -> Inline -> Bool

(>) :: Inline -> Inline -> Bool

(>=) :: Inline -> Inline -> Bool

max :: Inline -> Inline -> Inline

min :: Inline -> Inline -> Inline

Show Inline

Methods

showsPrec :: Int -> Inline -> ShowS

show :: Inline -> String

showList :: [Inline] -> ShowS

Generic Inline

Associated Types

type Rep Inline :: * -> *

Methods

from :: Inline -> Rep Inline x

to :: Rep Inline x -> Inline

Ppr Inline

Methods

ppr :: Inline -> Doc

ppr_list :: [Inline] -> Doc

type Rep Inline

type Rep Inline = D1 (MetaData "Inline" "Language.Haskell.TH.Syntax" "template-haskell" False) ((:+:) (C1 (MetaCons "NoInline" PrefixI False) U1) ((:+:) (C1 (MetaCons "Inline" PrefixI False) U1) (C1 (MetaCons "Inlinable" PrefixI False) U1)))

data RuleMatch

Constructors

ConLike

FunLike

Instances

Eq RuleMatch

Methods

(==) :: RuleMatch -> RuleMatch -> Bool

(/=) :: RuleMatch -> RuleMatch -> Bool

Data RuleMatch

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RuleMatch -> c RuleMatch

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c RuleMatch

toConstr :: RuleMatch -> Constr

dataTypeOf :: RuleMatch -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c RuleMatch)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RuleMatch)

gmapT :: (forall b. Data b => b -> b) -> RuleMatch -> RuleMatch

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RuleMatch -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RuleMatch -> r

gmapQ :: (forall d. Data d => d -> u) -> RuleMatch -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> RuleMatch -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> RuleMatch -> m RuleMatch

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleMatch -> m RuleMatch

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleMatch -> m RuleMatch

Ord RuleMatch

Methods

compare :: RuleMatch -> RuleMatch -> Ordering

(<) :: RuleMatch -> RuleMatch -> Bool

(<=) :: RuleMatch -> RuleMatch -> Bool

(>) :: RuleMatch -> RuleMatch -> Bool

(>=) :: RuleMatch -> RuleMatch -> Bool

max :: RuleMatch -> RuleMatch -> RuleMatch

min :: RuleMatch -> RuleMatch -> RuleMatch

Show RuleMatch

Methods

showsPrec :: Int -> RuleMatch -> ShowS

show :: RuleMatch -> String

showList :: [RuleMatch] -> ShowS

Generic RuleMatch

Associated Types

type Rep RuleMatch :: * -> *

Methods

from :: RuleMatch -> Rep RuleMatch x

to :: Rep RuleMatch x -> RuleMatch

Ppr RuleMatch

Methods

ppr :: RuleMatch -> Doc

ppr_list :: [RuleMatch] -> Doc

type Rep RuleMatch

type Rep RuleMatch = D1 (MetaData "RuleMatch" "Language.Haskell.TH.Syntax" "template-haskell" False) ((:+:) (C1 (MetaCons "ConLike" PrefixI False) U1) (C1 (MetaCons "FunLike" PrefixI False) U1))

data Phases

Constructors

AllPhases

FromPhase Int

BeforePhase Int

Instances

Eq Phases

Methods

(==) :: Phases -> Phases -> Bool

(/=) :: Phases -> Phases -> Bool

Data Phases

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Phases -> c Phases

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Phases

toConstr :: Phases -> Constr

dataTypeOf :: Phases -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Phases)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Phases)

gmapT :: (forall b. Data b => b -> b) -> Phases -> Phases

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Phases -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Phases -> r

gmapQ :: (forall d. Data d => d -> u) -> Phases -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Phases -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Phases -> m Phases

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Phases -> m Phases

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Phases -> m Phases

Ord Phases

Methods

compare :: Phases -> Phases -> Ordering

(<) :: Phases -> Phases -> Bool

(<=) :: Phases -> Phases -> Bool

(>) :: Phases -> Phases -> Bool

(>=) :: Phases -> Phases -> Bool

max :: Phases -> Phases -> Phases

min :: Phases -> Phases -> Phases

Show Phases

Methods

showsPrec :: Int -> Phases -> ShowS

show :: Phases -> String

showList :: [Phases] -> ShowS

Generic Phases

Associated Types

type Rep Phases :: * -> *

Methods

from :: Phases -> Rep Phases x

to :: Rep Phases x -> Phases

Ppr Phases

Methods

ppr :: Phases -> Doc

ppr_list :: [Phases] -> Doc

type Rep Phases

type Rep Phases = D1 (MetaData "Phases" "Language.Haskell.TH.Syntax" "template-haskell" False) ((:+:) (C1 (MetaCons "AllPhases" PrefixI False) U1) ((:+:) (C1 (MetaCons "FromPhase" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Int))) (C1 (MetaCons "BeforePhase" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Int)))))

data RuleBndr

Constructors

RuleVar Name

TypedRuleVar Name Type

Instances

Eq RuleBndr

Methods

(==) :: RuleBndr -> RuleBndr -> Bool

(/=) :: RuleBndr -> RuleBndr -> Bool

Data RuleBndr

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RuleBndr -> c RuleBndr

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c RuleBndr

toConstr :: RuleBndr -> Constr

dataTypeOf :: RuleBndr -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c RuleBndr)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RuleBndr)

gmapT :: (forall b. Data b => b -> b) -> RuleBndr -> RuleBndr

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RuleBndr -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RuleBndr -> r

gmapQ :: (forall d. Data d => d -> u) -> RuleBndr -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> RuleBndr -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> RuleBndr -> m RuleBndr

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleBndr -> m RuleBndr

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleBndr -> m RuleBndr

Ord RuleBndr

Methods

compare :: RuleBndr -> RuleBndr -> Ordering

(<) :: RuleBndr -> RuleBndr -> Bool

(<=) :: RuleBndr -> RuleBndr -> Bool

(>) :: RuleBndr -> RuleBndr -> Bool

(>=) :: RuleBndr -> RuleBndr -> Bool

max :: RuleBndr -> RuleBndr -> RuleBndr

min :: RuleBndr -> RuleBndr -> RuleBndr

Show RuleBndr

Methods

showsPrec :: Int -> RuleBndr -> ShowS

show :: RuleBndr -> String

showList :: [RuleBndr] -> ShowS

Generic RuleBndr

Associated Types

type Rep RuleBndr :: * -> *

Methods

from :: RuleBndr -> Rep RuleBndr x

to :: Rep RuleBndr x -> RuleBndr

Ppr RuleBndr

Methods

ppr :: RuleBndr -> Doc

ppr_list :: [RuleBndr] -> Doc

type Rep RuleBndr

type Rep RuleBndr = D1 (MetaData "RuleBndr" "Language.Haskell.TH.Syntax" "template-haskell" False) ((:+:) (C1 (MetaCons "RuleVar" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name))) (C1 (MetaCons "TypedRuleVar" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Type)))))

data AnnTarget

Constructors

ModuleAnnotation

TypeAnnotation Name

ValueAnnotation Name

Instances

Eq AnnTarget

Methods

(==) :: AnnTarget -> AnnTarget -> Bool

(/=) :: AnnTarget -> AnnTarget -> Bool

Data AnnTarget

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AnnTarget -> c AnnTarget

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AnnTarget

toConstr :: AnnTarget -> Constr

dataTypeOf :: AnnTarget -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c AnnTarget)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AnnTarget)

gmapT :: (forall b. Data b => b -> b) -> AnnTarget -> AnnTarget

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AnnTarget -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AnnTarget -> r

gmapQ :: (forall d. Data d => d -> u) -> AnnTarget -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> AnnTarget -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> AnnTarget -> m AnnTarget

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnTarget -> m AnnTarget

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnTarget -> m AnnTarget

Ord AnnTarget

Methods

compare :: AnnTarget -> AnnTarget -> Ordering

(<) :: AnnTarget -> AnnTarget -> Bool

(<=) :: AnnTarget -> AnnTarget -> Bool

(>) :: AnnTarget -> AnnTarget -> Bool

(>=) :: AnnTarget -> AnnTarget -> Bool

max :: AnnTarget -> AnnTarget -> AnnTarget

min :: AnnTarget -> AnnTarget -> AnnTarget

Show AnnTarget

Methods

showsPrec :: Int -> AnnTarget -> ShowS

show :: AnnTarget -> String

showList :: [AnnTarget] -> ShowS

Generic AnnTarget

Associated Types

type Rep AnnTarget :: * -> *

Methods

from :: AnnTarget -> Rep AnnTarget x

to :: Rep AnnTarget x -> AnnTarget

type Rep AnnTarget

type Rep AnnTarget = D1 (MetaData "AnnTarget" "Language.Haskell.TH.Syntax" "template-haskell" False) ((:+:) (C1 (MetaCons "ModuleAnnotation" PrefixI False) U1) ((:+:) (C1 (MetaCons "TypeAnnotation" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name))) (C1 (MetaCons "ValueAnnotation" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name)))))

type Cxt

Arguments

 = [Pred]

(Eq a, Ord b)

type Pred = Type

Since the advent of ConstraintKinds, constraints are really just types. Equality constraints use the EqualityT constructor. Constraints may also be tuples of other constraints.

data SourceUnpackedness

Constructors

NoSourceUnpackedness

C a

SourceNoUnpack

C { {-# NOUNPACK #-} } a

SourceUnpack

C { {-# UNPACK #-} } a

Instances

Eq SourceUnpackedness

Methods

(==) :: SourceUnpackedness -> SourceUnpackedness -> Bool

(/=) :: SourceUnpackedness -> SourceUnpackedness -> Bool

Data SourceUnpackedness

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SourceUnpackedness -> c SourceUnpackedness

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SourceUnpackedness

toConstr :: SourceUnpackedness -> Constr

dataTypeOf :: SourceUnpackedness -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c SourceUnpackedness)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SourceUnpackedness)

gmapT :: (forall b. Data b => b -> b) -> SourceUnpackedness -> SourceUnpackedness

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SourceUnpackedness -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SourceUnpackedness -> r

gmapQ :: (forall d. Data d => d -> u) -> SourceUnpackedness -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> SourceUnpackedness -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SourceUnpackedness -> m SourceUnpackedness

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SourceUnpackedness -> m SourceUnpackedness

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SourceUnpackedness -> m SourceUnpackedness

Ord SourceUnpackedness

Methods

compare :: SourceUnpackedness -> SourceUnpackedness -> Ordering

(<) :: SourceUnpackedness -> SourceUnpackedness -> Bool

(<=) :: SourceUnpackedness -> SourceUnpackedness -> Bool

(>) :: SourceUnpackedness -> SourceUnpackedness -> Bool

(>=) :: SourceUnpackedness -> SourceUnpackedness -> Bool

max :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness

min :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness

Show SourceUnpackedness

Methods

showsPrec :: Int -> SourceUnpackedness -> ShowS

show :: SourceUnpackedness -> String

showList :: [SourceUnpackedness] -> ShowS

Generic SourceUnpackedness

Associated Types

type Rep SourceUnpackedness :: * -> *

Methods

from :: SourceUnpackedness -> Rep SourceUnpackedness x

to :: Rep SourceUnpackedness x -> SourceUnpackedness

Ppr SourceUnpackedness

Methods

ppr :: SourceUnpackedness -> Doc

ppr_list :: [SourceUnpackedness] -> Doc

type Rep SourceUnpackedness

type Rep SourceUnpackedness = D1 (MetaData "SourceUnpackedness" "Language.Haskell.TH.Syntax" "template-haskell" False) ((:+:) (C1 (MetaCons "NoSourceUnpackedness" PrefixI False) U1) ((:+:) (C1 (MetaCons "SourceNoUnpack" PrefixI False) U1) (C1 (MetaCons "SourceUnpack" PrefixI False) U1)))

data SourceStrictness

Constructors

NoSourceStrictness

C a

SourceLazy

C {~}a

SourceStrict

C {!}a

Instances

Eq SourceStrictness

Methods

(==) :: SourceStrictness -> SourceStrictness -> Bool

(/=) :: SourceStrictness -> SourceStrictness -> Bool

Data SourceStrictness

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SourceStrictness -> c SourceStrictness

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SourceStrictness

toConstr :: SourceStrictness -> Constr

dataTypeOf :: SourceStrictness -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c SourceStrictness)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SourceStrictness)

gmapT :: (forall b. Data b => b -> b) -> SourceStrictness -> SourceStrictness

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SourceStrictness -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SourceStrictness -> r

gmapQ :: (forall d. Data d => d -> u) -> SourceStrictness -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> SourceStrictness -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SourceStrictness -> m SourceStrictness

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SourceStrictness -> m SourceStrictness

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SourceStrictness -> m SourceStrictness

Ord SourceStrictness

Methods

compare :: SourceStrictness -> SourceStrictness -> Ordering

(<) :: SourceStrictness -> SourceStrictness -> Bool

(<=) :: SourceStrictness -> SourceStrictness -> Bool

(>) :: SourceStrictness -> SourceStrictness -> Bool

(>=) :: SourceStrictness -> SourceStrictness -> Bool

max :: SourceStrictness -> SourceStrictness -> SourceStrictness

min :: SourceStrictness -> SourceStrictness -> SourceStrictness

Show SourceStrictness

Methods

showsPrec :: Int -> SourceStrictness -> ShowS

show :: SourceStrictness -> String

showList :: [SourceStrictness] -> ShowS

Generic SourceStrictness

Associated Types

type Rep SourceStrictness :: * -> *

Methods

from :: SourceStrictness -> Rep SourceStrictness x

to :: Rep SourceStrictness x -> SourceStrictness

Ppr SourceStrictness

Methods

ppr :: SourceStrictness -> Doc

ppr_list :: [SourceStrictness] -> Doc

type Rep SourceStrictness

type Rep SourceStrictness = D1 (MetaData "SourceStrictness" "Language.Haskell.TH.Syntax" "template-haskell" False) ((:+:) (C1 (MetaCons "NoSourceStrictness" PrefixI False) U1) ((:+:) (C1 (MetaCons "SourceLazy" PrefixI False) U1) (C1 (MetaCons "SourceStrict" PrefixI False) U1)))

data DecidedStrictness

Unlike SourceStrictness and SourceUnpackedness, DecidedStrictness refers to the strictness that the compiler chooses for a data constructor field, which may be different from what is written in source code. See reifyConStrictness for more information.

Constructors

DecidedLazy

DecidedStrict

DecidedUnpack

Instances

Eq DecidedStrictness

Methods

(==) :: DecidedStrictness -> DecidedStrictness -> Bool

(/=) :: DecidedStrictness -> DecidedStrictness -> Bool

Data DecidedStrictness

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DecidedStrictness -> c DecidedStrictness

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DecidedStrictness

toConstr :: DecidedStrictness -> Constr

dataTypeOf :: DecidedStrictness -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c DecidedStrictness)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DecidedStrictness)

gmapT :: (forall b. Data b => b -> b) -> DecidedStrictness -> DecidedStrictness

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DecidedStrictness -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DecidedStrictness -> r

gmapQ :: (forall d. Data d => d -> u) -> DecidedStrictness -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> DecidedStrictness -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> DecidedStrictness -> m DecidedStrictness

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DecidedStrictness -> m DecidedStrictness

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DecidedStrictness -> m DecidedStrictness

Ord DecidedStrictness

Methods

compare :: DecidedStrictness -> DecidedStrictness -> Ordering

(<) :: DecidedStrictness -> DecidedStrictness -> Bool

(<=) :: DecidedStrictness -> DecidedStrictness -> Bool

(>) :: DecidedStrictness -> DecidedStrictness -> Bool

(>=) :: DecidedStrictness -> DecidedStrictness -> Bool

max :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness

min :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness

Show DecidedStrictness

Methods

showsPrec :: Int -> DecidedStrictness -> ShowS

show :: DecidedStrictness -> String

showList :: [DecidedStrictness] -> ShowS

Generic DecidedStrictness

Associated Types

type Rep DecidedStrictness :: * -> *

Methods

from :: DecidedStrictness -> Rep DecidedStrictness x

to :: Rep DecidedStrictness x -> DecidedStrictness

Ppr DecidedStrictness

Methods

ppr :: DecidedStrictness -> Doc

ppr_list :: [DecidedStrictness] -> Doc

type Rep DecidedStrictness

type Rep DecidedStrictness = D1 (MetaData "DecidedStrictness" "Language.Haskell.TH.Syntax" "template-haskell" False) ((:+:) (C1 (MetaCons "DecidedLazy" PrefixI False) U1) ((:+:) (C1 (MetaCons "DecidedStrict" PrefixI False) U1) (C1 (MetaCons "DecidedUnpack" PrefixI False) U1)))

data Con

Constructors

NormalC Name [BangType]

C Int a

RecC Name [VarBangType]

C { v :: Int, w :: a }

InfixC BangType Name BangType

Int :+ a

ForallC [TyVarBndr] Cxt Con

forall a. Eq a => C [a]

GadtC [Name] [BangType] Type

C :: a -> b -> T b Int

RecGadtC [Name] [VarBangType] Type

C :: { v :: Int } -> T b Int

Instances

Eq Con

Methods

(==) :: Con -> Con -> Bool

(/=) :: Con -> Con -> Bool

Data Con

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Con -> c Con

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Con

toConstr :: Con -> Constr

dataTypeOf :: Con -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Con)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Con)

gmapT :: (forall b. Data b => b -> b) -> Con -> Con

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Con -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Con -> r

gmapQ :: (forall d. Data d => d -> u) -> Con -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Con -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Con -> m Con

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Con -> m Con

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Con -> m Con

Ord Con

Methods

compare :: Con -> Con -> Ordering

(<) :: Con -> Con -> Bool

(<=) :: Con -> Con -> Bool

(>) :: Con -> Con -> Bool

(>=) :: Con -> Con -> Bool

max :: Con -> Con -> Con

min :: Con -> Con -> Con

Show Con

Methods

showsPrec :: Int -> Con -> ShowS

show :: Con -> String

showList :: [Con] -> ShowS

Generic Con

Associated Types

type Rep Con :: * -> *

Methods

from :: Con -> Rep Con x

to :: Rep Con x -> Con

Ppr Con

Methods

ppr :: Con -> Doc

ppr_list :: [Con] -> Doc

type Rep Con

type Rep Con = D1 (MetaData "Con" "Language.Haskell.TH.Syntax" "template-haskell" False) ((:+:) ((:+:) (C1 (MetaCons "NormalC" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [BangType])))) ((:+:) (C1 (MetaCons "RecC" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [VarBangType])))) (C1 (MetaCons "InfixC" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 BangType)) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 BangType))))))) ((:+:) (C1 (MetaCons "ForallC" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [TyVarBndr])) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Cxt)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Con))))) ((:+:) (C1 (MetaCons "GadtC" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Name])) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [BangType])) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Type))))) (C1 (MetaCons "RecGadtC" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Name])) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [VarBangType])) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Type))))))))

data Bang

Constructors

Bang SourceUnpackedness SourceStrictness

C { {-# UNPACK #-} !}a

Instances

Eq Bang

Methods

(==) :: Bang -> Bang -> Bool

(/=) :: Bang -> Bang -> Bool

Data Bang

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Bang -> c Bang

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Bang

toConstr :: Bang -> Constr

dataTypeOf :: Bang -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Bang)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Bang)

gmapT :: (forall b. Data b => b -> b) -> Bang -> Bang

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Bang -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Bang -> r

gmapQ :: (forall d. Data d => d -> u) -> Bang -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Bang -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Bang -> m Bang

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Bang -> m Bang

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Bang -> m Bang

Ord Bang

Methods

compare :: Bang -> Bang -> Ordering

(<) :: Bang -> Bang -> Bool

(<=) :: Bang -> Bang -> Bool

(>) :: Bang -> Bang -> Bool

(>=) :: Bang -> Bang -> Bool

max :: Bang -> Bang -> Bang

min :: Bang -> Bang -> Bang

Show Bang

Methods

showsPrec :: Int -> Bang -> ShowS

show :: Bang -> String

showList :: [Bang] -> ShowS

Generic Bang

Associated Types

type Rep Bang :: * -> *

Methods

from :: Bang -> Rep Bang x

to :: Rep Bang x -> Bang

Ppr Bang

Methods

ppr :: Bang -> Doc

ppr_list :: [Bang] -> Doc

type Rep Bang

type Rep Bang = D1 (MetaData "Bang" "Language.Haskell.TH.Syntax" "template-haskell" False) (C1 (MetaCons "Bang" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 SourceUnpackedness)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 SourceStrictness))))

type BangType = (Bang, Type)

type VarBangType = (Name, Bang, Type)

type Strict = Bang

As of template-haskell-2.11.0.0, Strict has been replaced by Bang.

type StrictType = BangType

As of template-haskell-2.11.0.0, StrictType has been replaced by BangType.

type VarStrictType = VarBangType

As of template-haskell-2.11.0.0, VarStrictType has been replaced by VarBangType.

data Type

Constructors

ForallT [TyVarBndr] Cxt Type

forall <vars>. <ctxt> -> <type>

AppT Type Type

T a b

SigT Type Kind

t :: k

VarT Name

a

ConT Name

T

PromotedT Name

'T

InfixT Type Name Type

T + T

UInfixT Type Name Type

T + T

See Language.Haskell.TH.Syntax

ParensT Type

(T)

TupleT Int

(,), (,,), etc.

UnboxedTupleT Int

(#,#), (#,,#), etc.

ArrowT

->

EqualityT

~

ListT

[]

PromotedTupleT Int

'(), '(,), '(,,), etc.

PromotedNilT

'[]

PromotedConsT

(':)

StarT

*

ConstraintT

Constraint

LitT TyLit

0,1,2, etc.

WildCardT

@_,

Instances

Eq Type

Methods

(==) :: Type -> Type -> Bool

(/=) :: Type -> Type -> Bool

Data Type

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Type -> c Type

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Type

toConstr :: Type -> Constr

dataTypeOf :: Type -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Type)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Type)

gmapT :: (forall b. Data b => b -> b) -> Type -> Type

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r

gmapQ :: (forall d. Data d => d -> u) -> Type -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Type -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Type -> m Type

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Type -> m Type

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Type -> m Type

Ord Type

Methods

compare :: Type -> Type -> Ordering

(<) :: Type -> Type -> Bool

(<=) :: Type -> Type -> Bool

(>) :: Type -> Type -> Bool

(>=) :: Type -> Type -> Bool

max :: Type -> Type -> Type

min :: Type -> Type -> Type

Show Type

Methods

showsPrec :: Int -> Type -> ShowS

show :: Type -> String

showList :: [Type] -> ShowS

Generic Type

Associated Types

type Rep Type :: * -> *

Methods

from :: Type -> Rep Type x

to :: Rep Type x -> Type

Ppr Type

Methods

ppr :: Type -> Doc

ppr_list :: [Type] -> Doc

type Rep Type

type Rep Type = D1 (MetaData "Type" "Language.Haskell.TH.Syntax" "template-haskell" False) ((:+:) ((:+:) ((:+:) ((:+:) (C1 (MetaCons "ForallT" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [TyVarBndr])) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Cxt)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Type))))) (C1 (MetaCons "AppT" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Type)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Type))))) ((:+:) (C1 (MetaCons "SigT" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Type)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Kind)))) ((:+:) (C1 (MetaCons "VarT" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name))) (C1 (MetaCons "ConT" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name)))))) ((:+:) ((:+:) (C1 (MetaCons "PromotedT" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name))) (C1 (MetaCons "InfixT" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Type)) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Type)))))) ((:+:) (C1 (MetaCons "UInfixT" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Type)) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Type))))) ((:+:) (C1 (MetaCons "ParensT" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Type))) (C1 (MetaCons "TupleT" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Int))))))) ((:+:) ((:+:) ((:+:) (C1 (MetaCons "UnboxedTupleT" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Int))) (C1 (MetaCons "ArrowT" PrefixI False) U1)) ((:+:) (C1 (MetaCons "EqualityT" PrefixI False) U1) ((:+:) (C1 (MetaCons "ListT" PrefixI False) U1) (C1 (MetaCons "PromotedTupleT" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Int)))))) ((:+:) ((:+:) (C1 (MetaCons "PromotedNilT" PrefixI False) U1) ((:+:) (C1 (MetaCons "PromotedConsT" PrefixI False) U1) (C1 (MetaCons "StarT" PrefixI False) U1))) ((:+:) (C1 (MetaCons "ConstraintT" PrefixI False) U1) ((:+:) (C1 (MetaCons "LitT" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 TyLit))) (C1 (MetaCons "WildCardT" PrefixI False) U1))))))

data TyVarBndr

Constructors

PlainTV Name

a

KindedTV Name Kind

(a :: k)

Instances

Eq TyVarBndr

Methods

(==) :: TyVarBndr -> TyVarBndr -> Bool

(/=) :: TyVarBndr -> TyVarBndr -> Bool

Data TyVarBndr

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TyVarBndr -> c TyVarBndr

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TyVarBndr

toConstr :: TyVarBndr -> Constr

dataTypeOf :: TyVarBndr -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c TyVarBndr)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TyVarBndr)

gmapT :: (forall b. Data b => b -> b) -> TyVarBndr -> TyVarBndr

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyVarBndr -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TyVarBndr -> r

gmapQ :: (forall d. Data d => d -> u) -> TyVarBndr -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> TyVarBndr -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> TyVarBndr -> m TyVarBndr

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TyVarBndr -> m TyVarBndr

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TyVarBndr -> m TyVarBndr

Ord TyVarBndr

Methods

compare :: TyVarBndr -> TyVarBndr -> Ordering

(<) :: TyVarBndr -> TyVarBndr -> Bool

(<=) :: TyVarBndr -> TyVarBndr -> Bool

(>) :: TyVarBndr -> TyVarBndr -> Bool

(>=) :: TyVarBndr -> TyVarBndr -> Bool

max :: TyVarBndr -> TyVarBndr -> TyVarBndr

min :: TyVarBndr -> TyVarBndr -> TyVarBndr

Show TyVarBndr

Methods

showsPrec :: Int -> TyVarBndr -> ShowS

show :: TyVarBndr -> String

showList :: [TyVarBndr] -> ShowS

Generic TyVarBndr

Associated Types

type Rep TyVarBndr :: * -> *

Methods

from :: TyVarBndr -> Rep TyVarBndr x

to :: Rep TyVarBndr x -> TyVarBndr

Ppr TyVarBndr

Methods

ppr :: TyVarBndr -> Doc

ppr_list :: [TyVarBndr] -> Doc

type Rep TyVarBndr

type Rep TyVarBndr = D1 (MetaData "TyVarBndr" "Language.Haskell.TH.Syntax" "template-haskell" False) ((:+:) (C1 (MetaCons "PlainTV" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name))) (C1 (MetaCons "KindedTV" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Kind)))))

data FamilyResultSig

Type family result signature

Constructors

NoSig

no signature

KindSig Kind

k

TyVarSig TyVarBndr

= r, = (r :: k)

Instances

Eq FamilyResultSig

Methods

(==) :: FamilyResultSig -> FamilyResultSig -> Bool

(/=) :: FamilyResultSig -> FamilyResultSig -> Bool

Data FamilyResultSig

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FamilyResultSig -> c FamilyResultSig

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FamilyResultSig

toConstr :: FamilyResultSig -> Constr

dataTypeOf :: FamilyResultSig -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c FamilyResultSig)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FamilyResultSig)

gmapT :: (forall b. Data b => b -> b) -> FamilyResultSig -> FamilyResultSig

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FamilyResultSig -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FamilyResultSig -> r

gmapQ :: (forall d. Data d => d -> u) -> FamilyResultSig -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> FamilyResultSig -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FamilyResultSig -> m FamilyResultSig

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FamilyResultSig -> m FamilyResultSig

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FamilyResultSig -> m FamilyResultSig

Ord FamilyResultSig

Methods

compare :: FamilyResultSig -> FamilyResultSig -> Ordering

(<) :: FamilyResultSig -> FamilyResultSig -> Bool

(<=) :: FamilyResultSig -> FamilyResultSig -> Bool

(>) :: FamilyResultSig -> FamilyResultSig -> Bool

(>=) :: FamilyResultSig -> FamilyResultSig -> Bool

max :: FamilyResultSig -> FamilyResultSig -> FamilyResultSig

min :: FamilyResultSig -> FamilyResultSig -> FamilyResultSig

Show FamilyResultSig

Methods

showsPrec :: Int -> FamilyResultSig -> ShowS

show :: FamilyResultSig -> String

showList :: [FamilyResultSig] -> ShowS

Generic FamilyResultSig

Associated Types

type Rep FamilyResultSig :: * -> *

Methods

from :: FamilyResultSig -> Rep FamilyResultSig x

to :: Rep FamilyResultSig x -> FamilyResultSig

Ppr FamilyResultSig

Methods

ppr :: FamilyResultSig -> Doc

ppr_list :: [FamilyResultSig] -> Doc

type Rep FamilyResultSig

type Rep FamilyResultSig = D1 (MetaData "FamilyResultSig" "Language.Haskell.TH.Syntax" "template-haskell" False) ((:+:) (C1 (MetaCons "NoSig" PrefixI False) U1) ((:+:) (C1 (MetaCons "KindSig" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Kind))) (C1 (MetaCons "TyVarSig" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 TyVarBndr)))))

data InjectivityAnn

Injectivity annotation

Constructors

InjectivityAnn Name [Name]

Instances

Eq InjectivityAnn

Methods

(==) :: InjectivityAnn -> InjectivityAnn -> Bool

(/=) :: InjectivityAnn -> InjectivityAnn -> Bool

Data InjectivityAnn

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> InjectivityAnn -> c InjectivityAnn

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c InjectivityAnn

toConstr :: InjectivityAnn -> Constr

dataTypeOf :: InjectivityAnn -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c InjectivityAnn)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c InjectivityAnn)

gmapT :: (forall b. Data b => b -> b) -> InjectivityAnn -> InjectivityAnn

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> InjectivityAnn -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> InjectivityAnn -> r

gmapQ :: (forall d. Data d => d -> u) -> InjectivityAnn -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> InjectivityAnn -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> InjectivityAnn -> m InjectivityAnn

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> InjectivityAnn -> m InjectivityAnn

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> InjectivityAnn -> m InjectivityAnn

Ord InjectivityAnn

Methods

compare :: InjectivityAnn -> InjectivityAnn -> Ordering

(<) :: InjectivityAnn -> InjectivityAnn -> Bool

(<=) :: InjectivityAnn -> InjectivityAnn -> Bool

(>) :: InjectivityAnn -> InjectivityAnn -> Bool

(>=) :: InjectivityAnn -> InjectivityAnn -> Bool

max :: InjectivityAnn -> InjectivityAnn -> InjectivityAnn

min :: InjectivityAnn -> InjectivityAnn -> InjectivityAnn

Show InjectivityAnn

Methods

showsPrec :: Int -> InjectivityAnn -> ShowS

show :: InjectivityAnn -> String

showList :: [InjectivityAnn] -> ShowS

Generic InjectivityAnn

Associated Types

type Rep InjectivityAnn :: * -> *

Methods

from :: InjectivityAnn -> Rep InjectivityAnn x

to :: Rep InjectivityAnn x -> InjectivityAnn

Ppr InjectivityAnn

Methods

ppr :: InjectivityAnn -> Doc

ppr_list :: [InjectivityAnn] -> Doc

type Rep InjectivityAnn

type Rep InjectivityAnn = D1 (MetaData "InjectivityAnn" "Language.Haskell.TH.Syntax" "template-haskell" False) (C1 (MetaCons "InjectivityAnn" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Name]))))

data TyLit

Constructors

NumTyLit Integer

2

StrTyLit String

Hello

Instances

Eq TyLit

Methods

(==) :: TyLit -> TyLit -> Bool

(/=) :: TyLit -> TyLit -> Bool

Data TyLit

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TyLit -> c TyLit

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TyLit

toConstr :: TyLit -> Constr

dataTypeOf :: TyLit -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c TyLit)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TyLit)

gmapT :: (forall b. Data b => b -> b) -> TyLit -> TyLit

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyLit -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TyLit -> r

gmapQ :: (forall d. Data d => d -> u) -> TyLit -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> TyLit -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> TyLit -> m TyLit

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TyLit -> m TyLit

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TyLit -> m TyLit

Ord TyLit

Methods

compare :: TyLit -> TyLit -> Ordering

(<) :: TyLit -> TyLit -> Bool

(<=) :: TyLit -> TyLit -> Bool

(>) :: TyLit -> TyLit -> Bool

(>=) :: TyLit -> TyLit -> Bool

max :: TyLit -> TyLit -> TyLit

min :: TyLit -> TyLit -> TyLit

Show TyLit

Methods

showsPrec :: Int -> TyLit -> ShowS

show :: TyLit -> String

showList :: [TyLit] -> ShowS

Generic TyLit

Associated Types

type Rep TyLit :: * -> *

Methods

from :: TyLit -> Rep TyLit x

to :: Rep TyLit x -> TyLit

Ppr TyLit

Methods

ppr :: TyLit -> Doc

ppr_list :: [TyLit] -> Doc

type Rep TyLit

type Rep TyLit = D1 (MetaData "TyLit" "Language.Haskell.TH.Syntax" "template-haskell" False) ((:+:) (C1 (MetaCons "NumTyLit" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Integer))) (C1 (MetaCons "StrTyLit" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String))))

data Role

Role annotations

Constructors

NominalR

nominal

RepresentationalR

representational

PhantomR

phantom

InferR

_

Instances

Eq Role

Methods

(==) :: Role -> Role -> Bool

(/=) :: Role -> Role -> Bool

Data Role

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Role -> c Role

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Role

toConstr :: Role -> Constr

dataTypeOf :: Role -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Role)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Role)

gmapT :: (forall b. Data b => b -> b) -> Role -> Role

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Role -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Role -> r

gmapQ :: (forall d. Data d => d -> u) -> Role -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Role -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Role -> m Role

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Role -> m Role

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Role -> m Role

Ord Role

Methods

compare :: Role -> Role -> Ordering

(<) :: Role -> Role -> Bool

(<=) :: Role -> Role -> Bool

(>) :: Role -> Role -> Bool

(>=) :: Role -> Role -> Bool

max :: Role -> Role -> Role

min :: Role -> Role -> Role

Show Role

Methods

showsPrec :: Int -> Role -> ShowS

show :: Role -> String

showList :: [Role] -> ShowS

Generic Role

Associated Types

type Rep Role :: * -> *

Methods

from :: Role -> Rep Role x

to :: Rep Role x -> Role

Ppr Role

Methods

ppr :: Role -> Doc

ppr_list :: [Role] -> Doc

type Rep Role

type Rep Role = D1 (MetaData "Role" "Language.Haskell.TH.Syntax" "template-haskell" False) ((:+:) ((:+:) (C1 (MetaCons "NominalR" PrefixI False) U1) (C1 (MetaCons "RepresentationalR" PrefixI False) U1)) ((:+:) (C1 (MetaCons "PhantomR" PrefixI False) U1) (C1 (MetaCons "InferR" PrefixI False) U1)))

data AnnLookup

Annotation target for reifyAnnotations

Constructors

AnnLookupModule Module

AnnLookupName Name

Instances

Eq AnnLookup

Methods

(==) :: AnnLookup -> AnnLookup -> Bool

(/=) :: AnnLookup -> AnnLookup -> Bool

Data AnnLookup

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AnnLookup -> c AnnLookup

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AnnLookup

toConstr :: AnnLookup -> Constr

dataTypeOf :: AnnLookup -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c AnnLookup)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AnnLookup)

gmapT :: (forall b. Data b => b -> b) -> AnnLookup -> AnnLookup

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AnnLookup -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AnnLookup -> r

gmapQ :: (forall d. Data d => d -> u) -> AnnLookup -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> AnnLookup -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> AnnLookup -> m AnnLookup

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnLookup -> m AnnLookup

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnLookup -> m AnnLookup

Ord AnnLookup

Methods

compare :: AnnLookup -> AnnLookup -> Ordering

(<) :: AnnLookup -> AnnLookup -> Bool

(<=) :: AnnLookup -> AnnLookup -> Bool

(>) :: AnnLookup -> AnnLookup -> Bool

(>=) :: AnnLookup -> AnnLookup -> Bool

max :: AnnLookup -> AnnLookup -> AnnLookup

min :: AnnLookup -> AnnLookup -> AnnLookup

Show AnnLookup

Methods

showsPrec :: Int -> AnnLookup -> ShowS

show :: AnnLookup -> String

showList :: [AnnLookup] -> ShowS

Generic AnnLookup

Associated Types

type Rep AnnLookup :: * -> *

Methods

from :: AnnLookup -> Rep AnnLookup x

to :: Rep AnnLookup x -> AnnLookup

type Rep AnnLookup

type Rep AnnLookup = D1 (MetaData "AnnLookup" "Language.Haskell.TH.Syntax" "template-haskell" False) ((:+:) (C1 (MetaCons "AnnLookupModule" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Module))) (C1 (MetaCons "AnnLookupName" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name))))

type Kind = Type

To avoid duplication between kinds and types, they are defined to be the same. Naturally, you would never have a type be StarT and you would never have a kind be SigT, but many of the other constructors are shared. Note that the kind Bool is denoted with ConT, not PromotedT. Similarly, tuple kinds are made with TupleT, not PromotedTupleT.

cmpEq :: Ordering -> Bool

thenCmp :: Ordering -> Ordering -> Ordering

Language extensions

module Language.Haskell.TH.LanguageExtensions