Language.Haskell.TH

Моноид и его операции

data Q a Исходный код

runQ :: Quasi m => Q a -> m a Исходный код

Администрирование: ошибки, местоположения и IO

reportError :: String -> Q () Исходный код

Сообщите пользователю об ошибке, но позвольте текущему вычислению продолжить работу. Чтобы прервать вычисление, используйте fail.

reportWarning :: String -> Q () Исходный код

Сообщите пользователю об предупреждении и продолжите работу.

report :: Bool -> String -> Q () Исходный код

Сообщите об ошибке (True) или предупреждении (False), но продолжайте; используйте fail для остановки.

recover Исходный код

Восстановиться от ошибок, поднятых reportError или fail.

location :: Q Loc Исходный код

Местоположение, в котором выполняется данное вычисление.

data Loc Исходный код

runIO :: IO a -> Q a Исходный код

Функция runIO позволяет запускать вычисление I/O в моноиде Q. Обратите внимание: вам гарантируется порядок вызовов runIO внутри одного вычисления Q, но не порядок, в котором выполняются вставки.

Примечание: по разным причинам, ручки stdout и stderr не обязательно сбрасываются, когда компилятор завершает работу, поэтому вам нужно сбросить их самостоятельно.

Запрос к компилятору

Reify

reify :: Name -> Q Info Исходный код

reify извлекает информацию о Name.

thisModule :: Q Модуль Исходный код

Возвращает Модуль в месте вставки. Может быть использован в качестве входного параметра для reifyModule.

data Info Исходный код

Получено из reify в Q монаде.

data ModuleInfo Исходный код

Получено из reifyModule в Q монаде.

type InstanceDec = Dec Исходный код

InstanceDec описывает один экземпляр класса или функционала типа. Это просто Dec, но гарантируется, что он будет одним из следующих:

• InstanceD (с пустым [Dec])
• DataInstD или NewtypeInstD (с пустым производным [Name])
• TySynInstD

type ParentName = Имя Исходный код

В ClassOpI и DataConI, имя родительского класса или типа.

type Арность = Int Исходный код

В PrimTyConI, арность конструктора типа.

type Неподнятый = Bool Исходный код

В PrimTyConI, конструктор типа неподнятого типа?

Поиск имени

lookupTypeName :: Строка -> Q (МожетБыть Имя) Исходный код

Ищет заданное имя в области видимости текущей вставки (пространство имен типов). Для получения более подробной информации см. Language.Haskell.TH.Syntax.

lookupValueName :: Строка -> Q (МожетБыть Имя) Исходный код

Ищет заданное имя в области видимости текущей вставки (пространство имен значений). Для получения более подробной информации см. Language.Haskell.TH.Syntax.

Поиск экземпляра

reifyInstances :: Имя -> [Тип] -> Q [InstanceDec] Исходный код

reifyInstances nm tys возвращает список видимых экземпляров nm tys. То есть, если nm — имя класса типа, то возвращаются все экземпляры этого класса для типов tys. В противном случае, если nm — имя семейства данных или семейства типов, возвращаются все экземпляры этого семейства для типов tys.

isInstance :: Имя -> [Тип] -> Q Bool Исходный код

Является ли список экземпляров, возвращаемый reifyInstances, непустым?

Поиск ролей

reifyRoles :: Имя -> Q [Роль] Исходный код

reifyRoles nm возвращает список ролей, связанных с параметрами тикона nm. Возникает ошибка, если nm не найден или не является тиконом. Возвращаемый список никогда не должен содержать InferR.

Поиск аннотаций

reifyAnnotations :: Data a => AnnLookup -> Q [a] Исходный код

reifyAnnotations target возвращает список аннотаций, связанных с target. Возвращаются только аннотации с правильным типом. Если у вас есть аннотации Int и String для одной и той же цели, вы должны вызвать эту функцию дважды.

data AnnLookup Исходный код

Цель аннотации для reifyAnnotations

Типизированные выражения

data TExp a Исходный код

unType :: TExp a -> Выражение Исходный код

Имена

data Имя Исходный код

Абстрактный тип, представляющий имена в синтаксическом дереве.

Name можно создать несколькими способами, которые предоставляют различные гарантии захвата имен (см. Language.Haskell.TH.Syntax для объяснения захвата имен):

