Language.Haskell.TH.Syntax

class Monad m => Quasi m where Source

badIO :: String -> IO a Source

counter :: IORef Int Source

newtype Q a Source

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

newtype TExp a Source

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

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

newName :: String -> Q Name Source

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

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

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.

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

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

reportError :: String -> Q () Source

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

reportWarning :: String -> Q () Source

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

recover Source

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

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

lookupTypeName :: String -> Q (Maybe Name) Source

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

lookupValueName :: String -> Q (Maybe Name) Source

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

Функции lookupTypeName и lookupValueName предоставляют способ запросить контекст текущего сплейса для определения имен, находящихся в области видимости. Функция lookupTypeName запрашивает пространство имен типов, а lookupValueName запрашивает пространство имен значений, но функции в остальном идентичны.

Вызов lookupValueName s проверит, существует ли значение с именем s в области видимости в текущей позиции сплейса. Если существует, то Name этого значения возвращается; если нет, то возвращается Nothing.

Возвращаемое имя не может быть "захвачено". Например:

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

В этом случае g = "global"; вызов lookupValueName вернул глобальное f, и это имя не было захвачено локальным определением f.

Поиск выполняется в контексте главного сплейса, который выполняется. Например:

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

Опять же в этом примере g = "global", поскольку вызов lookupValueName запрашивает контекст самого внешнего $(...).

Операторы должны быть запрошены без каких-либо окружающих скобок, например:

lookupValueName "+"

Также поддерживаются квалифицированные имена, например:

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

reify :: Name -> Q Info Source

reify получает информацию о Name.

Иногда полезно построить имя аргумента, используя lookupTypeName или lookupValueName для обеспечения того, что мы выполняем реификацию из правильного пространства имен. Например, в этом контексте:

data D = D

Что D делает reify (mkName "D") возвращать информацию о? (Ответ: D-тип, но не полагайтесь на это.) Чтобы получить информацию о D-значение, используйте lookupValueName:

do
  Just nm <- lookupValueName "D"
  reify nm

и чтобы получить информацию о D-тип, используйте lookupTypeName.

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

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

reifyRoles :: Name -> Q [Role] Source

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

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

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

reifyModule :: Module -> Q ModuleInfo Source

reifyModule mod получает информацию о модуле mod. Чтобы получить информацию о текущем модуле, вызовите эту функцию со значением, возвращаемым thisModule.

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

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

location :: Q Loc Source

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

runIO :: IO a -> Q a Source

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

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

addDependentFile :: FilePath -> Q () Source

Записывает внешние файлы, используемые runIO (зависимости). Затем компилятор может распознать, что ему необходимо перекомпилировать файл Haskell, когда изменяется внешний файл.

Ожидается абсолютный путь к файлу.

Примечания:

• ghc -M не знает об этих зависимостях - он не выполняет TH.
• Зависимость основана на содержимом файла, а не на времени последнего изменения.

addTopDecls :: [Dec] -> Q () Source

Добавляет дополнительные объявления верхнего уровня. Добавленные объявления будут проверены на тип вместе с текущей группой объявлений.

addModFinalizer :: Q () -> Q () Source

Добавляет финализатор, который будет выполняться в монаде Q после проверки типа текущего модуля. Это имеет смысл только при выполнении внутри сплейса верхнего уровня.

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

Получение состояния из монады Q.

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

Замена состояния в монаде Q.

returnQ :: a -> Q a Source

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

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

class Lift t where Source

liftString :: String -> Q Exp Source

trueName :: Name Source

falseName :: Name Source

nothingName :: Name Source

justName :: Name Source

leftName :: Name Source

rightName :: Name Source

newtype ModName Source

newtype PkgName Source

data Модуль Источник

Получено из reifyModule и thisModule.

newtype Имя_переменной Источник

mkModName :: Строка -> ModName Источник

modString :: ModName -> Строка Источник

mkPkgName :: Строка -> PkgName Источник

pkgString :: PkgName -> Строка Источник

mkOccName :: Строка -> Имя_переменной Источник

occString :: Имя_переменной -> Строка Источник

Большая часть API Name посвящена проблеме захвата имен, что можно увидеть в следующем примере.

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

Примитивное упрощение этого приведет к:

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

Внезапно, g и h имеют разные значения! В этом случае мы говорим, что x в правой части g был захвачен связыванием x в f.

На самом деле нам нужно, чтобы x в f отличалось от x в g, поэтому мы получаем следующее упрощение:

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

что избегает захвата имен, как и ожидалось.

В общем случае, мы говорим, что Name может быть захвачено, если то, на что оно ссылается, может быть изменено путем добавления новых объявлений.

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 NameFlavour Source

