hydra-ext-0.18.0: src/main/haskell/Hydra/Ext/Dsl/Datalog/Syntax.hs

-- Note: this is an automatically generated file. Do not edit.

-- | DSL functions for hydra.ext.datalog.syntax

module Hydra.Ext.Dsl.Datalog.Syntax where

import qualified Hydra.Core.Model as Model
import qualified Hydra.Core.Typed as Typed
import qualified Hydra.Ext.Datalog.Syntax as Syntax
import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines)
import qualified Data.Scientific as Sci
import Data.Void

-- | DSL constructor for hydra.ext.datalog.syntax.Atom
atom :: Typed.TypedTerm Syntax.Relation -> Typed.TypedTerm Syntax.TermList -> Typed.TypedTerm Syntax.Atom
atom relation termList =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.datalog.syntax.Atom"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "Relation"),
          Model.fieldTerm = (Typed.unTypedTerm relation)},
        Model.Field {
          Model.fieldName = (Model.Name "TermList"),
          Model.fieldTerm = (Typed.unTypedTerm termList)}]}))

-- | DSL name token for hydra.ext.datalog.syntax.Atom
atomAtom :: Typed.TypedName Syntax.Atom
atomAtom = Typed.TypedName (Model.Name "hydra.ext.datalog.syntax.Atom")

-- | DSL name token for hydra.ext.datalog.syntax.AtomList
atomListAtomList :: Typed.TypedName Syntax.AtomList
atomListAtomList = Typed.TypedName (Model.Name "hydra.ext.datalog.syntax.AtomList")

-- | DSL injection for the many variant of hydra.ext.datalog.syntax.AtomList
atomListMany :: Typed.TypedTerm Syntax.AtomListMultiple -> Typed.TypedTerm Syntax.AtomList
atomListMany x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.datalog.syntax.AtomList"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "many"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for hydra.ext.datalog.syntax.AtomListMultiple
atomListMultiple :: Typed.TypedTerm Syntax.Atom -> Typed.TypedTerm Syntax.AtomList -> Typed.TypedTerm Syntax.AtomListMultiple
atomListMultiple atom atomList =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.datalog.syntax.AtomListMultiple"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "Atom"),
          Model.fieldTerm = (Typed.unTypedTerm atom)},
        Model.Field {
          Model.fieldName = (Model.Name "AtomList"),
          Model.fieldTerm = (Typed.unTypedTerm atomList)}]}))

-- | DSL accessor for the Atom field of hydra.ext.datalog.syntax.AtomListMultiple
atomListMultipleAtom :: Typed.TypedTerm Syntax.AtomListMultiple -> Typed.TypedTerm Syntax.Atom
atomListMultipleAtom x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.datalog.syntax.AtomListMultiple"),
        Model.projectionFieldName = (Model.Name "Atom")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the AtomList field of hydra.ext.datalog.syntax.AtomListMultiple
atomListMultipleAtomList :: Typed.TypedTerm Syntax.AtomListMultiple -> Typed.TypedTerm Syntax.AtomList
atomListMultipleAtomList x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.datalog.syntax.AtomListMultiple"),
        Model.projectionFieldName = (Model.Name "AtomList")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.datalog.syntax.AtomListMultiple
atomListMultipleAtomListMultiple :: Typed.TypedName Syntax.AtomListMultiple
atomListMultipleAtomListMultiple = Typed.TypedName (Model.Name "hydra.ext.datalog.syntax.AtomListMultiple")

-- | DSL updater for the Atom field of hydra.ext.datalog.syntax.AtomListMultiple
atomListMultipleWithAtom :: Typed.TypedTerm Syntax.AtomListMultiple -> Typed.TypedTerm Syntax.Atom -> Typed.TypedTerm Syntax.AtomListMultiple
atomListMultipleWithAtom original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.datalog.syntax.AtomListMultiple"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "Atom"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "AtomList"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.datalog.syntax.AtomListMultiple"),
              Model.projectionFieldName = (Model.Name "AtomList")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the AtomList field of hydra.ext.datalog.syntax.AtomListMultiple
