Moduletemplate-haskell-2.22.0.0Haskell2010

Language.Haskell.TH.Quote

Template Haskell supports quasiquoting, which permits users to construct program fragments by directly writing concrete syntax. A quasiquoter is essentially a function with takes a string to a Template Haskell AST. This module defines the QuasiQuoter datatype, which specifies a quasiquoter q which can be invoked using the syntax [q| ... string to parse ... |] when the QuasiQuotes language extension is enabled, and some utility functions for manipulating quasiquoters. Nota bene: this package does not define any parsers, that is up to you.

1 type
4 values

Packagetemplate-haskell-2.22.0.0
Exports5
LanguageHaskell2010
LicenceBSD-3-Clause
SourceQuote.hs

datadata QuasiQuoter

The QuasiQuoter type, a value q of this type can be used in the syntax [q| ... string to parse ...|]. In fact, for convenience, a QuasiQuoter actually defines multiple quasiquoters to be used in different splice contexts; if you are only interested in defining a quasiquoter to be used for expressions, you would define a QuasiQuoter with only quoteExp, and leave the other fields stubbed out with errors.

Constructors

QuasiQuoter
- quoteExp :: String -> Q Exp
  Quasi-quoter for expressions, invoked by quotes like lhs = $[q|...]
- quotePat :: String -> Q Pat
  Quasi-quoter for patterns, invoked by quotes like f $[q|...] = rhs
- quoteType :: String -> Q Type
  Quasi-quoter for types, invoked by quotes like f :: $[q|...]
- quoteDec :: String -> Q [Dec]
  Quasi-quoter for declarations, invoked by top-level quotes

valuequoteFile :: QuasiQuoter -> QuasiQuoter

quoteFile takes a QuasiQuoter and lifts it into one that read the data out of a file. For example, suppose asmq is an assembly-language quoter, so that you can write [asmq| ld r1, r2 |] as an expression. Then if you define asmq_f = quoteFile asmq, then the quote [asmq_f|foo.s|] will take input from file "foo.s" instead of the inline text

For backwards compatibility

3 declarations

valuedataToQa

:: (Quote m, Data a)
=> Name -> k
-> Lit -> m q
-> k -> [m q] -> m q
-> forall b. Data b => b -> Maybe (m q)
-> a
-> m 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.

valuedataToExpQ

:: (Quote m, Data a)
=> forall b. Data b => b -> Maybe (m Exp)
-> a
-> m Exp

dataToExpQ converts a value to a 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.

valuedataToPatQ

:: (Quote m, Data a)
=> forall b. Data b => b -> Maybe (m Pat)
-> a
-> m Pat

dataToPatQ converts a value to a 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.