data NameSpace Source

type Uniq = Int Source

nameBase :: Name -> String Source

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

nameModule :: Name -> Maybe String Source

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

mkName :: String -> Name Source

Создаёт имя, которое можно захватить. Вхождения таких имён будут разрешаться в соответствии с правилами области видимости 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") |]

mkNameU :: String -> Uniq -> Name Source

Используется только во внутренней работе

mkNameL :: String -> Uniq -> Name Source

Используется только во внутренней работе

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

Используется для 'x и т. д., но недоступно программисту

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

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

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

data NameIs Source

showName :: Name -> String Source

showName' :: NameIs -> Name -> String Source

tupleDataName :: Int -> Name Source

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

tupleTypeName :: Int -> Name Source

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

mk_tup_name :: Int -> NameSpace -> Name Source

unboxedTupleDataName :: Int -> Name Source

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

unboxedTupleTypeName :: Int -> Name Source

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

mk_unboxed_tup_name :: Int -> NameSpace -> Name Source

data Loc Source

type CharPos Source

data Info Source

Получено из reify в Q Monad.

data ModuleInfo Source

Получено из reifyModule в Q Monad.

type ИмяРодителя = Имя Источник

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

type Арность = Целое Источник

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

type Неподнятый = Булево Источник

В PrimTyConI, является ли конструктор типа неподнятым?

type ДекларацияПримера = Декларация Источник

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

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

data Связанность Источник

data НаправлениеСвязанности Источник

МаксимальныйПриоритет :: Целое Источник

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

ПоУмолчаниюСвязанность :: Связанность Источник

По умолчанию связанность: infixl 9

При реализации антицитаций для квазицитаторов, часто необходимо анализировать строки в выражения:

parse :: String -> Maybe Exp

Но как следует анализировать a + b * c? Если нам неизвестны связанности + и *, мы не знаем, следует ли анализировать его как a + (b * c) или (a + b) * c.

В таких случаях используйте UInfixE или UInfixP, которые обозначают "нераспределённое инфиксное выражение" и "нераспределённое инфиксное образец". Когда компилятор получает вставку, содержащую дерево приложений UInfixE таких как

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

он будет искать и связанные приоритеты соответствующих операторов и перегруппировывать дерево по мере необходимости.

• Деревья не будут перегруппированы через ParensE или ParensP, что используется для анализа выражений, таких как

(a + b * c) + d * e

• InfixE и InfixP выражения никогда не перегруппировываются.
• Конструктор UInfixE не поддерживает секции. Секции, такие как (a *) не имеют неоднозначности, поэтому InfixE достаточно. Для более длинных секций, таких как (a + b * c -), используйте конструктор InfixE для внешней секции и используйте конструкторы UInfixE для всех остальных операторов:

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

Секции, такие как (a + b +) и ((a + b) +) должны быть отображены в Exps по-разному:

(+ 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

• Выражения в кавычках, такие как

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

никогда не будут содержать UInfixE, UInfixP, ParensE, или ParensP конструкторы.

data Лит Источник

data Pat Источник

Шаблон в 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 FieldPat = (Имя, Pat) Источник

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

case e of { pat -> body where decs }

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

f { p1 p2 = body where decs }

data Выражение Источник

{ 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 }

type FieldExp = (Name, Exp) Исходный код

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

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

f p { = e } where ds

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

f x { | odd x } = x

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

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

data Range 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 TySynEqn Источник

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

data FunDep Источник

data FamFlavour Источник

data Foreign Источник

data Callconv Источник

data Безопасность Источник

data Директива Источник

data Inline Источник

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

data Фазы Источник

data RuleBndr Source

data AnnTarget Source

type Cxt Source

(Eq a, Ord b)

type Pred = Type Source

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

data Strict Source

data Con Source

C Int a

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

Int :+ a

forall a. Eq a => C [a]

type StrictType = (Strict, Type) Source

тип VarStrictType = (Имя, Строгий, Тип) Исходный код

данные Тип Исходный код

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

T a b

t :: k

a

T

'T

(,), (,,), etc.

(), (), etc.

->

~

[]

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

'[]

(':)

*

Constraint

0,1,2, etc.

данные TyVarBndr Исходный код

a

(a :: k)

данные TyLit Исходный код

2

Hello

данные Роль Исходный код

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

nominal

representational

phantom

_

данные AnnLookup Исходный код

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

type Тип = Тип Источник

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

cmpEq :: Порядок -> Булево Источник

thenCmp :: Порядок -> Порядок -> Порядок Источник