atomListMultipleWithAtomList :: Typed.TypedTerm Syntax.AtomListMultiple -> Typed.TypedTerm Syntax.AtomList -> Typed.TypedTerm Syntax.AtomListMultiple
atomListMultipleWithAtomList original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.datalog.syntax.AtomListMultiple"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "Atom"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.datalog.syntax.AtomListMultiple"),
              Model.projectionFieldName = (Model.Name "Atom")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "AtomList"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL injection for the single variant of hydra.ext.datalog.syntax.AtomList
atomListSingle :: Typed.TypedTerm Syntax.Atom -> Typed.TypedTerm Syntax.AtomList
atomListSingle x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.datalog.syntax.AtomList"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "single"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL accessor for the Relation field of hydra.ext.datalog.syntax.Atom
atomRelation :: Typed.TypedTerm Syntax.Atom -> Typed.TypedTerm Syntax.Relation
atomRelation x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.datalog.syntax.Atom"),
        Model.projectionFieldName = (Model.Name "Relation")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the TermList field of hydra.ext.datalog.syntax.Atom
atomTermList :: Typed.TypedTerm Syntax.Atom -> Typed.TypedTerm Syntax.TermList
atomTermList x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.datalog.syntax.Atom"),
        Model.projectionFieldName = (Model.Name "TermList")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the Relation field of hydra.ext.datalog.syntax.Atom
atomWithRelation :: Typed.TypedTerm Syntax.Atom -> Typed.TypedTerm Syntax.Relation -> Typed.TypedTerm Syntax.Atom
atomWithRelation original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.datalog.syntax.Atom"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "Relation"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "TermList"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.datalog.syntax.Atom"),
              Model.projectionFieldName = (Model.Name "TermList")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the TermList field of hydra.ext.datalog.syntax.Atom
atomWithTermList :: Typed.TypedTerm Syntax.Atom -> Typed.TypedTerm Syntax.TermList -> Typed.TypedTerm Syntax.Atom
atomWithTermList original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.datalog.syntax.Atom"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "Relation"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.datalog.syntax.Atom"),
              Model.projectionFieldName = (Model.Name "Relation")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "TermList"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for the hydra.ext.datalog.syntax.Constant wrapper
constant :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.Constant
constant x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.datalog.syntax.Constant"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.datalog.syntax.Constant
constantConstant :: Typed.TypedName Syntax.Constant
constantConstant = Typed.TypedName (Model.Name "hydra.ext.datalog.syntax.Constant")

-- | DSL name token for hydra.ext.datalog.syntax.ConstantList
constantListConstantList :: Typed.TypedName Syntax.ConstantList
constantListConstantList = Typed.TypedName (Model.Name "hydra.ext.datalog.syntax.ConstantList")

-- | DSL injection for the many variant of hydra.ext.datalog.syntax.ConstantList
constantListMany :: Typed.TypedTerm Syntax.ConstantListMultiple -> Typed.TypedTerm Syntax.ConstantList
constantListMany x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.datalog.syntax.ConstantList"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "many"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for hydra.ext.datalog.syntax.ConstantListMultiple
constantListMultiple :: Typed.TypedTerm Syntax.Constant -> Typed.TypedTerm Syntax.ConstantList -> Typed.TypedTerm Syntax.ConstantListMultiple
constantListMultiple constant constantList =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.datalog.syntax.ConstantListMultiple"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "Constant"),
          Model.fieldTerm = (Typed.unTypedTerm constant)},
        Model.Field {
          Model.fieldName = (Model.Name "ConstantList"),
          Model.fieldTerm = (Typed.unTypedTerm constantList)}]}))

-- | DSL accessor for the Constant field of hydra.ext.datalog.syntax.ConstantListMultiple
constantListMultipleConstant :: Typed.TypedTerm Syntax.ConstantListMultiple -> Typed.TypedTerm Syntax.Constant
constantListMultipleConstant x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.datalog.syntax.ConstantListMultiple"),
        Model.projectionFieldName = (Model.Name "Constant")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the ConstantList field of hydra.ext.datalog.syntax.ConstantListMultiple
constantListMultipleConstantList :: Typed.TypedTerm Syntax.ConstantListMultiple -> Typed.TypedTerm Syntax.ConstantList
constantListMultipleConstantList x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.datalog.syntax.ConstantListMultiple"),
        Model.projectionFieldName = (Model.Name "ConstantList")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.datalog.syntax.ConstantListMultiple