• Встроенный синтаксис 'f и ''T могут использоваться для создания имен. Выражение 'f дает Name, которое ссылается на значение f в текущей области видимости, а ''T дает Name, которое ссылается на тип T в текущей области видимости. Эти имена никогда не могут быть захвачены.
• lookupValueName и lookupTypeName аналогичны 'f и ''T соответственно, но Name ищутся в момент выполнения текущей вставки. Эти имена никогда не могут быть захвачены.
• newName монадным способом генерирует новое имя, которое никогда не может быть захвачено.
• mkName генерирует имя, которое может быть захвачено.

Имена, созданные с помощью newName и mkName , могут использоваться в связываниях (например, let x = ... или x -> ...), но имена, созданные с помощью lookupValueName, lookupTypeName, 'f, ''T, не могут.

data ПространствоИмен Исходный код

Создание имен

mkName :: Строка -> Имя Исходный код

Генерирует имя, которое может быть захвачено. Вхождения таких имен будут разрешаться в соответствии с правилами области видимости Haskell в месте вхождения.

Например:

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

В этом случае, g преобразуется в

g = Prelude.pi + 3

Обратите внимание, что mkName может использоваться с квалифицированными именами:

mkName "Prelude.pi"

См. также dyn для полезного комбинатора. Приведенный выше пример можно переписать с помощью dyn как

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

newName :: Строка -> Q Имя Исходный код

Генерирует свежее имя, которое не может быть захвачено.

Например, это:

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

сгенерирует вставку

f = \x0 -> \x -> x0

В частности, вхождение VarE nm1 относится к связыванию VarP nm1, и не захватывается связыванием VarP nm2.

Хотя имена, сгенерированные с помощью newName , не могут быть захвачены, они могут захватить другие имена. Например, это:

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

сгенерирует вставку

g = \x -> \x0 -> x0

так как вхождение VarE nm2 захватывается самым внутренним связыванием x, а именно VarP nm1.

Разобрать имена

nameBase :: Имя -> Строка Исходный код

Имя без префикса модуля

nameModule :: Имя -> МожетБыть Строка Исходный код

Префикс модуля имени, если он существует

Встроенные имена

tupleTypeName :: ЦелоеЧисло -> Имя Исходный код

Конструктор кортежного типа

tupleDataName :: Int -> Name Source

Конструктор данных кортежа

unboxedTupleTypeName :: Int -> Name Source

Конструктор типов нераспакованных кортежей

unboxedTupleDataName :: Int -> Name Source

Конструктор данных нераспакованных кортежей

Алгебраические типы данных

Предпочтительнее использовать строчные версии (операторы синтаксиса) этих конструкторов, поскольку они лучше сочетаются с цитатами ([| |]) и вставками ($( ... ))

Объявления

data Dec Source

{ f p1 p2 = b where decs }

{ p = b where decs }

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

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

{ type T x = (x,x) }

{ class Eq a => Ord a where ds }

{ instance Show w => Show [w]
       where ds }

{ length :: [a] -> Int }

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

{ infix 3 foo }

{ {--} }

{ type family T a b c :: * }

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

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

{ type instance ... }

{ type family F a b :: * where ... }

{ type role T nominal representational }

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

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

data Con Source

C Int a

C { v :: Int, w :: a }

Int :+ a

forall a. Eq a => C [a]

data Clause Source

f { p1 p2 = body where decs }

data Strict Source

data Foreign Source

data Callconv Source

data Безопасность Source

data Директива Source

data Inline Источник

data RuleMatch Источник

data Этапы Источник

data RuleBndr Источник

data Целевая аннотация Источник

data FunDep Source

data FamFlavour Source

data TySynEqn Source

Одно уравнение экземпляра семейства типов или закрытого семейства типов. Аргументы — это шаблоны типов левой части и результат правой части.

data Fixity Source

data НаправлениеФиксирования Source

defaultFixity :: Fixity Source

Значение по умолчанию для фиксированности: infixl 9

maxPrecedence :: Int Source

Максимальный разрешённый приоритет оператора для Fixity конструктора (ответ: 9)

Выражения

data Exp Source

{ x }

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

{ 5 or c}

{ f x }

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

{x + y}

{ (e) }

{  p1 p2 -> e }

{ case m1; m2 }

{ (e1,e2) }

{ () }

{ if e1 then e2 else e3 }

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

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

{ case e of m1; m2 }

{ do { p <- e1; e2 }  }

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

[ f x | x <- xs ]

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

{ [ 1 ,2 .. 10 ] }

{ [1,2,3] }

{ e :: t }

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

{ (f x) { z = w } }

{ static e }

data Сопоставление Источник

case e of { pat -> body where decs }