constantListMultipleConstantListMultiple :: Typed.TypedName Syntax.ConstantListMultiple
constantListMultipleConstantListMultiple = Typed.TypedName (Model.Name "hydra.ext.datalog.syntax.ConstantListMultiple")

-- | DSL updater for the Constant field of hydra.ext.datalog.syntax.ConstantListMultiple
constantListMultipleWithConstant :: Typed.TypedTerm Syntax.ConstantListMultiple -> Typed.TypedTerm Syntax.Constant -> Typed.TypedTerm Syntax.ConstantListMultiple
constantListMultipleWithConstant original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.datalog.syntax.ConstantListMultiple"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "Constant"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "ConstantList"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.datalog.syntax.ConstantListMultiple"),
              Model.projectionFieldName = (Model.Name "ConstantList")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the ConstantList field of hydra.ext.datalog.syntax.ConstantListMultiple
constantListMultipleWithConstantList :: Typed.TypedTerm Syntax.ConstantListMultiple -> Typed.TypedTerm Syntax.ConstantList -> Typed.TypedTerm Syntax.ConstantListMultiple
constantListMultipleWithConstantList original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.datalog.syntax.ConstantListMultiple"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "Constant"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.datalog.syntax.ConstantListMultiple"),
              Model.projectionFieldName = (Model.Name "Constant")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "ConstantList"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL injection for the single variant of hydra.ext.datalog.syntax.ConstantList
constantListSingle :: Typed.TypedTerm Syntax.Constant -> Typed.TypedTerm Syntax.ConstantList
constantListSingle x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.datalog.syntax.ConstantList"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "single"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for hydra.ext.datalog.syntax.Fact
fact :: Typed.TypedTerm Syntax.Relation -> Typed.TypedTerm Syntax.ConstantList -> Typed.TypedTerm Syntax.Fact
fact relation constantList =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.datalog.syntax.Fact"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "Relation"),
          Model.fieldTerm = (Typed.unTypedTerm relation)},
        Model.Field {
          Model.fieldName = (Model.Name "ConstantList"),
          Model.fieldTerm = (Typed.unTypedTerm constantList)}]}))

-- | DSL accessor for the ConstantList field of hydra.ext.datalog.syntax.Fact
factConstantList :: Typed.TypedTerm Syntax.Fact -> Typed.TypedTerm Syntax.ConstantList
factConstantList x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.datalog.syntax.Fact"),
        Model.projectionFieldName = (Model.Name "ConstantList")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.datalog.syntax.Fact
factFact :: Typed.TypedName Syntax.Fact
factFact = Typed.TypedName (Model.Name "hydra.ext.datalog.syntax.Fact")

-- | DSL accessor for the Relation field of hydra.ext.datalog.syntax.Fact
factRelation :: Typed.TypedTerm Syntax.Fact -> Typed.TypedTerm Syntax.Relation
factRelation x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.datalog.syntax.Fact"),
        Model.projectionFieldName = (Model.Name "Relation")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the ConstantList field of hydra.ext.datalog.syntax.Fact
factWithConstantList :: Typed.TypedTerm Syntax.Fact -> Typed.TypedTerm Syntax.ConstantList -> Typed.TypedTerm Syntax.Fact
factWithConstantList original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.datalog.syntax.Fact"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "Relation"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.datalog.syntax.Fact"),
              Model.projectionFieldName = (Model.Name "Relation")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "ConstantList"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the Relation field of hydra.ext.datalog.syntax.Fact
factWithRelation :: Typed.TypedTerm Syntax.Fact -> Typed.TypedTerm Syntax.Relation -> Typed.TypedTerm Syntax.Fact
factWithRelation original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.datalog.syntax.Fact"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "Relation"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "ConstantList"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.datalog.syntax.Fact"),
              Model.projectionFieldName = (Model.Name "ConstantList")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for the hydra.ext.datalog.syntax.Program wrapper
program :: Typed.TypedTerm [Syntax.ProgramElmt] -> Typed.TypedTerm Syntax.Program
program x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.datalog.syntax.Program"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL injection for the Fact variant of hydra.ext.datalog.syntax.ProgramElmt
programElmtFact :: Typed.TypedTerm Syntax.Fact -> Typed.TypedTerm Syntax.ProgramElmt
programElmtFact x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.datalog.syntax.ProgramElmt"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "Fact"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.datalog.syntax.ProgramElmt
programElmtProgramElmt :: Typed.TypedName Syntax.ProgramElmt
programElmtProgramElmt = Typed.TypedName (Model.Name "hydra.ext.datalog.syntax.ProgramElmt")

-- | DSL injection for the Rule variant of hydra.ext.datalog.syntax.ProgramElmt
programElmtRule :: Typed.TypedTerm Syntax.Rule -> Typed.TypedTerm Syntax.ProgramElmt
programElmtRule x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.datalog.syntax.ProgramElmt"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "Rule"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.datalog.syntax.Program
programProgram :: Typed.TypedName Syntax.Program
programProgram = Typed.TypedName (Model.Name "hydra.ext.datalog.syntax.Program")

-- | DSL constructor for the hydra.ext.datalog.syntax.Relation wrapper
relation :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.Relation
relation x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.datalog.syntax.Relation"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.datalog.syntax.Relation
relationRelation :: Typed.TypedName Syntax.Relation
relationRelation = Typed.TypedName (Model.Name "hydra.ext.datalog.syntax.Relation")

-- | DSL constructor for hydra.ext.datalog.syntax.Rule
rule :: Typed.TypedTerm Syntax.Atom -> Typed.TypedTerm Syntax.AtomList -> Typed.TypedTerm Syntax.Rule
rule atom atomList =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.datalog.syntax.Rule"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "Atom"),
          Model.fieldTerm = (Typed.unTypedTerm atom)},
        Model.Field {
          Model.fieldName = (Model.Name "AtomList"),
          Model.fieldTerm = (Typed.unTypedTerm atomList)}]}))

-- | DSL accessor for the Atom field of hydra.ext.datalog.syntax.Rule
ruleAtom :: Typed.TypedTerm Syntax.Rule -> Typed.TypedTerm Syntax.Atom
ruleAtom x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.datalog.syntax.Rule"),
        Model.projectionFieldName = (Model.Name "Atom")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the AtomList field of hydra.ext.datalog.syntax.Rule
ruleAtomList :: Typed.TypedTerm Syntax.Rule -> Typed.TypedTerm Syntax.AtomList
ruleAtomList x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.datalog.syntax.Rule"),
        Model.projectionFieldName = (Model.Name "AtomList")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.datalog.syntax.Rule
ruleRule :: Typed.TypedName Syntax.Rule
ruleRule = Typed.TypedName (Model.Name "hydra.ext.datalog.syntax.Rule")

-- | DSL updater for the Atom field of hydra.ext.datalog.syntax.Rule
ruleWithAtom :: Typed.TypedTerm Syntax.Rule -> Typed.TypedTerm Syntax.Atom -> Typed.TypedTerm Syntax.Rule
ruleWithAtom original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.datalog.syntax.Rule"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "Atom"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "AtomList"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.datalog.syntax.Rule"),
              Model.projectionFieldName = (Model.Name "AtomList")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the AtomList field of hydra.ext.datalog.syntax.Rule
ruleWithAtomList :: Typed.TypedTerm Syntax.Rule -> Typed.TypedTerm Syntax.AtomList -> Typed.TypedTerm Syntax.Rule
ruleWithAtomList original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.datalog.syntax.Rule"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "Atom"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.datalog.syntax.Rule"),
              Model.projectionFieldName = (Model.Name "Atom")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "AtomList"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL injection for the Constant variant of hydra.ext.datalog.syntax.Term
termConstant :: Typed.TypedTerm Syntax.Constant -> Typed.TypedTerm Syntax.Term
termConstant x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.datalog.syntax.Term"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "Constant"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the many variant of hydra.ext.datalog.syntax.TermList
termListMany :: Typed.TypedTerm Syntax.TermListMultiple -> Typed.TypedTerm Syntax.TermList
termListMany x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.datalog.syntax.TermList"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "many"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for hydra.ext.datalog.syntax.TermListMultiple
termListMultiple :: Typed.TypedTerm Syntax.Term -> Typed.TypedTerm Syntax.TermList -> Typed.TypedTerm Syntax.TermListMultiple
termListMultiple term termList =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.datalog.syntax.TermListMultiple"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "Term"),
          Model.fieldTerm = (Typed.unTypedTerm term)},
        Model.Field {
          Model.fieldName = (Model.Name "TermList"),
          Model.fieldTerm = (Typed.unTypedTerm termList)}]}))