data Тело Источник

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

f p { = e } where ds

data Условие Источник

f x { | odd x } = x

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

data Оператор Источник

data Диапазон Источник

data Литерал Источник

Шаблоны

data Шаблон Источник

Шаблон в Haskell, указанный в {}

{ 5 or c }

{ x }

{ (p1,p2) }

{ () }

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

foo ({x :+ y}) = e

foo ({x :+ y}) = e

{(p)}

{ ~p }

{ !p }

{ x @ p }

{ _ }

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

{ [1,2,3] }

{ p :: t }

{ e -> p }

type FieldExp = (Name, Exp) Источник

type FieldPat = (Name, Pat) Источник

Типы

data Type Источник

forall <vars>. <ctxt> -> <type>

T a b

t :: k

a

T

'T

(,), (,,), etc.

(), (), etc.

->

~

[]

'(), '(,), '(,,), etc.

'[]

(':)

*

Constraint

0,1,2, etc.

data TyVarBndr Источник

a

(a :: k)

data TyLit Source

2

Hello

type Kind = Type Source

Для избежания дублирования между типами и видами, они определены одинаково. Естественно, у вас никогда не будет тип являться StarT, и у вас никогда не будет вид являться SigT, но многие другие конструкторы общие. Обратите внимание, что вид Bool обозначается ConT, а не PromotedT. Аналогично, кортежи видов создаются с помощью TupleT, а не PromotedTupleT.

type Cxt Source

(Eq a, Ord b)

type Pred = Type Source

С появлением ConstraintKinds, ограничения — это всего лишь типы. Ограничения равенства используют конструктор EqualityT. Ограничения также могут быть кортежами других ограничений.

data Role Source

Аннотации роли

nominal

representational

phantom

_

Функции библиотеки

Аббревиатуры

type InfoQ = Q Info Source

type ExpQ = Q Exp Source

type DecQ = Q Dec Source

type DecsQ = Q [Dec] Source

type ConQ = Q Con Source

type TypeQ = Q Type Source

type TyLitQ = Q TyLit Source

type CxtQ = Q Cxt Source

type PredQ = Q Pred Source

type MatchQ = Q Match Source

type ClauseQ = Q Clause Source

type BodyQ = Q Body Source

type GuardQ = Q Guard Source

type StmtQ = Q Stmt Source

type RangeQ = Q Range Source

type StrictTypeQ = Q StrictType Source

type VarStrictTypeQ = Q VarStrictType Source

type PatQ = Q Паттерн Source

type FieldPatQ = Q FieldPat Source

type RuleBndrQ = Q RuleBndr Source

type TySynEqnQ = Q TySynEqn Source

Конструкторы, поднятые до Q

Литералы

intPrimL :: Целое -> Лит Source

wordPrimL :: Целое -> Лит Source

floatPrimL :: Рациональное -> Лит Source

doublePrimL :: Рациональное -> Лит Source

integerL :: Целое -> Лит Source

rationalL :: Рациональное -> Лит Source

charL :: Символ -> Лит Source

stringL :: Строка -> Лит Source

stringPrimL :: [Word8] -> Лит Source

Паттерны

litP :: Лит -> PatQ Source

varP :: Имя -> PatQ Source

tupP :: [PatQ] -> PatQ Source

conP :: Имя -> [PatQ] -> PatQ Source

uInfixP :: PatQ -> Имя -> PatQ -> PatQ Source

parensP :: PatQ -> PatQ Source

infixP :: PatQ -> Имя -> PatQ -> PatQ Source

tildeP :: PatQ -> PatQ Source

bangP :: PatQ -> PatQ Source

asP :: Имя -> PatQ -> PatQ Source

wildP :: PatQ Source

recP :: Имя -> [FieldPatQ] -> PatQ Source

listP :: [PatQ] -> PatQ Source

sigP :: PatQ -> TypeQ -> PatQ Source

viewP :: ExpQ -> PatQ -> PatQ Source

fieldPat :: Имя -> PatQ -> FieldPatQ Source

Защитные условия для паттернов

normalB :: ExpQ -> BodyQ Source

guardedB :: [Q (Защита, Выражение)] -> BodyQ Source

normalG :: ExpQ -> GuardQ Source

normalGE :: ExpQ -> ExpQ -> Q (Guard, Exp) Source

patG :: [StmtQ] -> GuardQ Source

patGE :: [StmtQ] -> ExpQ -> Q (Guard, Exp) Source

match :: PatQ -> BodyQ -> [DecQ] -> MatchQ Source

Использование с caseE

clause :: [PatQ] -> BodyQ -> [DecQ] -> ClauseQ Source

Использование с funD

Выражения

dyn :: String -> ExpQ Source

Динамическое связывание переменной (негигиенично)

global :: Name -> ExpQ Source

varE :: Name -> ExpQ Source

conE :: Name -> ExpQ Source

litE :: Lit -> ExpQ Source

appE :: ExpQ -> ExpQ -> ExpQ Source

uInfixE :: ExpQ -> ExpQ -> ExpQ -> ExpQ Source

parensE :: ExpQ -> ExpQ Source

staticE :: ExpQ -> ExpQ Source

staticE x = [| static x |]

infixE :: Maybe ExpQ -> ExpQ -> Maybe ExpQ -> ExpQ Source

infixApp :: ExpQ -> ExpQ -> ExpQ -> ExpQ Source

sectionL :: ExpQ -> ExpQ -> ExpQ Source

sectionR :: ExpQ -> ExpQ -> ExpQ Source

lamE :: [PatQ] -> ExpQ -> ExpQ Source

lam1E :: PatQ -> ExpQ -> ExpQ Source

Одноаргументная лямбда

lamCaseE :: [MatchQ] -> ExpQ Source

tupE :: [ExpQ] -> ExpQ Source

condE :: ExpQ -> ExpQ -> ExpQ -> ExpQ Source

multiIfE :: [Q (Guard, Exp)] -> ExpQ Source

letE :: [DecQ] -> ExpQ -> ExpQ Source

caseE :: ExpQ -> [MatchQ] -> ExpQ Source

appsE :: [ExpQ] -> ExpQ Source

listE :: [ExpQ] -> ExpQ Source

sigE :: ExpQ -> TypeQ -> ExpQ Source

recConE :: Name -> [Q (Name, Exp)] -> ExpQ Source

recUpdE :: ExpQ -> [Q (Имя, Exp)] -> ExpQ Источник

stringE :: Строка -> ExpQ Источник

fieldExp :: Имя -> ExpQ -> Q (Имя, Exp) Источник

Диапазоны

fromE :: ExpQ -> ExpQ Источник

fromThenE :: ExpQ -> ExpQ -> ExpQ Источник

fromToE :: ExpQ -> ExpQ -> ExpQ Источник

fromThenToE :: ExpQ -> ExpQ -> ExpQ -> ExpQ Источник

Диапазоны с большей косвенностью

arithSeqE :: RangeQ -> ExpQ Источник

fromR :: ExpQ -> RangeQ Источник

fromThenR :: ExpQ -> ExpQ -> RangeQ Источник

fromToR :: ExpQ -> ExpQ -> RangeQ Источник

fromThenToR :: ExpQ -> ExpQ -> ExpQ -> RangeQ Источник

Операторы

doE :: [StmtQ] -> ExpQ Источник

compE :: [StmtQ] -> ExpQ Источник

bindS :: PatQ -> ExpQ -> StmtQ Источник

letS :: [DecQ] -> StmtQ Источник

noBindS :: ExpQ -> StmtQ Источник

parS :: [[StmtQ]] -> StmtQ Источник

Типы

forallT :: [TyVarBndr] -> CxtQ -> TypeQ -> TypeQ Источник

varT :: Имя -> TypeQ Источник

conT :: Имя -> TypeQ Источник

appT :: TypeQ -> TypeQ -> TypeQ Источник

arrowT :: TypeQ Источник

equalityT :: TypeQ Источник

listT :: TypeQ Источник

tupleT :: Целое -> TypeQ Источник

sigT :: TypeQ -> Kind -> TypeQ Источник

litT :: TyLitQ -> TypeQ Источник

promotedT :: Имя -> TypeQ Источник

promotedTupleT :: Целое -> TypeQ Источник

promotedNilT :: TypeQ Источник

promotedConsT :: TypeQ Источник

Литералы типов

numTyLit :: Целое -> TyLitQ Источник

strTyLit :: Строка -> TyLitQ Источник

Строгость

isStrict :: Q Strict Источник

notStrict :: Q Strict Источник

strictType :: Q Strict -> TypeQ -> StrictTypeQ Источник

varStrictType :: Имя -> StrictTypeQ -> VarStrictTypeQ Источник

Контексты классов

cxt :: [PredQ] -> CxtQ Источник

classP :: Имя -> [Q Тип] -> Q Pred Источник

equalP :: TypeQ -> TypeQ -> PredQ Источник

normalC :: Имя -> [StrictTypeQ] -> ConQ Источник

recC :: Имя -> [VarStrictTypeQ] -> ConQ Источник

infixC :: Q (Strict, Тип) -> Имя -> Q (Strict, Тип) -> ConQ Источник

forallC :: [TyVarBndr] -> CxtQ -> ConQ -> ConQ Источник

Виды

varK :: Имя -> Вид Источник

conK :: Имя -> Вид Источник

tupleK :: Целое -> Вид Источник

arrowK :: Вид Источник

listK :: Вид Источник

appK :: Вид -> Вид -> Вид Источник

starK :: Вид Источник

constraintK :: Вид Источник

Роли

nominalR :: Роль Источник

representationalR :: Роль Источник

phantomR :: Роль Источник

inferR :: Роль Источник

Декларации верхнего уровня

Данные

valD :: PatQ -> BodyQ -> [DecQ] -> DecQ Источник

funD :: Имя -> [ClauseQ] -> DecQ Источник

tySynD :: Имя -> [TyVarBndr] -> TypeQ -> DecQ Источник

dataD :: CxtQ -> Имя -> [TyVarBndr] -> [ConQ] -> [Имя] -> DecQ Источник

newtypeD :: CxtQ -> Имя -> [TyVarBndr] -> ConQ -> [Имя] -> DecQ Источник

Класс

classD :: CxtQ -> Name -> [TyVarBndr] -> [FunDep] -> [DecQ] -> DecQ Источник

instanceD :: CxtQ -> TypeQ -> [DecQ] -> DecQ Источник

sigD :: Name -> TypeQ -> DecQ Источник

standaloneDerivD :: CxtQ -> TypeQ -> DecQ Источник

defaultSigD :: Name -> TypeQ -> DecQ Источник

Аннотации ролей

roleAnnotD :: Name -> [Role] -> DecQ Источник

Семейство типов/семейство данных

familyNoKindD :: FamFlavour -> Name -> [TyVarBndr] -> DecQ Источник

familyKindD :: FamFlavour -> Name -> [TyVarBndr] -> Kind -> DecQ Источник

dataInstD :: CxtQ -> Name -> [TypeQ] -> [ConQ] -> [Name] -> DecQ Источник

closedTypeFamilyNoKindD :: Name -> [TyVarBndr] -> [TySynEqnQ] -> DecQ Источник

closedTypeFamilyKindD :: Name -> [TyVarBndr] -> Kind -> [TySynEqnQ] -> DecQ Источник

newtypeInstD :: CxtQ -> Name -> [TypeQ] -> ConQ -> [Name] -> DecQ Источник

tySynInstD :: Name -> TySynEqnQ -> DecQ Источник

typeFam :: FamFlavour Источник

dataFam :: FamFlavour Источник

tySynEqn :: [TypeQ] -> TypeQ -> TySynEqnQ Источник

Интерфейс внешней функции (FFI)

cCall :: Callconv Источник

stdCall :: Callconv Источник

cApi :: Callconv Источник

prim :: Callconv Источник

javaScript :: Callconv Источник

unsafe :: Safety Источник

safe :: Safety Источник

forImpD :: Callconv -> Safety -> String -> Name -> TypeQ -> DecQ Источник

Директивы

ruleVar :: Name -> RuleBndrQ Источник

typedRuleVar :: Name -> TypeQ -> RuleBndrQ Источник

pragInlD :: Name -> Inline -> RuleMatch -> Phases -> DecQ Источник

pragSpecD :: Name -> TypeQ -> Phases -> DecQ Источник

pragSpecInlD :: Имя -> ТипQ -> Вставка -> Фазы -> DecQ Исходный код

pragSpecInstD :: ТипQ -> DecQ Исходный код

pragRuleD :: Строка -> [RuleBndrQ] -> ExpQ -> ExpQ -> Фазы -> DecQ Исходный код

pragAnnD :: AnnTarget -> ExpQ -> DecQ Исходный код

pragLineD :: Целое -> Строка -> DecQ Исходный код

Форматировщик

class Ppr a where Исходный код

pprint :: Ppr a => a -> Строка Исходный код

pprExp :: Уровень приоритета -> Выражение -> Документ Исходный код

pprLit :: Уровень приоритета -> Литерал -> Документ Исходный код

pprPat :: Уровень приоритета -> Шаблон -> Документ Исходный код

pprParendType :: Тип -> Документ Исходный код