-- | DSL accessor for the Term field of hydra.ext.datalog.syntax.TermListMultiple
termListMultipleTerm :: Typed.TypedTerm Syntax.TermListMultiple -> Typed.TypedTerm Syntax.Term
termListMultipleTerm x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.datalog.syntax.TermListMultiple"),
        Model.projectionFieldName = (Model.Name "Term")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the TermList field of hydra.ext.datalog.syntax.TermListMultiple
termListMultipleTermList :: Typed.TypedTerm Syntax.TermListMultiple -> Typed.TypedTerm Syntax.TermList
termListMultipleTermList x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.datalog.syntax.TermListMultiple"),
        Model.projectionFieldName = (Model.Name "TermList")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.datalog.syntax.TermListMultiple
termListMultipleTermListMultiple :: Typed.TypedName Syntax.TermListMultiple
termListMultipleTermListMultiple = Typed.TypedName (Model.Name "hydra.ext.datalog.syntax.TermListMultiple")

-- | DSL updater for the Term field of hydra.ext.datalog.syntax.TermListMultiple
termListMultipleWithTerm :: Typed.TypedTerm Syntax.TermListMultiple -> Typed.TypedTerm Syntax.Term -> Typed.TypedTerm Syntax.TermListMultiple
termListMultipleWithTerm original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.datalog.syntax.TermListMultiple"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "Term"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "TermList"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.datalog.syntax.TermListMultiple"),
              Model.projectionFieldName = (Model.Name "TermList")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the TermList field of hydra.ext.datalog.syntax.TermListMultiple
termListMultipleWithTermList :: Typed.TypedTerm Syntax.TermListMultiple -> Typed.TypedTerm Syntax.TermList -> Typed.TypedTerm Syntax.TermListMultiple
termListMultipleWithTermList original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.datalog.syntax.TermListMultiple"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "Term"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.datalog.syntax.TermListMultiple"),
              Model.projectionFieldName = (Model.Name "Term")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "TermList"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL injection for the single variant of hydra.ext.datalog.syntax.TermList
termListSingle :: Typed.TypedTerm Syntax.Term -> Typed.TypedTerm Syntax.TermList
termListSingle x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.datalog.syntax.TermList"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "single"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.datalog.syntax.TermList
termListTermList :: Typed.TypedName Syntax.TermList
termListTermList = Typed.TypedName (Model.Name "hydra.ext.datalog.syntax.TermList")

-- | DSL name token for hydra.ext.datalog.syntax.Term
termTerm :: Typed.TypedName Syntax.Term
termTerm = Typed.TypedName (Model.Name "hydra.ext.datalog.syntax.Term")

-- | DSL injection for the Variable variant of hydra.ext.datalog.syntax.Term
termVariable :: Typed.TypedTerm Syntax.Variable -> Typed.TypedTerm Syntax.Term
termVariable x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.datalog.syntax.Term"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "Variable"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL accessor for the body of hydra.ext.datalog.syntax.Constant
unConstant :: Typed.TypedTerm Syntax.Constant -> Typed.TypedTerm String
unConstant x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.datalog.syntax.Constant")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.datalog.syntax.Program
unProgram :: Typed.TypedTerm Syntax.Program -> Typed.TypedTerm [Syntax.ProgramElmt]
unProgram x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.datalog.syntax.Program")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.datalog.syntax.Relation
unRelation :: Typed.TypedTerm Syntax.Relation -> Typed.TypedTerm String
unRelation x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.datalog.syntax.Relation")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.datalog.syntax.Variable
unVariable :: Typed.TypedTerm Syntax.Variable -> Typed.TypedTerm String
unVariable x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.datalog.syntax.Variable")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL constructor for the hydra.ext.datalog.syntax.Variable wrapper
variable :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.Variable
variable x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.datalog.syntax.Variable"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.datalog.syntax.Variable
variableVariable :: Typed.TypedName Syntax.Variable
variableVariable = Typed.TypedName (Model.Name "hydra.ext.datalog.syntax.Variable")