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

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

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

module Hydra.Ext.Dsl.Cpp.Syntax where

import qualified Hydra.Core.Model as Model
import qualified Hydra.Core.Typed as Typed
import qualified Hydra.Ext.Cpp.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 name token for hydra.ext.cpp.syntax.AccessSpecifier
accessSpecifierAccessSpecifier :: Typed.TypedName Syntax.AccessSpecifier
accessSpecifierAccessSpecifier = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.AccessSpecifier")

-- | DSL injection for the none variant of hydra.ext.cpp.syntax.AccessSpecifier
accessSpecifierNone :: Typed.TypedTerm Syntax.AccessSpecifier
accessSpecifierNone =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.AccessSpecifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "none"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the private variant of hydra.ext.cpp.syntax.AccessSpecifier
accessSpecifierPrivate :: Typed.TypedTerm Syntax.AccessSpecifier
accessSpecifierPrivate =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.AccessSpecifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "private"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the protected variant of hydra.ext.cpp.syntax.AccessSpecifier
accessSpecifierProtected :: Typed.TypedTerm Syntax.AccessSpecifier
accessSpecifierProtected =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.AccessSpecifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "protected"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the public variant of hydra.ext.cpp.syntax.AccessSpecifier
accessSpecifierPublic :: Typed.TypedTerm Syntax.AccessSpecifier
accessSpecifierPublic =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.AccessSpecifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "public"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL constructor for hydra.ext.cpp.syntax.AddOperation
addOperation :: Typed.TypedTerm Syntax.AdditiveExpression -> Typed.TypedTerm Syntax.MultiplicativeExpression -> Typed.TypedTerm Syntax.AddOperation
addOperation left right =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.AddOperation"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Typed.unTypedTerm left)},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Typed.unTypedTerm right)}]}))

-- | DSL name token for hydra.ext.cpp.syntax.AddOperation
addOperationAddOperation :: Typed.TypedName Syntax.AddOperation
addOperationAddOperation = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.AddOperation")

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

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

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

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

-- | DSL injection for the add variant of hydra.ext.cpp.syntax.AdditiveExpression
additiveExpressionAdd :: Typed.TypedTerm Syntax.AddOperation -> Typed.TypedTerm Syntax.AdditiveExpression
additiveExpressionAdd x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.AdditiveExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "add"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.cpp.syntax.AdditiveExpression
additiveExpressionAdditiveExpression :: Typed.TypedName Syntax.AdditiveExpression
additiveExpressionAdditiveExpression = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.AdditiveExpression")

-- | DSL injection for the multiplicative variant of hydra.ext.cpp.syntax.AdditiveExpression
additiveExpressionMultiplicative :: Typed.TypedTerm Syntax.MultiplicativeExpression -> Typed.TypedTerm Syntax.AdditiveExpression
additiveExpressionMultiplicative x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.AdditiveExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "multiplicative"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the subtract variant of hydra.ext.cpp.syntax.AdditiveExpression
additiveExpressionSubtract :: Typed.TypedTerm Syntax.SubtractOperation -> Typed.TypedTerm Syntax.AdditiveExpression
additiveExpressionSubtract x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.AdditiveExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "subtract"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.cpp.syntax.AndExpression
andExpressionAndExpression :: Typed.TypedName Syntax.AndExpression
andExpressionAndExpression = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.AndExpression")

-- | DSL injection for the bitwiseAnd variant of hydra.ext.cpp.syntax.AndExpression
andExpressionBitwiseAnd :: Typed.TypedTerm Syntax.BitwiseAndOperation -> Typed.TypedTerm Syntax.AndExpression
andExpressionBitwiseAnd x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.AndExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "bitwiseAnd"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the equality variant of hydra.ext.cpp.syntax.AndExpression
andExpressionEquality :: Typed.TypedTerm Syntax.EqualityExpression -> Typed.TypedTerm Syntax.AndExpression
andExpressionEquality x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.AndExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "equality"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the assignment variant of hydra.ext.cpp.syntax.AssignmentExpression
assignmentExpressionAssignment :: Typed.TypedTerm Syntax.ExplicitAssignment -> Typed.TypedTerm Syntax.AssignmentExpression
assignmentExpressionAssignment x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.AssignmentExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "assignment"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.cpp.syntax.AssignmentExpression
assignmentExpressionAssignmentExpression :: Typed.TypedName Syntax.AssignmentExpression
assignmentExpressionAssignmentExpression = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.AssignmentExpression")

-- | DSL injection for the conditional variant of hydra.ext.cpp.syntax.AssignmentExpression
assignmentExpressionConditional :: Typed.TypedTerm Syntax.ConditionalExpression -> Typed.TypedTerm Syntax.AssignmentExpression
assignmentExpressionConditional x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.AssignmentExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "conditional"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the assign variant of hydra.ext.cpp.syntax.AssignmentOperator
assignmentOperatorAssign :: Typed.TypedTerm Syntax.AssignmentOperator
assignmentOperatorAssign =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.AssignmentOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "assign"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL name token for hydra.ext.cpp.syntax.AssignmentOperator
assignmentOperatorAssignmentOperator :: Typed.TypedName Syntax.AssignmentOperator
assignmentOperatorAssignmentOperator = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.AssignmentOperator")

-- | DSL injection for the bitwiseAndAssign variant of hydra.ext.cpp.syntax.AssignmentOperator
assignmentOperatorBitwiseAndAssign :: Typed.TypedTerm Syntax.AssignmentOperator
assignmentOperatorBitwiseAndAssign =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.AssignmentOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "bitwiseAndAssign"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the bitwiseOrAssign variant of hydra.ext.cpp.syntax.AssignmentOperator
assignmentOperatorBitwiseOrAssign :: Typed.TypedTerm Syntax.AssignmentOperator
assignmentOperatorBitwiseOrAssign =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.AssignmentOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "bitwiseOrAssign"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the bitwiseXorAssign variant of hydra.ext.cpp.syntax.AssignmentOperator
assignmentOperatorBitwiseXorAssign :: Typed.TypedTerm Syntax.AssignmentOperator
assignmentOperatorBitwiseXorAssign =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.AssignmentOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "bitwiseXorAssign"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the divideAssign variant of hydra.ext.cpp.syntax.AssignmentOperator
assignmentOperatorDivideAssign :: Typed.TypedTerm Syntax.AssignmentOperator
assignmentOperatorDivideAssign =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.AssignmentOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "divideAssign"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the leftShiftAssign variant of hydra.ext.cpp.syntax.AssignmentOperator
assignmentOperatorLeftShiftAssign :: Typed.TypedTerm Syntax.AssignmentOperator
assignmentOperatorLeftShiftAssign =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.AssignmentOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "leftShiftAssign"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the minusAssign variant of hydra.ext.cpp.syntax.AssignmentOperator
assignmentOperatorMinusAssign :: Typed.TypedTerm Syntax.AssignmentOperator
assignmentOperatorMinusAssign =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.AssignmentOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "minusAssign"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the moduloAssign variant of hydra.ext.cpp.syntax.AssignmentOperator
assignmentOperatorModuloAssign :: Typed.TypedTerm Syntax.AssignmentOperator
assignmentOperatorModuloAssign =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.AssignmentOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "moduloAssign"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the multiplyAssign variant of hydra.ext.cpp.syntax.AssignmentOperator
assignmentOperatorMultiplyAssign :: Typed.TypedTerm Syntax.AssignmentOperator
assignmentOperatorMultiplyAssign =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.AssignmentOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "multiplyAssign"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the plusAssign variant of hydra.ext.cpp.syntax.AssignmentOperator
assignmentOperatorPlusAssign :: Typed.TypedTerm Syntax.AssignmentOperator
assignmentOperatorPlusAssign =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.AssignmentOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "plusAssign"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the rightShiftAssign variant of hydra.ext.cpp.syntax.AssignmentOperator
assignmentOperatorRightShiftAssign :: Typed.TypedTerm Syntax.AssignmentOperator
assignmentOperatorRightShiftAssign =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.AssignmentOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "rightShiftAssign"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL constructor for hydra.ext.cpp.syntax.BaseSpecifier
baseSpecifier :: Typed.TypedTerm Syntax.AccessSpecifier -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.BaseSpecifier
baseSpecifier access name =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.BaseSpecifier"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "access"),
          Model.fieldTerm = (Typed.unTypedTerm access)},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)}]}))

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

-- | DSL name token for hydra.ext.cpp.syntax.BaseSpecifier
baseSpecifierBaseSpecifier :: Typed.TypedName Syntax.BaseSpecifier
baseSpecifierBaseSpecifier = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.BaseSpecifier")

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

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

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

-- | DSL injection for the auto variant of hydra.ext.cpp.syntax.BasicType
basicTypeAuto :: Typed.TypedTerm Syntax.BasicType
basicTypeAuto =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.BasicType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "auto"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL name token for hydra.ext.cpp.syntax.BasicType
basicTypeBasicType :: Typed.TypedName Syntax.BasicType
basicTypeBasicType = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.BasicType")

-- | DSL injection for the bool variant of hydra.ext.cpp.syntax.BasicType
basicTypeBool :: Typed.TypedTerm Syntax.BasicType
basicTypeBool =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.BasicType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "bool"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the char variant of hydra.ext.cpp.syntax.BasicType
basicTypeChar :: Typed.TypedTerm Syntax.BasicType
basicTypeChar =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.BasicType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "char"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the double variant of hydra.ext.cpp.syntax.BasicType
basicTypeDouble :: Typed.TypedTerm Syntax.BasicType
basicTypeDouble =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.BasicType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "double"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the float variant of hydra.ext.cpp.syntax.BasicType
basicTypeFloat :: Typed.TypedTerm Syntax.BasicType
basicTypeFloat =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.BasicType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "float"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the int variant of hydra.ext.cpp.syntax.BasicType
basicTypeInt :: Typed.TypedTerm Syntax.BasicType
basicTypeInt =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.BasicType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "int"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the named variant of hydra.ext.cpp.syntax.BasicType
basicTypeNamed :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.BasicType
basicTypeNamed x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.BasicType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "named"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the string variant of hydra.ext.cpp.syntax.BasicType
basicTypeString :: Typed.TypedTerm Syntax.BasicType
basicTypeString =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.BasicType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "string"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the void variant of hydra.ext.cpp.syntax.BasicType
basicTypeVoid :: Typed.TypedTerm Syntax.BasicType
basicTypeVoid =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.BasicType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "void"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL name token for hydra.ext.cpp.syntax.BinaryOperator
binaryOperatorBinaryOperator :: Typed.TypedName Syntax.BinaryOperator
binaryOperatorBinaryOperator = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.BinaryOperator")

-- | DSL injection for the bitwiseAnd variant of hydra.ext.cpp.syntax.BinaryOperator
binaryOperatorBitwiseAnd :: Typed.TypedTerm Syntax.BinaryOperator
binaryOperatorBitwiseAnd =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.BinaryOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "bitwiseAnd"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the bitwiseOr variant of hydra.ext.cpp.syntax.BinaryOperator
binaryOperatorBitwiseOr :: Typed.TypedTerm Syntax.BinaryOperator
binaryOperatorBitwiseOr =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.BinaryOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "bitwiseOr"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the bitwiseXor variant of hydra.ext.cpp.syntax.BinaryOperator
binaryOperatorBitwiseXor :: Typed.TypedTerm Syntax.BinaryOperator
binaryOperatorBitwiseXor =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.BinaryOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "bitwiseXor"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the divide variant of hydra.ext.cpp.syntax.BinaryOperator
binaryOperatorDivide :: Typed.TypedTerm Syntax.BinaryOperator
binaryOperatorDivide =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.BinaryOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "divide"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the equal variant of hydra.ext.cpp.syntax.BinaryOperator
binaryOperatorEqual :: Typed.TypedTerm Syntax.BinaryOperator
binaryOperatorEqual =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.BinaryOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "equal"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the greater variant of hydra.ext.cpp.syntax.BinaryOperator
binaryOperatorGreater :: Typed.TypedTerm Syntax.BinaryOperator
binaryOperatorGreater =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.BinaryOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "greater"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the greaterEqual variant of hydra.ext.cpp.syntax.BinaryOperator
binaryOperatorGreaterEqual :: Typed.TypedTerm Syntax.BinaryOperator
binaryOperatorGreaterEqual =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.BinaryOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "greaterEqual"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the leftShift variant of hydra.ext.cpp.syntax.BinaryOperator
binaryOperatorLeftShift :: Typed.TypedTerm Syntax.BinaryOperator
binaryOperatorLeftShift =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.BinaryOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "leftShift"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the less variant of hydra.ext.cpp.syntax.BinaryOperator
binaryOperatorLess :: Typed.TypedTerm Syntax.BinaryOperator
binaryOperatorLess =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.BinaryOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "less"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the lessEqual variant of hydra.ext.cpp.syntax.BinaryOperator
binaryOperatorLessEqual :: Typed.TypedTerm Syntax.BinaryOperator
binaryOperatorLessEqual =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.BinaryOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "lessEqual"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the logicalAnd variant of hydra.ext.cpp.syntax.BinaryOperator
binaryOperatorLogicalAnd :: Typed.TypedTerm Syntax.BinaryOperator
binaryOperatorLogicalAnd =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.BinaryOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "logicalAnd"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the logicalOr variant of hydra.ext.cpp.syntax.BinaryOperator
binaryOperatorLogicalOr :: Typed.TypedTerm Syntax.BinaryOperator
binaryOperatorLogicalOr =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.BinaryOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "logicalOr"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the minus variant of hydra.ext.cpp.syntax.BinaryOperator
binaryOperatorMinus :: Typed.TypedTerm Syntax.BinaryOperator
binaryOperatorMinus =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.BinaryOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "minus"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the modulo variant of hydra.ext.cpp.syntax.BinaryOperator
binaryOperatorModulo :: Typed.TypedTerm Syntax.BinaryOperator
binaryOperatorModulo =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.BinaryOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "modulo"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the multiply variant of hydra.ext.cpp.syntax.BinaryOperator
binaryOperatorMultiply :: Typed.TypedTerm Syntax.BinaryOperator
binaryOperatorMultiply =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.BinaryOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "multiply"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the notEqual variant of hydra.ext.cpp.syntax.BinaryOperator
binaryOperatorNotEqual :: Typed.TypedTerm Syntax.BinaryOperator
binaryOperatorNotEqual =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.BinaryOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "notEqual"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the plus variant of hydra.ext.cpp.syntax.BinaryOperator
binaryOperatorPlus :: Typed.TypedTerm Syntax.BinaryOperator
binaryOperatorPlus =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.BinaryOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "plus"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the rightShift variant of hydra.ext.cpp.syntax.BinaryOperator
binaryOperatorRightShift :: Typed.TypedTerm Syntax.BinaryOperator
binaryOperatorRightShift =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.BinaryOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "rightShift"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL constructor for hydra.ext.cpp.syntax.BitwiseAndOperation
bitwiseAndOperation :: Typed.TypedTerm Syntax.AndExpression -> Typed.TypedTerm Syntax.EqualityExpression -> Typed.TypedTerm Syntax.BitwiseAndOperation
bitwiseAndOperation left right =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.BitwiseAndOperation"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Typed.unTypedTerm left)},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Typed.unTypedTerm right)}]}))

-- | DSL name token for hydra.ext.cpp.syntax.BitwiseAndOperation
bitwiseAndOperationBitwiseAndOperation :: Typed.TypedName Syntax.BitwiseAndOperation
bitwiseAndOperationBitwiseAndOperation = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.BitwiseAndOperation")

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

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

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

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

-- | DSL constructor for hydra.ext.cpp.syntax.BitwiseOrOperation
bitwiseOrOperation :: Typed.TypedTerm Syntax.InclusiveOrExpression -> Typed.TypedTerm Syntax.ExclusiveOrExpression -> Typed.TypedTerm Syntax.BitwiseOrOperation
bitwiseOrOperation left right =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.BitwiseOrOperation"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Typed.unTypedTerm left)},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Typed.unTypedTerm right)}]}))

-- | DSL name token for hydra.ext.cpp.syntax.BitwiseOrOperation
bitwiseOrOperationBitwiseOrOperation :: Typed.TypedName Syntax.BitwiseOrOperation
bitwiseOrOperationBitwiseOrOperation = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.BitwiseOrOperation")

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

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

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

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

-- | DSL constructor for hydra.ext.cpp.syntax.BitwiseXorOperation
bitwiseXorOperation :: Typed.TypedTerm Syntax.ExclusiveOrExpression -> Typed.TypedTerm Syntax.AndExpression -> Typed.TypedTerm Syntax.BitwiseXorOperation
bitwiseXorOperation left right =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.BitwiseXorOperation"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Typed.unTypedTerm left)},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Typed.unTypedTerm right)}]}))

-- | DSL name token for hydra.ext.cpp.syntax.BitwiseXorOperation
bitwiseXorOperationBitwiseXorOperation :: Typed.TypedName Syntax.BitwiseXorOperation
bitwiseXorOperationBitwiseXorOperation = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.BitwiseXorOperation")

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

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

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

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

-- | DSL constructor for the hydra.ext.cpp.syntax.BooleanLiteral wrapper
booleanLiteral :: Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.BooleanLiteral
booleanLiteral x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.cpp.syntax.BooleanLiteral"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.cpp.syntax.BooleanLiteral
booleanLiteralBooleanLiteral :: Typed.TypedName Syntax.BooleanLiteral
booleanLiteralBooleanLiteral = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.BooleanLiteral")

-- | DSL constructor for hydra.ext.cpp.syntax.Capture
capture :: Typed.TypedTerm String -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.Capture
capture name byReference =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.Capture"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)},
        Model.Field {
          Model.fieldName = (Model.Name "byReference"),
          Model.fieldTerm = (Typed.unTypedTerm byReference)}]}))

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

-- | DSL name token for hydra.ext.cpp.syntax.Capture
captureCapture :: Typed.TypedName Syntax.Capture
captureCapture = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.Capture")

-- | DSL injection for the captureByValue variant of hydra.ext.cpp.syntax.CaptureList
captureListCaptureByValue :: Typed.TypedTerm Syntax.CaptureList
captureListCaptureByValue =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.CaptureList"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "captureByValue"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL name token for hydra.ext.cpp.syntax.CaptureList
captureListCaptureList :: Typed.TypedName Syntax.CaptureList
captureListCaptureList = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.CaptureList")

-- | DSL injection for the captures variant of hydra.ext.cpp.syntax.CaptureList
captureListCaptures :: Typed.TypedTerm [Syntax.Capture] -> Typed.TypedTerm Syntax.CaptureList
captureListCaptures x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.CaptureList"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "captures"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

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

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

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

-- | DSL injection for the case variant of hydra.ext.cpp.syntax.CaseStatement
caseStatementCase :: Typed.TypedTerm Syntax.CaseValue -> Typed.TypedTerm Syntax.CaseStatement
caseStatementCase x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.CaseStatement"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "case"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.cpp.syntax.CaseStatement
caseStatementCaseStatement :: Typed.TypedName Syntax.CaseStatement
caseStatementCaseStatement = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.CaseStatement")

-- | DSL injection for the default variant of hydra.ext.cpp.syntax.CaseStatement
caseStatementDefault :: Typed.TypedTerm Syntax.Statement -> Typed.TypedTerm Syntax.CaseStatement
caseStatementDefault x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.CaseStatement"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "default"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for hydra.ext.cpp.syntax.CaseValue
caseValue :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Statement -> Typed.TypedTerm Syntax.CaseValue
caseValue value statement =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.CaseValue"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "value"),
          Model.fieldTerm = (Typed.unTypedTerm value)},
        Model.Field {
          Model.fieldName = (Model.Name "statement"),
          Model.fieldTerm = (Typed.unTypedTerm statement)}]}))

-- | DSL name token for hydra.ext.cpp.syntax.CaseValue
caseValueCaseValue :: Typed.TypedName Syntax.CaseValue
caseValueCaseValue = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.CaseValue")

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

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

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

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

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

-- | DSL name token for hydra.ext.cpp.syntax.CharacterLiteral
characterLiteralCharacterLiteral :: Typed.TypedName Syntax.CharacterLiteral
characterLiteralCharacterLiteral = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.CharacterLiteral")

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

-- | DSL name token for hydra.ext.cpp.syntax.ClassBody
classBodyClassBody :: Typed.TypedName Syntax.ClassBody
classBodyClassBody = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.ClassBody")

-- | DSL constructor for hydra.ext.cpp.syntax.ClassDeclaration
classDeclaration :: Typed.TypedTerm Syntax.ClassSpecifier -> Typed.TypedTerm (Maybe Syntax.ClassBody) -> Typed.TypedTerm Syntax.ClassDeclaration
classDeclaration specifier body =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.ClassDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "specifier"),
          Model.fieldTerm = (Typed.unTypedTerm specifier)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm body)}]}))

-- | DSL accessor for the body field of hydra.ext.cpp.syntax.ClassDeclaration
classDeclarationBody :: Typed.TypedTerm Syntax.ClassDeclaration -> Typed.TypedTerm (Maybe Syntax.ClassBody)
classDeclarationBody x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ClassDeclaration"),
        Model.projectionFieldName = (Model.Name "body")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.cpp.syntax.ClassDeclaration
classDeclarationClassDeclaration :: Typed.TypedName Syntax.ClassDeclaration
classDeclarationClassDeclaration = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.ClassDeclaration")

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

-- | DSL updater for the body field of hydra.ext.cpp.syntax.ClassDeclaration
classDeclarationWithBody :: Typed.TypedTerm Syntax.ClassDeclaration -> Typed.TypedTerm (Maybe Syntax.ClassBody) -> Typed.TypedTerm Syntax.ClassDeclaration
classDeclarationWithBody original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.ClassDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "specifier"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ClassDeclaration"),
              Model.projectionFieldName = (Model.Name "specifier")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

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

-- | DSL injection for the class variant of hydra.ext.cpp.syntax.ClassKey
classKeyClass :: Typed.TypedTerm Syntax.ClassKey
classKeyClass =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ClassKey"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "class"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL name token for hydra.ext.cpp.syntax.ClassKey
classKeyClassKey :: Typed.TypedName Syntax.ClassKey
classKeyClassKey = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.ClassKey")

-- | DSL injection for the enum variant of hydra.ext.cpp.syntax.ClassKey
classKeyEnum :: Typed.TypedTerm Syntax.ClassKey
classKeyEnum =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ClassKey"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "enum"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the enumClass variant of hydra.ext.cpp.syntax.ClassKey
classKeyEnumClass :: Typed.TypedTerm Syntax.ClassKey
classKeyEnumClass =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ClassKey"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "enumClass"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the struct variant of hydra.ext.cpp.syntax.ClassKey
classKeyStruct :: Typed.TypedTerm Syntax.ClassKey
classKeyStruct =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ClassKey"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "struct"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL constructor for hydra.ext.cpp.syntax.ClassSpecifier
classSpecifier :: Typed.TypedTerm Syntax.ClassKey -> Typed.TypedTerm String -> Typed.TypedTerm [Syntax.BaseSpecifier] -> Typed.TypedTerm Syntax.ClassSpecifier
classSpecifier key name inheritance =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.ClassSpecifier"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "key"),
          Model.fieldTerm = (Typed.unTypedTerm key)},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)},
        Model.Field {
          Model.fieldName = (Model.Name "inheritance"),
          Model.fieldTerm = (Typed.unTypedTerm inheritance)}]}))

-- | DSL name token for hydra.ext.cpp.syntax.ClassSpecifier
classSpecifierClassSpecifier :: Typed.TypedName Syntax.ClassSpecifier
classSpecifierClassSpecifier = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.ClassSpecifier")

-- | DSL accessor for the inheritance field of hydra.ext.cpp.syntax.ClassSpecifier
classSpecifierInheritance :: Typed.TypedTerm Syntax.ClassSpecifier -> Typed.TypedTerm [Syntax.BaseSpecifier]
classSpecifierInheritance x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ClassSpecifier"),
        Model.projectionFieldName = (Model.Name "inheritance")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

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

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

-- | DSL updater for the inheritance field of hydra.ext.cpp.syntax.ClassSpecifier
classSpecifierWithInheritance :: Typed.TypedTerm Syntax.ClassSpecifier -> Typed.TypedTerm [Syntax.BaseSpecifier] -> Typed.TypedTerm Syntax.ClassSpecifier
classSpecifierWithInheritance original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.ClassSpecifier"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "key"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ClassSpecifier"),
              Model.projectionFieldName = (Model.Name "key")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ClassSpecifier"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "inheritance"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the key field of hydra.ext.cpp.syntax.ClassSpecifier
classSpecifierWithKey :: Typed.TypedTerm Syntax.ClassSpecifier -> Typed.TypedTerm Syntax.ClassKey -> Typed.TypedTerm Syntax.ClassSpecifier
classSpecifierWithKey original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.ClassSpecifier"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "key"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ClassSpecifier"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "inheritance"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ClassSpecifier"),
              Model.projectionFieldName = (Model.Name "inheritance")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the name field of hydra.ext.cpp.syntax.ClassSpecifier
classSpecifierWithName :: Typed.TypedTerm Syntax.ClassSpecifier -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.ClassSpecifier
classSpecifierWithName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.ClassSpecifier"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "key"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ClassSpecifier"),
              Model.projectionFieldName = (Model.Name "key")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "inheritance"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ClassSpecifier"),
              Model.projectionFieldName = (Model.Name "inheritance")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.cpp.syntax.CommaExpression
commaExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.AssignmentExpression -> Typed.TypedTerm Syntax.CommaExpression
commaExpression left right =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.CommaExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Typed.unTypedTerm left)},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Typed.unTypedTerm right)}]}))

-- | DSL name token for hydra.ext.cpp.syntax.CommaExpression
commaExpressionCommaExpression :: Typed.TypedName Syntax.CommaExpression
commaExpressionCommaExpression = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.CommaExpression")

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

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

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

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

-- | DSL constructor for hydra.ext.cpp.syntax.Comment
comment :: Typed.TypedTerm String -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.Comment
comment text isMultiline =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.Comment"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "text"),
          Model.fieldTerm = (Typed.unTypedTerm text)},
        Model.Field {
          Model.fieldName = (Model.Name "isMultiline"),
          Model.fieldTerm = (Typed.unTypedTerm isMultiline)}]}))

-- | DSL name token for hydra.ext.cpp.syntax.Comment
commentComment :: Typed.TypedName Syntax.Comment
commentComment = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.Comment")

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

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

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

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

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

-- | DSL name token for hydra.ext.cpp.syntax.CompoundStatement
compoundStatementCompoundStatement :: Typed.TypedName Syntax.CompoundStatement
compoundStatementCompoundStatement = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.CompoundStatement")

-- | DSL name token for hydra.ext.cpp.syntax.ConditionalExpression
conditionalExpressionConditionalExpression :: Typed.TypedName Syntax.ConditionalExpression
conditionalExpressionConditionalExpression = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.ConditionalExpression")

-- | DSL injection for the logicalOr variant of hydra.ext.cpp.syntax.ConditionalExpression
conditionalExpressionLogicalOr :: Typed.TypedTerm Syntax.LogicalOrExpression -> Typed.TypedTerm Syntax.ConditionalExpression
conditionalExpressionLogicalOr x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ConditionalExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "logicalOr"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the ternary variant of hydra.ext.cpp.syntax.ConditionalExpression
conditionalExpressionTernary :: Typed.TypedTerm Syntax.TernaryExpression -> Typed.TypedTerm Syntax.ConditionalExpression
conditionalExpressionTernary x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ConditionalExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "ternary"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for hydra.ext.cpp.syntax.ConstructorDeclaration
constructorDeclaration :: Typed.TypedTerm String -> Typed.TypedTerm [Syntax.Parameter] -> Typed.TypedTerm [Syntax.MemInitializer] -> Typed.TypedTerm Syntax.FunctionBody -> Typed.TypedTerm Syntax.ConstructorDeclaration
constructorDeclaration name parameters initializers body =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.ConstructorDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Typed.unTypedTerm parameters)},
        Model.Field {
          Model.fieldName = (Model.Name "initializers"),
          Model.fieldTerm = (Typed.unTypedTerm initializers)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm body)}]}))

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

-- | DSL name token for hydra.ext.cpp.syntax.ConstructorDeclaration
constructorDeclarationConstructorDeclaration :: Typed.TypedName Syntax.ConstructorDeclaration
constructorDeclarationConstructorDeclaration = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.ConstructorDeclaration")

-- | DSL accessor for the initializers field of hydra.ext.cpp.syntax.ConstructorDeclaration
constructorDeclarationInitializers :: Typed.TypedTerm Syntax.ConstructorDeclaration -> Typed.TypedTerm [Syntax.MemInitializer]
constructorDeclarationInitializers x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ConstructorDeclaration"),
        Model.projectionFieldName = (Model.Name "initializers")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

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

-- | DSL accessor for the parameters field of hydra.ext.cpp.syntax.ConstructorDeclaration
constructorDeclarationParameters :: Typed.TypedTerm Syntax.ConstructorDeclaration -> Typed.TypedTerm [Syntax.Parameter]
constructorDeclarationParameters x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ConstructorDeclaration"),
        Model.projectionFieldName = (Model.Name "parameters")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the body field of hydra.ext.cpp.syntax.ConstructorDeclaration
constructorDeclarationWithBody :: Typed.TypedTerm Syntax.ConstructorDeclaration -> Typed.TypedTerm Syntax.FunctionBody -> Typed.TypedTerm Syntax.ConstructorDeclaration
constructorDeclarationWithBody original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.ConstructorDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ConstructorDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ConstructorDeclaration"),
              Model.projectionFieldName = (Model.Name "parameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "initializers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ConstructorDeclaration"),
              Model.projectionFieldName = (Model.Name "initializers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the initializers field of hydra.ext.cpp.syntax.ConstructorDeclaration
constructorDeclarationWithInitializers :: Typed.TypedTerm Syntax.ConstructorDeclaration -> Typed.TypedTerm [Syntax.MemInitializer] -> Typed.TypedTerm Syntax.ConstructorDeclaration
constructorDeclarationWithInitializers original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.ConstructorDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ConstructorDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ConstructorDeclaration"),
              Model.projectionFieldName = (Model.Name "parameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "initializers"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ConstructorDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the name field of hydra.ext.cpp.syntax.ConstructorDeclaration
constructorDeclarationWithName :: Typed.TypedTerm Syntax.ConstructorDeclaration -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.ConstructorDeclaration
constructorDeclarationWithName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.ConstructorDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ConstructorDeclaration"),
              Model.projectionFieldName = (Model.Name "parameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "initializers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ConstructorDeclaration"),
              Model.projectionFieldName = (Model.Name "initializers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ConstructorDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the parameters field of hydra.ext.cpp.syntax.ConstructorDeclaration
constructorDeclarationWithParameters :: Typed.TypedTerm Syntax.ConstructorDeclaration -> Typed.TypedTerm [Syntax.Parameter] -> Typed.TypedTerm Syntax.ConstructorDeclaration
constructorDeclarationWithParameters original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.ConstructorDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ConstructorDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "initializers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ConstructorDeclaration"),
              Model.projectionFieldName = (Model.Name "initializers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ConstructorDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL name token for hydra.ext.cpp.syntax.ContainerDeclaration
containerDeclarationContainerDeclaration :: Typed.TypedName Syntax.ContainerDeclaration
containerDeclarationContainerDeclaration = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.ContainerDeclaration")

-- | DSL injection for the list variant of hydra.ext.cpp.syntax.ContainerDeclaration
containerDeclarationList :: Typed.TypedTerm Syntax.ListDeclaration -> Typed.TypedTerm Syntax.ContainerDeclaration
containerDeclarationList x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ContainerDeclaration"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "list"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the map variant of hydra.ext.cpp.syntax.ContainerDeclaration
containerDeclarationMap :: Typed.TypedTerm Syntax.MapDeclaration -> Typed.TypedTerm Syntax.ContainerDeclaration
containerDeclarationMap x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ContainerDeclaration"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "map"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the optional variant of hydra.ext.cpp.syntax.ContainerDeclaration
containerDeclarationOptional :: Typed.TypedTerm Syntax.OptionalDeclaration -> Typed.TypedTerm Syntax.ContainerDeclaration
containerDeclarationOptional x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ContainerDeclaration"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "optional"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the set variant of hydra.ext.cpp.syntax.ContainerDeclaration
containerDeclarationSet :: Typed.TypedTerm Syntax.SetDeclaration -> Typed.TypedTerm Syntax.ContainerDeclaration
containerDeclarationSet x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ContainerDeclaration"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "set"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the class variant of hydra.ext.cpp.syntax.Declaration
declarationClass :: Typed.TypedTerm Syntax.ClassDeclaration -> Typed.TypedTerm Syntax.Declaration
declarationClass x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Declaration"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "class"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.cpp.syntax.Declaration
declarationDeclaration :: Typed.TypedName Syntax.Declaration
declarationDeclaration = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.Declaration")

-- | DSL injection for the function variant of hydra.ext.cpp.syntax.Declaration
declarationFunction :: Typed.TypedTerm Syntax.FunctionDeclaration -> Typed.TypedTerm Syntax.Declaration
declarationFunction x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Declaration"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "function"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the namespace variant of hydra.ext.cpp.syntax.Declaration
declarationNamespace :: Typed.TypedTerm Syntax.NamespaceDeclaration -> Typed.TypedTerm Syntax.Declaration
declarationNamespace x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Declaration"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "namespace"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the preprocessor variant of hydra.ext.cpp.syntax.Declaration
declarationPreprocessor :: Typed.TypedTerm Syntax.PreprocessorDirective -> Typed.TypedTerm Syntax.Declaration
declarationPreprocessor x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Declaration"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "preprocessor"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the template variant of hydra.ext.cpp.syntax.Declaration
declarationTemplate :: Typed.TypedTerm Syntax.TemplateDeclaration -> Typed.TypedTerm Syntax.Declaration
declarationTemplate x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Declaration"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "template"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the typedef variant of hydra.ext.cpp.syntax.Declaration
declarationTypedef :: Typed.TypedTerm Syntax.TypedefDeclaration -> Typed.TypedTerm Syntax.Declaration
declarationTypedef x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Declaration"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "typedef"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the variable variant of hydra.ext.cpp.syntax.Declaration
declarationVariable :: Typed.TypedTerm Syntax.VariableDeclaration -> Typed.TypedTerm Syntax.Declaration
declarationVariable x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Declaration"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "variable"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for hydra.ext.cpp.syntax.DefineDirective
defineDirective :: Typed.TypedTerm String -> Typed.TypedTerm (Maybe [String]) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Syntax.DefineDirective
defineDirective name parameters replacement =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.DefineDirective"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Typed.unTypedTerm parameters)},
        Model.Field {
          Model.fieldName = (Model.Name "replacement"),
          Model.fieldTerm = (Typed.unTypedTerm replacement)}]}))

-- | DSL name token for hydra.ext.cpp.syntax.DefineDirective
defineDirectiveDefineDirective :: Typed.TypedName Syntax.DefineDirective
defineDirectiveDefineDirective = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.DefineDirective")

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

-- | DSL accessor for the parameters field of hydra.ext.cpp.syntax.DefineDirective
defineDirectiveParameters :: Typed.TypedTerm Syntax.DefineDirective -> Typed.TypedTerm (Maybe [String])
defineDirectiveParameters x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.DefineDirective"),
        Model.projectionFieldName = (Model.Name "parameters")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the replacement field of hydra.ext.cpp.syntax.DefineDirective
defineDirectiveReplacement :: Typed.TypedTerm Syntax.DefineDirective -> Typed.TypedTerm (Maybe String)
defineDirectiveReplacement x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.DefineDirective"),
        Model.projectionFieldName = (Model.Name "replacement")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the name field of hydra.ext.cpp.syntax.DefineDirective
defineDirectiveWithName :: Typed.TypedTerm Syntax.DefineDirective -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.DefineDirective
defineDirectiveWithName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.DefineDirective"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.DefineDirective"),
              Model.projectionFieldName = (Model.Name "parameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "replacement"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.DefineDirective"),
              Model.projectionFieldName = (Model.Name "replacement")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the parameters field of hydra.ext.cpp.syntax.DefineDirective
defineDirectiveWithParameters :: Typed.TypedTerm Syntax.DefineDirective -> Typed.TypedTerm (Maybe [String]) -> Typed.TypedTerm Syntax.DefineDirective
defineDirectiveWithParameters original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.DefineDirective"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.DefineDirective"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "replacement"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.DefineDirective"),
              Model.projectionFieldName = (Model.Name "replacement")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the replacement field of hydra.ext.cpp.syntax.DefineDirective
defineDirectiveWithReplacement :: Typed.TypedTerm Syntax.DefineDirective -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Syntax.DefineDirective
defineDirectiveWithReplacement original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.DefineDirective"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.DefineDirective"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.DefineDirective"),
              Model.projectionFieldName = (Model.Name "parameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "replacement"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for hydra.ext.cpp.syntax.DestructorDeclaration
destructorDeclaration :: Typed.TypedTerm [Syntax.FunctionSpecifierPrefix] -> Typed.TypedTerm String -> Typed.TypedTerm [Syntax.FunctionSpecifierSuffix] -> Typed.TypedTerm Syntax.FunctionBody -> Typed.TypedTerm Syntax.DestructorDeclaration
destructorDeclaration prefixSpecifiers name suffixSpecifiers body =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.DestructorDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "prefixSpecifiers"),
          Model.fieldTerm = (Typed.unTypedTerm prefixSpecifiers)},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)},
        Model.Field {
          Model.fieldName = (Model.Name "suffixSpecifiers"),
          Model.fieldTerm = (Typed.unTypedTerm suffixSpecifiers)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm body)}]}))

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

-- | DSL name token for hydra.ext.cpp.syntax.DestructorDeclaration
destructorDeclarationDestructorDeclaration :: Typed.TypedName Syntax.DestructorDeclaration
destructorDeclarationDestructorDeclaration = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.DestructorDeclaration")

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

-- | DSL accessor for the prefixSpecifiers field of hydra.ext.cpp.syntax.DestructorDeclaration
destructorDeclarationPrefixSpecifiers :: Typed.TypedTerm Syntax.DestructorDeclaration -> Typed.TypedTerm [Syntax.FunctionSpecifierPrefix]
destructorDeclarationPrefixSpecifiers x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.DestructorDeclaration"),
        Model.projectionFieldName = (Model.Name "prefixSpecifiers")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the suffixSpecifiers field of hydra.ext.cpp.syntax.DestructorDeclaration
destructorDeclarationSuffixSpecifiers :: Typed.TypedTerm Syntax.DestructorDeclaration -> Typed.TypedTerm [Syntax.FunctionSpecifierSuffix]
destructorDeclarationSuffixSpecifiers x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.DestructorDeclaration"),
        Model.projectionFieldName = (Model.Name "suffixSpecifiers")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the body field of hydra.ext.cpp.syntax.DestructorDeclaration
destructorDeclarationWithBody :: Typed.TypedTerm Syntax.DestructorDeclaration -> Typed.TypedTerm Syntax.FunctionBody -> Typed.TypedTerm Syntax.DestructorDeclaration
destructorDeclarationWithBody original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.DestructorDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "prefixSpecifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.DestructorDeclaration"),
              Model.projectionFieldName = (Model.Name "prefixSpecifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.DestructorDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "suffixSpecifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.DestructorDeclaration"),
              Model.projectionFieldName = (Model.Name "suffixSpecifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the name field of hydra.ext.cpp.syntax.DestructorDeclaration
destructorDeclarationWithName :: Typed.TypedTerm Syntax.DestructorDeclaration -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.DestructorDeclaration
destructorDeclarationWithName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.DestructorDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "prefixSpecifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.DestructorDeclaration"),
              Model.projectionFieldName = (Model.Name "prefixSpecifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "suffixSpecifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.DestructorDeclaration"),
              Model.projectionFieldName = (Model.Name "suffixSpecifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.DestructorDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the prefixSpecifiers field of hydra.ext.cpp.syntax.DestructorDeclaration
destructorDeclarationWithPrefixSpecifiers :: Typed.TypedTerm Syntax.DestructorDeclaration -> Typed.TypedTerm [Syntax.FunctionSpecifierPrefix] -> Typed.TypedTerm Syntax.DestructorDeclaration
destructorDeclarationWithPrefixSpecifiers original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.DestructorDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "prefixSpecifiers"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.DestructorDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "suffixSpecifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.DestructorDeclaration"),
              Model.projectionFieldName = (Model.Name "suffixSpecifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.DestructorDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the suffixSpecifiers field of hydra.ext.cpp.syntax.DestructorDeclaration
destructorDeclarationWithSuffixSpecifiers :: Typed.TypedTerm Syntax.DestructorDeclaration -> Typed.TypedTerm [Syntax.FunctionSpecifierSuffix] -> Typed.TypedTerm Syntax.DestructorDeclaration
destructorDeclarationWithSuffixSpecifiers original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.DestructorDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "prefixSpecifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.DestructorDeclaration"),
              Model.projectionFieldName = (Model.Name "prefixSpecifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.DestructorDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "suffixSpecifiers"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.DestructorDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.cpp.syntax.DivideOperation
divideOperation :: Typed.TypedTerm Syntax.MultiplicativeExpression -> Typed.TypedTerm Syntax.UnaryExpression -> Typed.TypedTerm Syntax.DivideOperation
divideOperation left right =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.DivideOperation"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Typed.unTypedTerm left)},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Typed.unTypedTerm right)}]}))

-- | DSL name token for hydra.ext.cpp.syntax.DivideOperation
divideOperationDivideOperation :: Typed.TypedName Syntax.DivideOperation
divideOperationDivideOperation = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.DivideOperation")

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

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

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

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

-- | DSL constructor for hydra.ext.cpp.syntax.DoStatement
doStatement :: Typed.TypedTerm Syntax.Statement -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.DoStatement
doStatement body condition =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.DoStatement"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm body)},
        Model.Field {
          Model.fieldName = (Model.Name "condition"),
          Model.fieldTerm = (Typed.unTypedTerm condition)}]}))

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

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

-- | DSL name token for hydra.ext.cpp.syntax.DoStatement
doStatementDoStatement :: Typed.TypedName Syntax.DoStatement
doStatementDoStatement = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.DoStatement")

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

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

-- | DSL constructor for hydra.ext.cpp.syntax.ElifDirective
elifDirective :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.ElifDirective
elifDirective condition =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.ElifDirective"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "condition"),
          Model.fieldTerm = (Typed.unTypedTerm condition)}]}))

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

-- | DSL name token for hydra.ext.cpp.syntax.ElifDirective
elifDirectiveElifDirective :: Typed.TypedName Syntax.ElifDirective
elifDirectiveElifDirective = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.ElifDirective")

-- | DSL updater for the condition field of hydra.ext.cpp.syntax.ElifDirective
elifDirectiveWithCondition :: Typed.TypedTerm Syntax.ElifDirective -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.ElifDirective
elifDirectiveWithCondition original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.ElifDirective"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "condition"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for hydra.ext.cpp.syntax.EqualOperation
equalOperation :: Typed.TypedTerm Syntax.EqualityExpression -> Typed.TypedTerm Syntax.RelationalExpression -> Typed.TypedTerm Syntax.EqualOperation
equalOperation left right =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.EqualOperation"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Typed.unTypedTerm left)},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Typed.unTypedTerm right)}]}))

-- | DSL name token for hydra.ext.cpp.syntax.EqualOperation
equalOperationEqualOperation :: Typed.TypedName Syntax.EqualOperation
equalOperationEqualOperation = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.EqualOperation")

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

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

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

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

-- | DSL injection for the equal variant of hydra.ext.cpp.syntax.EqualityExpression
equalityExpressionEqual :: Typed.TypedTerm Syntax.EqualOperation -> Typed.TypedTerm Syntax.EqualityExpression
equalityExpressionEqual x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.EqualityExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "equal"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.cpp.syntax.EqualityExpression
equalityExpressionEqualityExpression :: Typed.TypedName Syntax.EqualityExpression
equalityExpressionEqualityExpression = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.EqualityExpression")

-- | DSL injection for the notEqual variant of hydra.ext.cpp.syntax.EqualityExpression
equalityExpressionNotEqual :: Typed.TypedTerm Syntax.NotEqualOperation -> Typed.TypedTerm Syntax.EqualityExpression
equalityExpressionNotEqual x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.EqualityExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "notEqual"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the relational variant of hydra.ext.cpp.syntax.EqualityExpression
equalityExpressionRelational :: Typed.TypedTerm Syntax.RelationalExpression -> Typed.TypedTerm Syntax.EqualityExpression
equalityExpressionRelational x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.EqualityExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "relational"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for hydra.ext.cpp.syntax.ErrorDirective
errorDirective :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.ErrorDirective
errorDirective message =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.ErrorDirective"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "message"),
          Model.fieldTerm = (Typed.unTypedTerm message)}]}))

-- | DSL name token for hydra.ext.cpp.syntax.ErrorDirective
errorDirectiveErrorDirective :: Typed.TypedName Syntax.ErrorDirective
errorDirectiveErrorDirective = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.ErrorDirective")

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

-- | DSL updater for the message field of hydra.ext.cpp.syntax.ErrorDirective
errorDirectiveWithMessage :: Typed.TypedTerm Syntax.ErrorDirective -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.ErrorDirective
errorDirectiveWithMessage original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.ErrorDirective"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "message"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL injection for the and variant of hydra.ext.cpp.syntax.ExclusiveOrExpression
exclusiveOrExpressionAnd :: Typed.TypedTerm Syntax.AndExpression -> Typed.TypedTerm Syntax.ExclusiveOrExpression
exclusiveOrExpressionAnd x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ExclusiveOrExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "and"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the bitwiseXor variant of hydra.ext.cpp.syntax.ExclusiveOrExpression
exclusiveOrExpressionBitwiseXor :: Typed.TypedTerm Syntax.BitwiseXorOperation -> Typed.TypedTerm Syntax.ExclusiveOrExpression
exclusiveOrExpressionBitwiseXor x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ExclusiveOrExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "bitwiseXor"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.cpp.syntax.ExclusiveOrExpression
exclusiveOrExpressionExclusiveOrExpression :: Typed.TypedName Syntax.ExclusiveOrExpression
exclusiveOrExpressionExclusiveOrExpression = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.ExclusiveOrExpression")

-- | DSL constructor for hydra.ext.cpp.syntax.ExplicitAssignment
explicitAssignment :: Typed.TypedTerm Syntax.LogicalOrExpression -> Typed.TypedTerm Syntax.AssignmentOperator -> Typed.TypedTerm Syntax.AssignmentExpression -> Typed.TypedTerm Syntax.ExplicitAssignment
explicitAssignment left op right =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.ExplicitAssignment"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Typed.unTypedTerm left)},
        Model.Field {
          Model.fieldName = (Model.Name "op"),
          Model.fieldTerm = (Typed.unTypedTerm op)},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Typed.unTypedTerm right)}]}))

-- | DSL name token for hydra.ext.cpp.syntax.ExplicitAssignment
explicitAssignmentExplicitAssignment :: Typed.TypedName Syntax.ExplicitAssignment
explicitAssignmentExplicitAssignment = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.ExplicitAssignment")

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

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

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

-- | DSL updater for the left field of hydra.ext.cpp.syntax.ExplicitAssignment
explicitAssignmentWithLeft :: Typed.TypedTerm Syntax.ExplicitAssignment -> Typed.TypedTerm Syntax.LogicalOrExpression -> Typed.TypedTerm Syntax.ExplicitAssignment
explicitAssignmentWithLeft original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.ExplicitAssignment"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "op"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ExplicitAssignment"),
              Model.projectionFieldName = (Model.Name "op")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ExplicitAssignment"),
              Model.projectionFieldName = (Model.Name "right")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the op field of hydra.ext.cpp.syntax.ExplicitAssignment
explicitAssignmentWithOp :: Typed.TypedTerm Syntax.ExplicitAssignment -> Typed.TypedTerm Syntax.AssignmentOperator -> Typed.TypedTerm Syntax.ExplicitAssignment
explicitAssignmentWithOp original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.ExplicitAssignment"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ExplicitAssignment"),
              Model.projectionFieldName = (Model.Name "left")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "op"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ExplicitAssignment"),
              Model.projectionFieldName = (Model.Name "right")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the right field of hydra.ext.cpp.syntax.ExplicitAssignment
explicitAssignmentWithRight :: Typed.TypedTerm Syntax.ExplicitAssignment -> Typed.TypedTerm Syntax.AssignmentExpression -> Typed.TypedTerm Syntax.ExplicitAssignment
explicitAssignmentWithRight original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.ExplicitAssignment"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ExplicitAssignment"),
              Model.projectionFieldName = (Model.Name "left")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "op"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ExplicitAssignment"),
              Model.projectionFieldName = (Model.Name "op")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL injection for the assignment variant of hydra.ext.cpp.syntax.Expression
expressionAssignment :: Typed.TypedTerm Syntax.AssignmentExpression -> Typed.TypedTerm Syntax.Expression
expressionAssignment x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Expression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "assignment"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the comma variant of hydra.ext.cpp.syntax.Expression
expressionComma :: Typed.TypedTerm Syntax.CommaExpression -> Typed.TypedTerm Syntax.Expression
expressionComma x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Expression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "comma"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.cpp.syntax.Expression
expressionExpression :: Typed.TypedName Syntax.Expression
expressionExpression = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.Expression")

-- | DSL constructor for the hydra.ext.cpp.syntax.ExpressionStatement wrapper
expressionStatement :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.ExpressionStatement
expressionStatement x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.cpp.syntax.ExpressionStatement"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.cpp.syntax.ExpressionStatement
expressionStatementExpressionStatement :: Typed.TypedName Syntax.ExpressionStatement
expressionStatementExpressionStatement = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.ExpressionStatement")

-- | DSL constructor for the hydra.ext.cpp.syntax.FloatingLiteral wrapper
floatingLiteral :: Typed.TypedTerm Double -> Typed.TypedTerm Syntax.FloatingLiteral
floatingLiteral x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.cpp.syntax.FloatingLiteral"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.cpp.syntax.FloatingLiteral
floatingLiteralFloatingLiteral :: Typed.TypedName Syntax.FloatingLiteral
floatingLiteralFloatingLiteral = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.FloatingLiteral")

-- | DSL injection for the declaration variant of hydra.ext.cpp.syntax.ForInit
forInitDeclaration :: Typed.TypedTerm Syntax.VariableDeclaration -> Typed.TypedTerm Syntax.ForInit
forInitDeclaration x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ForInit"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "declaration"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the empty variant of hydra.ext.cpp.syntax.ForInit
forInitEmpty :: Typed.TypedTerm Syntax.ForInit
forInitEmpty =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ForInit"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "empty"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the expression variant of hydra.ext.cpp.syntax.ForInit
forInitExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.ForInit
forInitExpression x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ForInit"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "expression"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.cpp.syntax.ForInit
forInitForInit :: Typed.TypedName Syntax.ForInit
forInitForInit = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.ForInit")

-- | DSL constructor for hydra.ext.cpp.syntax.ForStatement
forStatement :: Typed.TypedTerm Syntax.ForInit -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Statement -> Typed.TypedTerm Syntax.ForStatement
forStatement init condition increment body =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.ForStatement"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "init"),
          Model.fieldTerm = (Typed.unTypedTerm init)},
        Model.Field {
          Model.fieldName = (Model.Name "condition"),
          Model.fieldTerm = (Typed.unTypedTerm condition)},
        Model.Field {
          Model.fieldName = (Model.Name "increment"),
          Model.fieldTerm = (Typed.unTypedTerm increment)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm body)}]}))

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

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

-- | DSL name token for hydra.ext.cpp.syntax.ForStatement
forStatementForStatement :: Typed.TypedName Syntax.ForStatement
forStatementForStatement = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.ForStatement")

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

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

-- | DSL updater for the body field of hydra.ext.cpp.syntax.ForStatement
forStatementWithBody :: Typed.TypedTerm Syntax.ForStatement -> Typed.TypedTerm Syntax.Statement -> Typed.TypedTerm Syntax.ForStatement
forStatementWithBody original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.ForStatement"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "init"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ForStatement"),
              Model.projectionFieldName = (Model.Name "init")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "condition"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ForStatement"),
              Model.projectionFieldName = (Model.Name "condition")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "increment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ForStatement"),
              Model.projectionFieldName = (Model.Name "increment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the condition field of hydra.ext.cpp.syntax.ForStatement
forStatementWithCondition :: Typed.TypedTerm Syntax.ForStatement -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.ForStatement
forStatementWithCondition original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.ForStatement"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "init"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ForStatement"),
              Model.projectionFieldName = (Model.Name "init")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "condition"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "increment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ForStatement"),
              Model.projectionFieldName = (Model.Name "increment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ForStatement"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the increment field of hydra.ext.cpp.syntax.ForStatement
forStatementWithIncrement :: Typed.TypedTerm Syntax.ForStatement -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.ForStatement
forStatementWithIncrement original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.ForStatement"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "init"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ForStatement"),
              Model.projectionFieldName = (Model.Name "init")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "condition"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ForStatement"),
              Model.projectionFieldName = (Model.Name "condition")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "increment"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ForStatement"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the init field of hydra.ext.cpp.syntax.ForStatement
forStatementWithInit :: Typed.TypedTerm Syntax.ForStatement -> Typed.TypedTerm Syntax.ForInit -> Typed.TypedTerm Syntax.ForStatement
forStatementWithInit original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.ForStatement"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "init"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "condition"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ForStatement"),
              Model.projectionFieldName = (Model.Name "condition")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "increment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ForStatement"),
              Model.projectionFieldName = (Model.Name "increment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ForStatement"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.cpp.syntax.FunctionApplication
functionApplication :: Typed.TypedTerm Syntax.FunctionIdentifier -> Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.FunctionApplication
functionApplication function arguments =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionApplication"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "function"),
          Model.fieldTerm = (Typed.unTypedTerm function)},
        Model.Field {
          Model.fieldName = (Model.Name "arguments"),
          Model.fieldTerm = (Typed.unTypedTerm arguments)}]}))

-- | DSL accessor for the arguments field of hydra.ext.cpp.syntax.FunctionApplication
functionApplicationArguments :: Typed.TypedTerm Syntax.FunctionApplication -> Typed.TypedTerm [Syntax.Expression]
functionApplicationArguments x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionApplication"),
        Model.projectionFieldName = (Model.Name "arguments")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

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

-- | DSL name token for hydra.ext.cpp.syntax.FunctionApplication
functionApplicationFunctionApplication :: Typed.TypedName Syntax.FunctionApplication
functionApplicationFunctionApplication = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.FunctionApplication")

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

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

-- | DSL injection for the compound variant of hydra.ext.cpp.syntax.FunctionBody
functionBodyCompound :: Typed.TypedTerm Syntax.CompoundStatement -> Typed.TypedTerm Syntax.FunctionBody
functionBodyCompound x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionBody"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "compound"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the declaration variant of hydra.ext.cpp.syntax.FunctionBody
functionBodyDeclaration :: Typed.TypedTerm Syntax.FunctionBody
functionBodyDeclaration =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionBody"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "declaration"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the default variant of hydra.ext.cpp.syntax.FunctionBody
functionBodyDefault :: Typed.TypedTerm Syntax.FunctionBody
functionBodyDefault =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionBody"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "default"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL name token for hydra.ext.cpp.syntax.FunctionBody
functionBodyFunctionBody :: Typed.TypedName Syntax.FunctionBody
functionBodyFunctionBody = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.FunctionBody")

-- | DSL injection for the pure variant of hydra.ext.cpp.syntax.FunctionBody
functionBodyPure :: Typed.TypedTerm Syntax.FunctionBody
functionBodyPure =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionBody"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "pure"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL constructor for hydra.ext.cpp.syntax.FunctionCallOperation
functionCallOperation :: Typed.TypedTerm Syntax.PostfixExpression -> Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.FunctionCallOperation
functionCallOperation function arguments =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionCallOperation"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "function"),
          Model.fieldTerm = (Typed.unTypedTerm function)},
        Model.Field {
          Model.fieldName = (Model.Name "arguments"),
          Model.fieldTerm = (Typed.unTypedTerm arguments)}]}))

-- | DSL accessor for the arguments field of hydra.ext.cpp.syntax.FunctionCallOperation
functionCallOperationArguments :: Typed.TypedTerm Syntax.FunctionCallOperation -> Typed.TypedTerm [Syntax.Expression]
functionCallOperationArguments x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionCallOperation"),
        Model.projectionFieldName = (Model.Name "arguments")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

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

-- | DSL name token for hydra.ext.cpp.syntax.FunctionCallOperation
functionCallOperationFunctionCallOperation :: Typed.TypedName Syntax.FunctionCallOperation
functionCallOperationFunctionCallOperation = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.FunctionCallOperation")

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

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

-- | DSL constructor for hydra.ext.cpp.syntax.FunctionDeclaration
functionDeclaration :: Typed.TypedTerm [Syntax.FunctionSpecifierPrefix] -> Typed.TypedTerm Syntax.TypeExpression -> Typed.TypedTerm String -> Typed.TypedTerm [Syntax.Parameter] -> Typed.TypedTerm [Syntax.FunctionSpecifierSuffix] -> Typed.TypedTerm Syntax.FunctionBody -> Typed.TypedTerm Syntax.FunctionDeclaration
functionDeclaration prefixSpecifiers returnType name parameters suffixSpecifiers body =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "prefixSpecifiers"),
          Model.fieldTerm = (Typed.unTypedTerm prefixSpecifiers)},
        Model.Field {
          Model.fieldName = (Model.Name "returnType"),
          Model.fieldTerm = (Typed.unTypedTerm returnType)},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Typed.unTypedTerm parameters)},
        Model.Field {
          Model.fieldName = (Model.Name "suffixSpecifiers"),
          Model.fieldTerm = (Typed.unTypedTerm suffixSpecifiers)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm body)}]}))

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

-- | DSL name token for hydra.ext.cpp.syntax.FunctionDeclaration
functionDeclarationFunctionDeclaration :: Typed.TypedName Syntax.FunctionDeclaration
functionDeclarationFunctionDeclaration = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration")

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

-- | DSL accessor for the parameters field of hydra.ext.cpp.syntax.FunctionDeclaration
functionDeclarationParameters :: Typed.TypedTerm Syntax.FunctionDeclaration -> Typed.TypedTerm [Syntax.Parameter]
functionDeclarationParameters x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"),
        Model.projectionFieldName = (Model.Name "parameters")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the prefixSpecifiers field of hydra.ext.cpp.syntax.FunctionDeclaration
functionDeclarationPrefixSpecifiers :: Typed.TypedTerm Syntax.FunctionDeclaration -> Typed.TypedTerm [Syntax.FunctionSpecifierPrefix]
functionDeclarationPrefixSpecifiers x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"),
        Model.projectionFieldName = (Model.Name "prefixSpecifiers")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

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

-- | DSL accessor for the suffixSpecifiers field of hydra.ext.cpp.syntax.FunctionDeclaration
functionDeclarationSuffixSpecifiers :: Typed.TypedTerm Syntax.FunctionDeclaration -> Typed.TypedTerm [Syntax.FunctionSpecifierSuffix]
functionDeclarationSuffixSpecifiers x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"),
        Model.projectionFieldName = (Model.Name "suffixSpecifiers")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the body field of hydra.ext.cpp.syntax.FunctionDeclaration
functionDeclarationWithBody :: Typed.TypedTerm Syntax.FunctionDeclaration -> Typed.TypedTerm Syntax.FunctionBody -> Typed.TypedTerm Syntax.FunctionDeclaration
functionDeclarationWithBody original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "prefixSpecifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"),
              Model.projectionFieldName = (Model.Name "prefixSpecifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "returnType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"),
              Model.projectionFieldName = (Model.Name "returnType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"),
              Model.projectionFieldName = (Model.Name "parameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "suffixSpecifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"),
              Model.projectionFieldName = (Model.Name "suffixSpecifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the name field of hydra.ext.cpp.syntax.FunctionDeclaration
functionDeclarationWithName :: Typed.TypedTerm Syntax.FunctionDeclaration -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.FunctionDeclaration
functionDeclarationWithName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "prefixSpecifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"),
              Model.projectionFieldName = (Model.Name "prefixSpecifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "returnType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"),
              Model.projectionFieldName = (Model.Name "returnType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"),
              Model.projectionFieldName = (Model.Name "parameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "suffixSpecifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"),
              Model.projectionFieldName = (Model.Name "suffixSpecifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the parameters field of hydra.ext.cpp.syntax.FunctionDeclaration
functionDeclarationWithParameters :: Typed.TypedTerm Syntax.FunctionDeclaration -> Typed.TypedTerm [Syntax.Parameter] -> Typed.TypedTerm Syntax.FunctionDeclaration
functionDeclarationWithParameters original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "prefixSpecifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"),
              Model.projectionFieldName = (Model.Name "prefixSpecifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "returnType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"),
              Model.projectionFieldName = (Model.Name "returnType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "suffixSpecifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"),
              Model.projectionFieldName = (Model.Name "suffixSpecifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the prefixSpecifiers field of hydra.ext.cpp.syntax.FunctionDeclaration
functionDeclarationWithPrefixSpecifiers :: Typed.TypedTerm Syntax.FunctionDeclaration -> Typed.TypedTerm [Syntax.FunctionSpecifierPrefix] -> Typed.TypedTerm Syntax.FunctionDeclaration
functionDeclarationWithPrefixSpecifiers original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "prefixSpecifiers"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "returnType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"),
              Model.projectionFieldName = (Model.Name "returnType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"),
              Model.projectionFieldName = (Model.Name "parameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "suffixSpecifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"),
              Model.projectionFieldName = (Model.Name "suffixSpecifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the returnType field of hydra.ext.cpp.syntax.FunctionDeclaration
functionDeclarationWithReturnType :: Typed.TypedTerm Syntax.FunctionDeclaration -> Typed.TypedTerm Syntax.TypeExpression -> Typed.TypedTerm Syntax.FunctionDeclaration
functionDeclarationWithReturnType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "prefixSpecifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"),
              Model.projectionFieldName = (Model.Name "prefixSpecifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "returnType"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"),
              Model.projectionFieldName = (Model.Name "parameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "suffixSpecifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"),
              Model.projectionFieldName = (Model.Name "suffixSpecifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the suffixSpecifiers field of hydra.ext.cpp.syntax.FunctionDeclaration
functionDeclarationWithSuffixSpecifiers :: Typed.TypedTerm Syntax.FunctionDeclaration -> Typed.TypedTerm [Syntax.FunctionSpecifierSuffix] -> Typed.TypedTerm Syntax.FunctionDeclaration
functionDeclarationWithSuffixSpecifiers original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "prefixSpecifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"),
              Model.projectionFieldName = (Model.Name "prefixSpecifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "returnType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"),
              Model.projectionFieldName = (Model.Name "returnType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"),
              Model.projectionFieldName = (Model.Name "parameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "suffixSpecifiers"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL name token for hydra.ext.cpp.syntax.FunctionIdentifier
functionIdentifierFunctionIdentifier :: Typed.TypedName Syntax.FunctionIdentifier
functionIdentifierFunctionIdentifier = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.FunctionIdentifier")

-- | DSL injection for the qualified variant of hydra.ext.cpp.syntax.FunctionIdentifier
functionIdentifierQualified :: Typed.TypedTerm Syntax.QualifiedIdentifier -> Typed.TypedTerm Syntax.FunctionIdentifier
functionIdentifierQualified x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionIdentifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "qualified"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the simple variant of hydra.ext.cpp.syntax.FunctionIdentifier
functionIdentifierSimple :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.FunctionIdentifier
functionIdentifierSimple x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionIdentifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "simple"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the explicit variant of hydra.ext.cpp.syntax.FunctionSpecifierPrefix
functionSpecifierPrefixExplicit :: Typed.TypedTerm Syntax.FunctionSpecifierPrefix
functionSpecifierPrefixExplicit =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionSpecifierPrefix"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "explicit"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL name token for hydra.ext.cpp.syntax.FunctionSpecifierPrefix
functionSpecifierPrefixFunctionSpecifierPrefix :: Typed.TypedName Syntax.FunctionSpecifierPrefix
functionSpecifierPrefixFunctionSpecifierPrefix =
    Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.FunctionSpecifierPrefix")

-- | DSL injection for the inline variant of hydra.ext.cpp.syntax.FunctionSpecifierPrefix
functionSpecifierPrefixInline :: Typed.TypedTerm Syntax.FunctionSpecifierPrefix
functionSpecifierPrefixInline =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionSpecifierPrefix"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "inline"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the static variant of hydra.ext.cpp.syntax.FunctionSpecifierPrefix
functionSpecifierPrefixStatic :: Typed.TypedTerm Syntax.FunctionSpecifierPrefix
functionSpecifierPrefixStatic =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionSpecifierPrefix"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "static"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the virtual variant of hydra.ext.cpp.syntax.FunctionSpecifierPrefix
functionSpecifierPrefixVirtual :: Typed.TypedTerm Syntax.FunctionSpecifierPrefix
functionSpecifierPrefixVirtual =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionSpecifierPrefix"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "virtual"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the const variant of hydra.ext.cpp.syntax.FunctionSpecifierSuffix
functionSpecifierSuffixConst :: Typed.TypedTerm Syntax.FunctionSpecifierSuffix
functionSpecifierSuffixConst =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionSpecifierSuffix"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "const"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the final variant of hydra.ext.cpp.syntax.FunctionSpecifierSuffix
functionSpecifierSuffixFinal :: Typed.TypedTerm Syntax.FunctionSpecifierSuffix
functionSpecifierSuffixFinal =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionSpecifierSuffix"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "final"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL name token for hydra.ext.cpp.syntax.FunctionSpecifierSuffix
functionSpecifierSuffixFunctionSpecifierSuffix :: Typed.TypedName Syntax.FunctionSpecifierSuffix
functionSpecifierSuffixFunctionSpecifierSuffix =
    Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.FunctionSpecifierSuffix")

-- | DSL injection for the noexcept variant of hydra.ext.cpp.syntax.FunctionSpecifierSuffix
functionSpecifierSuffixNoexcept :: Typed.TypedTerm Syntax.FunctionSpecifierSuffix
functionSpecifierSuffixNoexcept =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionSpecifierSuffix"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "noexcept"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the override variant of hydra.ext.cpp.syntax.FunctionSpecifierSuffix
functionSpecifierSuffixOverride :: Typed.TypedTerm Syntax.FunctionSpecifierSuffix
functionSpecifierSuffixOverride =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionSpecifierSuffix"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "override"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL constructor for hydra.ext.cpp.syntax.FunctionType
functionType :: Typed.TypedTerm Syntax.TypeExpression -> Typed.TypedTerm [Syntax.Parameter] -> Typed.TypedTerm Syntax.FunctionType
functionType returnType parameters =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionType"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "returnType"),
          Model.fieldTerm = (Typed.unTypedTerm returnType)},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Typed.unTypedTerm parameters)}]}))

-- | DSL name token for hydra.ext.cpp.syntax.FunctionType
functionTypeFunctionType :: Typed.TypedName Syntax.FunctionType
functionTypeFunctionType = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.FunctionType")

-- | DSL accessor for the parameters field of hydra.ext.cpp.syntax.FunctionType
functionTypeParameters :: Typed.TypedTerm Syntax.FunctionType -> Typed.TypedTerm [Syntax.Parameter]
functionTypeParameters x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.FunctionType"),
        Model.projectionFieldName = (Model.Name "parameters")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

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

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

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

-- | DSL constructor for hydra.ext.cpp.syntax.GreaterEqualOperation
greaterEqualOperation :: Typed.TypedTerm Syntax.RelationalExpression -> Typed.TypedTerm Syntax.ShiftExpression -> Typed.TypedTerm Syntax.GreaterEqualOperation
greaterEqualOperation left right =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.GreaterEqualOperation"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Typed.unTypedTerm left)},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Typed.unTypedTerm right)}]}))

-- | DSL name token for hydra.ext.cpp.syntax.GreaterEqualOperation
greaterEqualOperationGreaterEqualOperation :: Typed.TypedName Syntax.GreaterEqualOperation
greaterEqualOperationGreaterEqualOperation = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.GreaterEqualOperation")

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

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

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

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

-- | DSL constructor for hydra.ext.cpp.syntax.GreaterOperation
greaterOperation :: Typed.TypedTerm Syntax.RelationalExpression -> Typed.TypedTerm Syntax.ShiftExpression -> Typed.TypedTerm Syntax.GreaterOperation
greaterOperation left right =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.GreaterOperation"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Typed.unTypedTerm left)},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Typed.unTypedTerm right)}]}))

-- | DSL name token for hydra.ext.cpp.syntax.GreaterOperation
greaterOperationGreaterOperation :: Typed.TypedName Syntax.GreaterOperation
greaterOperationGreaterOperation = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.GreaterOperation")

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

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

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

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

-- | DSL constructor for hydra.ext.cpp.syntax.IfDirective
ifDirective :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.IfDirective
ifDirective condition =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.IfDirective"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "condition"),
          Model.fieldTerm = (Typed.unTypedTerm condition)}]}))

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

-- | DSL name token for hydra.ext.cpp.syntax.IfDirective
ifDirectiveIfDirective :: Typed.TypedName Syntax.IfDirective
ifDirectiveIfDirective = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.IfDirective")

-- | DSL updater for the condition field of hydra.ext.cpp.syntax.IfDirective
ifDirectiveWithCondition :: Typed.TypedTerm Syntax.IfDirective -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.IfDirective
ifDirectiveWithCondition original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.IfDirective"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "condition"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for hydra.ext.cpp.syntax.IfdefDirective
ifdefDirective :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.IfdefDirective
ifdefDirective identifier =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.IfdefDirective"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Typed.unTypedTerm identifier)}]}))

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

-- | DSL name token for hydra.ext.cpp.syntax.IfdefDirective
ifdefDirectiveIfdefDirective :: Typed.TypedName Syntax.IfdefDirective
ifdefDirectiveIfdefDirective = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.IfdefDirective")

-- | DSL updater for the identifier field of hydra.ext.cpp.syntax.IfdefDirective
ifdefDirectiveWithIdentifier :: Typed.TypedTerm Syntax.IfdefDirective -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.IfdefDirective
ifdefDirectiveWithIdentifier original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.IfdefDirective"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for hydra.ext.cpp.syntax.IfndefDirective
ifndefDirective :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.IfndefDirective
ifndefDirective identifier =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.IfndefDirective"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Typed.unTypedTerm identifier)}]}))

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

-- | DSL name token for hydra.ext.cpp.syntax.IfndefDirective
ifndefDirectiveIfndefDirective :: Typed.TypedName Syntax.IfndefDirective
ifndefDirectiveIfndefDirective = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.IfndefDirective")

-- | DSL updater for the identifier field of hydra.ext.cpp.syntax.IfndefDirective
ifndefDirectiveWithIdentifier :: Typed.TypedTerm Syntax.IfndefDirective -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.IfndefDirective
ifndefDirectiveWithIdentifier original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.IfndefDirective"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for hydra.ext.cpp.syntax.IncludeDirective
includeDirective :: Typed.TypedTerm String -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.IncludeDirective
includeDirective name isSystem =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.IncludeDirective"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)},
        Model.Field {
          Model.fieldName = (Model.Name "isSystem"),
          Model.fieldTerm = (Typed.unTypedTerm isSystem)}]}))

-- | DSL name token for hydra.ext.cpp.syntax.IncludeDirective
includeDirectiveIncludeDirective :: Typed.TypedName Syntax.IncludeDirective
includeDirectiveIncludeDirective = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.IncludeDirective")

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

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

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

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

-- | DSL injection for the bitwiseOr variant of hydra.ext.cpp.syntax.InclusiveOrExpression
inclusiveOrExpressionBitwiseOr :: Typed.TypedTerm Syntax.BitwiseOrOperation -> Typed.TypedTerm Syntax.InclusiveOrExpression
inclusiveOrExpressionBitwiseOr x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.InclusiveOrExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "bitwiseOr"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the exclusiveOr variant of hydra.ext.cpp.syntax.InclusiveOrExpression
inclusiveOrExpressionExclusiveOr :: Typed.TypedTerm Syntax.ExclusiveOrExpression -> Typed.TypedTerm Syntax.InclusiveOrExpression
inclusiveOrExpressionExclusiveOr x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.InclusiveOrExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "exclusiveOr"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.cpp.syntax.InclusiveOrExpression
inclusiveOrExpressionInclusiveOrExpression :: Typed.TypedName Syntax.InclusiveOrExpression
inclusiveOrExpressionInclusiveOrExpression = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.InclusiveOrExpression")

-- | DSL injection for the binary variant of hydra.ext.cpp.syntax.IntegerLiteral
integerLiteralBinary :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.IntegerLiteral
integerLiteralBinary x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.IntegerLiteral"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "binary"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the decimal variant of hydra.ext.cpp.syntax.IntegerLiteral
integerLiteralDecimal :: Typed.TypedTerm Integer -> Typed.TypedTerm Syntax.IntegerLiteral
integerLiteralDecimal x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.IntegerLiteral"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "decimal"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the hexadecimal variant of hydra.ext.cpp.syntax.IntegerLiteral
integerLiteralHexadecimal :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.IntegerLiteral
integerLiteralHexadecimal x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.IntegerLiteral"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "hexadecimal"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.cpp.syntax.IntegerLiteral
integerLiteralIntegerLiteral :: Typed.TypedName Syntax.IntegerLiteral
integerLiteralIntegerLiteral = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.IntegerLiteral")

-- | DSL injection for the octal variant of hydra.ext.cpp.syntax.IntegerLiteral
integerLiteralOctal :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.IntegerLiteral
integerLiteralOctal x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.IntegerLiteral"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "octal"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the do variant of hydra.ext.cpp.syntax.IterationStatement
iterationStatementDo :: Typed.TypedTerm Syntax.DoStatement -> Typed.TypedTerm Syntax.IterationStatement
iterationStatementDo x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.IterationStatement"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "do"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

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

-- | DSL name token for hydra.ext.cpp.syntax.IterationStatement
iterationStatementIterationStatement :: Typed.TypedName Syntax.IterationStatement
iterationStatementIterationStatement = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.IterationStatement")

-- | DSL injection for the rangeFor variant of hydra.ext.cpp.syntax.IterationStatement
iterationStatementRangeFor :: Typed.TypedTerm Syntax.RangeForStatement -> Typed.TypedTerm Syntax.IterationStatement
iterationStatementRangeFor x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.IterationStatement"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "rangeFor"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the while variant of hydra.ext.cpp.syntax.IterationStatement
iterationStatementWhile :: Typed.TypedTerm Syntax.WhileStatement -> Typed.TypedTerm Syntax.IterationStatement
iterationStatementWhile x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.IterationStatement"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "while"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the break variant of hydra.ext.cpp.syntax.JumpStatement
jumpStatementBreak :: Typed.TypedTerm Syntax.JumpStatement
jumpStatementBreak =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.JumpStatement"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "break"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the continue variant of hydra.ext.cpp.syntax.JumpStatement
jumpStatementContinue :: Typed.TypedTerm Syntax.JumpStatement
jumpStatementContinue =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.JumpStatement"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "continue"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL name token for hydra.ext.cpp.syntax.JumpStatement
jumpStatementJumpStatement :: Typed.TypedName Syntax.JumpStatement
jumpStatementJumpStatement = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.JumpStatement")

-- | DSL injection for the returnValue variant of hydra.ext.cpp.syntax.JumpStatement
jumpStatementReturnValue :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.JumpStatement
jumpStatementReturnValue x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.JumpStatement"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "returnValue"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the returnVoid variant of hydra.ext.cpp.syntax.JumpStatement
jumpStatementReturnVoid :: Typed.TypedTerm Syntax.JumpStatement
jumpStatementReturnVoid =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.JumpStatement"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "returnVoid"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the throw variant of hydra.ext.cpp.syntax.JumpStatement
jumpStatementThrow :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.JumpStatement
jumpStatementThrow x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.JumpStatement"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "throw"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for hydra.ext.cpp.syntax.LabeledStatement
labeledStatement :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.Statement -> Typed.TypedTerm Syntax.LabeledStatement
labeledStatement label statement =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.LabeledStatement"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "label"),
          Model.fieldTerm = (Typed.unTypedTerm label)},
        Model.Field {
          Model.fieldName = (Model.Name "statement"),
          Model.fieldTerm = (Typed.unTypedTerm statement)}]}))

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

-- | DSL name token for hydra.ext.cpp.syntax.LabeledStatement
labeledStatementLabeledStatement :: Typed.TypedName Syntax.LabeledStatement
labeledStatementLabeledStatement = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.LabeledStatement")

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

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

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

-- | DSL constructor for hydra.ext.cpp.syntax.LambdaExpression
lambdaExpression :: Typed.TypedTerm Syntax.CaptureList -> Typed.TypedTerm [Syntax.Parameter] -> Typed.TypedTerm (Maybe Syntax.TypeExpression) -> Typed.TypedTerm Syntax.CompoundStatement -> Typed.TypedTerm Syntax.LambdaExpression
lambdaExpression captures parameters returnType body =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.LambdaExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "captures"),
          Model.fieldTerm = (Typed.unTypedTerm captures)},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Typed.unTypedTerm parameters)},
        Model.Field {
          Model.fieldName = (Model.Name "returnType"),
          Model.fieldTerm = (Typed.unTypedTerm returnType)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm body)}]}))

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

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

-- | DSL name token for hydra.ext.cpp.syntax.LambdaExpression
lambdaExpressionLambdaExpression :: Typed.TypedName Syntax.LambdaExpression
lambdaExpressionLambdaExpression = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.LambdaExpression")

-- | DSL accessor for the parameters field of hydra.ext.cpp.syntax.LambdaExpression
lambdaExpressionParameters :: Typed.TypedTerm Syntax.LambdaExpression -> Typed.TypedTerm [Syntax.Parameter]
lambdaExpressionParameters x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.LambdaExpression"),
        Model.projectionFieldName = (Model.Name "parameters")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the returnType field of hydra.ext.cpp.syntax.LambdaExpression
lambdaExpressionReturnType :: Typed.TypedTerm Syntax.LambdaExpression -> Typed.TypedTerm (Maybe Syntax.TypeExpression)
lambdaExpressionReturnType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.LambdaExpression"),
        Model.projectionFieldName = (Model.Name "returnType")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the body field of hydra.ext.cpp.syntax.LambdaExpression
lambdaExpressionWithBody :: Typed.TypedTerm Syntax.LambdaExpression -> Typed.TypedTerm Syntax.CompoundStatement -> Typed.TypedTerm Syntax.LambdaExpression
lambdaExpressionWithBody original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.LambdaExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "captures"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.LambdaExpression"),
              Model.projectionFieldName = (Model.Name "captures")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.LambdaExpression"),
              Model.projectionFieldName = (Model.Name "parameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "returnType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.LambdaExpression"),
              Model.projectionFieldName = (Model.Name "returnType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the captures field of hydra.ext.cpp.syntax.LambdaExpression
lambdaExpressionWithCaptures :: Typed.TypedTerm Syntax.LambdaExpression -> Typed.TypedTerm Syntax.CaptureList -> Typed.TypedTerm Syntax.LambdaExpression
lambdaExpressionWithCaptures original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.LambdaExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "captures"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.LambdaExpression"),
              Model.projectionFieldName = (Model.Name "parameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "returnType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.LambdaExpression"),
              Model.projectionFieldName = (Model.Name "returnType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.LambdaExpression"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the parameters field of hydra.ext.cpp.syntax.LambdaExpression
lambdaExpressionWithParameters :: Typed.TypedTerm Syntax.LambdaExpression -> Typed.TypedTerm [Syntax.Parameter] -> Typed.TypedTerm Syntax.LambdaExpression
lambdaExpressionWithParameters original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.LambdaExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "captures"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.LambdaExpression"),
              Model.projectionFieldName = (Model.Name "captures")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "returnType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.LambdaExpression"),
              Model.projectionFieldName = (Model.Name "returnType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.LambdaExpression"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the returnType field of hydra.ext.cpp.syntax.LambdaExpression
lambdaExpressionWithReturnType :: Typed.TypedTerm Syntax.LambdaExpression -> Typed.TypedTerm (Maybe Syntax.TypeExpression) -> Typed.TypedTerm Syntax.LambdaExpression
lambdaExpressionWithReturnType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.LambdaExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "captures"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.LambdaExpression"),
              Model.projectionFieldName = (Model.Name "captures")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.LambdaExpression"),
              Model.projectionFieldName = (Model.Name "parameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "returnType"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.LambdaExpression"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.cpp.syntax.LeftShiftOperation
leftShiftOperation :: Typed.TypedTerm Syntax.ShiftExpression -> Typed.TypedTerm Syntax.AdditiveExpression -> Typed.TypedTerm Syntax.LeftShiftOperation
leftShiftOperation left right =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.LeftShiftOperation"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Typed.unTypedTerm left)},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Typed.unTypedTerm right)}]}))

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

-- | DSL name token for hydra.ext.cpp.syntax.LeftShiftOperation
leftShiftOperationLeftShiftOperation :: Typed.TypedName Syntax.LeftShiftOperation
leftShiftOperationLeftShiftOperation = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.LeftShiftOperation")

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

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

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

-- | DSL constructor for hydra.ext.cpp.syntax.LessEqualOperation
lessEqualOperation :: Typed.TypedTerm Syntax.RelationalExpression -> Typed.TypedTerm Syntax.ShiftExpression -> Typed.TypedTerm Syntax.LessEqualOperation
lessEqualOperation left right =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.LessEqualOperation"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Typed.unTypedTerm left)},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Typed.unTypedTerm right)}]}))

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

-- | DSL name token for hydra.ext.cpp.syntax.LessEqualOperation
lessEqualOperationLessEqualOperation :: Typed.TypedName Syntax.LessEqualOperation
lessEqualOperationLessEqualOperation = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.LessEqualOperation")

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

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

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

-- | DSL constructor for hydra.ext.cpp.syntax.LessOperation
lessOperation :: Typed.TypedTerm Syntax.RelationalExpression -> Typed.TypedTerm Syntax.ShiftExpression -> Typed.TypedTerm Syntax.LessOperation
lessOperation left right =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.LessOperation"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Typed.unTypedTerm left)},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Typed.unTypedTerm right)}]}))

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

-- | DSL name token for hydra.ext.cpp.syntax.LessOperation
lessOperationLessOperation :: Typed.TypedName Syntax.LessOperation
lessOperationLessOperation = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.LessOperation")

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

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

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

-- | DSL constructor for hydra.ext.cpp.syntax.LineDirective
lineDirective :: Typed.TypedTerm Int -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Syntax.LineDirective
lineDirective lineNumber filename =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.LineDirective"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "lineNumber"),
          Model.fieldTerm = (Typed.unTypedTerm lineNumber)},
        Model.Field {
          Model.fieldName = (Model.Name "filename"),
          Model.fieldTerm = (Typed.unTypedTerm filename)}]}))

-- | DSL accessor for the filename field of hydra.ext.cpp.syntax.LineDirective
lineDirectiveFilename :: Typed.TypedTerm Syntax.LineDirective -> Typed.TypedTerm (Maybe String)
lineDirectiveFilename x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.LineDirective"),
        Model.projectionFieldName = (Model.Name "filename")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.cpp.syntax.LineDirective
lineDirectiveLineDirective :: Typed.TypedName Syntax.LineDirective
lineDirectiveLineDirective = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.LineDirective")

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

-- | DSL updater for the filename field of hydra.ext.cpp.syntax.LineDirective
lineDirectiveWithFilename :: Typed.TypedTerm Syntax.LineDirective -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Syntax.LineDirective
lineDirectiveWithFilename original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.LineDirective"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "lineNumber"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.LineDirective"),
              Model.projectionFieldName = (Model.Name "lineNumber")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "filename"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

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

-- | DSL constructor for hydra.ext.cpp.syntax.ListDeclaration
listDeclaration :: Typed.TypedTerm Syntax.TypeExpression -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.ListDeclaration
listDeclaration elementType name =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.ListDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "elementType"),
          Model.fieldTerm = (Typed.unTypedTerm elementType)},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)}]}))

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

-- | DSL name token for hydra.ext.cpp.syntax.ListDeclaration
listDeclarationListDeclaration :: Typed.TypedName Syntax.ListDeclaration
listDeclarationListDeclaration = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.ListDeclaration")

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

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

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

-- | DSL injection for the boolean variant of hydra.ext.cpp.syntax.Literal
literalBoolean :: Typed.TypedTerm Syntax.BooleanLiteral -> Typed.TypedTerm Syntax.Literal
literalBoolean x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Literal"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "boolean"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the character variant of hydra.ext.cpp.syntax.Literal
literalCharacter :: Typed.TypedTerm Syntax.CharacterLiteral -> Typed.TypedTerm Syntax.Literal
literalCharacter x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Literal"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "character"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the floating variant of hydra.ext.cpp.syntax.Literal
literalFloating :: Typed.TypedTerm Syntax.FloatingLiteral -> Typed.TypedTerm Syntax.Literal
literalFloating x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Literal"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "floating"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the integer variant of hydra.ext.cpp.syntax.Literal
literalInteger :: Typed.TypedTerm Syntax.IntegerLiteral -> Typed.TypedTerm Syntax.Literal
literalInteger x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Literal"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "integer"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.cpp.syntax.Literal
literalLiteral :: Typed.TypedName Syntax.Literal
literalLiteral = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.Literal")

-- | DSL injection for the null variant of hydra.ext.cpp.syntax.Literal
literalNull :: Typed.TypedTerm Syntax.Literal
literalNull =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Literal"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "null"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the string variant of hydra.ext.cpp.syntax.Literal
literalString :: Typed.TypedTerm Syntax.StringLiteral -> Typed.TypedTerm Syntax.Literal
literalString x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Literal"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "string"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the inclusiveOr variant of hydra.ext.cpp.syntax.LogicalAndExpression
logicalAndExpressionInclusiveOr :: Typed.TypedTerm Syntax.InclusiveOrExpression -> Typed.TypedTerm Syntax.LogicalAndExpression
logicalAndExpressionInclusiveOr x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.LogicalAndExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "inclusiveOr"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the logicalAnd variant of hydra.ext.cpp.syntax.LogicalAndExpression
logicalAndExpressionLogicalAnd :: Typed.TypedTerm Syntax.LogicalAndOperation -> Typed.TypedTerm Syntax.LogicalAndExpression
logicalAndExpressionLogicalAnd x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.LogicalAndExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "logicalAnd"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.cpp.syntax.LogicalAndExpression
logicalAndExpressionLogicalAndExpression :: Typed.TypedName Syntax.LogicalAndExpression
logicalAndExpressionLogicalAndExpression = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.LogicalAndExpression")

-- | DSL constructor for hydra.ext.cpp.syntax.LogicalAndOperation
logicalAndOperation :: Typed.TypedTerm Syntax.LogicalAndExpression -> Typed.TypedTerm Syntax.InclusiveOrExpression -> Typed.TypedTerm Syntax.LogicalAndOperation
logicalAndOperation left right =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.LogicalAndOperation"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Typed.unTypedTerm left)},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Typed.unTypedTerm right)}]}))

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

-- | DSL name token for hydra.ext.cpp.syntax.LogicalAndOperation
logicalAndOperationLogicalAndOperation :: Typed.TypedName Syntax.LogicalAndOperation
logicalAndOperationLogicalAndOperation = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.LogicalAndOperation")

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

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

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

-- | DSL injection for the logicalAnd variant of hydra.ext.cpp.syntax.LogicalOrExpression
logicalOrExpressionLogicalAnd :: Typed.TypedTerm Syntax.LogicalAndExpression -> Typed.TypedTerm Syntax.LogicalOrExpression
logicalOrExpressionLogicalAnd x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.LogicalOrExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "logicalAnd"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the logicalOr variant of hydra.ext.cpp.syntax.LogicalOrExpression
logicalOrExpressionLogicalOr :: Typed.TypedTerm Syntax.LogicalOrOperation -> Typed.TypedTerm Syntax.LogicalOrExpression
logicalOrExpressionLogicalOr x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.LogicalOrExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "logicalOr"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.cpp.syntax.LogicalOrExpression
logicalOrExpressionLogicalOrExpression :: Typed.TypedName Syntax.LogicalOrExpression
logicalOrExpressionLogicalOrExpression = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.LogicalOrExpression")

-- | DSL constructor for hydra.ext.cpp.syntax.LogicalOrOperation
logicalOrOperation :: Typed.TypedTerm Syntax.LogicalOrExpression -> Typed.TypedTerm Syntax.LogicalAndExpression -> Typed.TypedTerm Syntax.LogicalOrOperation
logicalOrOperation left right =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.LogicalOrOperation"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Typed.unTypedTerm left)},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Typed.unTypedTerm right)}]}))

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

-- | DSL name token for hydra.ext.cpp.syntax.LogicalOrOperation
logicalOrOperationLogicalOrOperation :: Typed.TypedName Syntax.LogicalOrOperation
logicalOrOperationLogicalOrOperation = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.LogicalOrOperation")

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

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

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

-- | DSL constructor for hydra.ext.cpp.syntax.Map
map :: Typed.TypedTerm Syntax.TypeExpression -> Typed.TypedTerm Syntax.TypeExpression -> Typed.TypedTerm [Syntax.MapEntry] -> Typed.TypedTerm Syntax.Map
map keyType valueType entries =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.Map"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "keyType"),
          Model.fieldTerm = (Typed.unTypedTerm keyType)},
        Model.Field {
          Model.fieldName = (Model.Name "valueType"),
          Model.fieldTerm = (Typed.unTypedTerm valueType)},
        Model.Field {
          Model.fieldName = (Model.Name "entries"),
          Model.fieldTerm = (Typed.unTypedTerm entries)}]}))

-- | DSL constructor for hydra.ext.cpp.syntax.MapDeclaration
mapDeclaration :: Typed.TypedTerm Syntax.TypeExpression -> Typed.TypedTerm Syntax.TypeExpression -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.MapDeclaration
mapDeclaration keyType valueType name =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.MapDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "keyType"),
          Model.fieldTerm = (Typed.unTypedTerm keyType)},
        Model.Field {
          Model.fieldName = (Model.Name "valueType"),
          Model.fieldTerm = (Typed.unTypedTerm valueType)},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)}]}))

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

-- | DSL name token for hydra.ext.cpp.syntax.MapDeclaration
mapDeclarationMapDeclaration :: Typed.TypedName Syntax.MapDeclaration
mapDeclarationMapDeclaration = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.MapDeclaration")

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

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

-- | DSL updater for the keyType field of hydra.ext.cpp.syntax.MapDeclaration
mapDeclarationWithKeyType :: Typed.TypedTerm Syntax.MapDeclaration -> Typed.TypedTerm Syntax.TypeExpression -> Typed.TypedTerm Syntax.MapDeclaration
mapDeclarationWithKeyType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.MapDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "keyType"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "valueType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.MapDeclaration"),
              Model.projectionFieldName = (Model.Name "valueType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.MapDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the name field of hydra.ext.cpp.syntax.MapDeclaration
mapDeclarationWithName :: Typed.TypedTerm Syntax.MapDeclaration -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.MapDeclaration
mapDeclarationWithName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.MapDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "keyType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.MapDeclaration"),
              Model.projectionFieldName = (Model.Name "keyType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "valueType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.MapDeclaration"),
              Model.projectionFieldName = (Model.Name "valueType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the valueType field of hydra.ext.cpp.syntax.MapDeclaration
mapDeclarationWithValueType :: Typed.TypedTerm Syntax.MapDeclaration -> Typed.TypedTerm Syntax.TypeExpression -> Typed.TypedTerm Syntax.MapDeclaration
mapDeclarationWithValueType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.MapDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "keyType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.MapDeclaration"),
              Model.projectionFieldName = (Model.Name "keyType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "valueType"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.MapDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL accessor for the entries field of hydra.ext.cpp.syntax.Map
mapEntries :: Typed.TypedTerm Syntax.Map -> Typed.TypedTerm [Syntax.MapEntry]
mapEntries x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Map"),
        Model.projectionFieldName = (Model.Name "entries")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL constructor for hydra.ext.cpp.syntax.MapEntry
mapEntry :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.MapEntry
mapEntry key value =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.MapEntry"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "key"),
          Model.fieldTerm = (Typed.unTypedTerm key)},
        Model.Field {
          Model.fieldName = (Model.Name "value"),
          Model.fieldTerm = (Typed.unTypedTerm value)}]}))

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

-- | DSL name token for hydra.ext.cpp.syntax.MapEntry
mapEntryMapEntry :: Typed.TypedName Syntax.MapEntry
mapEntryMapEntry = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.MapEntry")

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

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

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

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

-- | DSL name token for hydra.ext.cpp.syntax.Map
mapMap :: Typed.TypedName Syntax.Map
mapMap = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.Map")

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

-- | DSL updater for the entries field of hydra.ext.cpp.syntax.Map
mapWithEntries :: Typed.TypedTerm Syntax.Map -> Typed.TypedTerm [Syntax.MapEntry] -> Typed.TypedTerm Syntax.Map
mapWithEntries original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.Map"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "keyType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Map"),
              Model.projectionFieldName = (Model.Name "keyType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "valueType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Map"),
              Model.projectionFieldName = (Model.Name "valueType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "entries"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the keyType field of hydra.ext.cpp.syntax.Map
mapWithKeyType :: Typed.TypedTerm Syntax.Map -> Typed.TypedTerm Syntax.TypeExpression -> Typed.TypedTerm Syntax.Map
mapWithKeyType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.Map"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "keyType"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "valueType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Map"),
              Model.projectionFieldName = (Model.Name "valueType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "entries"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Map"),
              Model.projectionFieldName = (Model.Name "entries")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the valueType field of hydra.ext.cpp.syntax.Map
mapWithValueType :: Typed.TypedTerm Syntax.Map -> Typed.TypedTerm Syntax.TypeExpression -> Typed.TypedTerm Syntax.Map
mapWithValueType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.Map"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "keyType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Map"),
              Model.projectionFieldName = (Model.Name "keyType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "valueType"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "entries"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Map"),
              Model.projectionFieldName = (Model.Name "entries")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.cpp.syntax.MemInitializer
memInitializer :: Typed.TypedTerm String -> Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.MemInitializer
memInitializer name arguments =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.MemInitializer"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)},
        Model.Field {
          Model.fieldName = (Model.Name "arguments"),
          Model.fieldTerm = (Typed.unTypedTerm arguments)}]}))

-- | DSL accessor for the arguments field of hydra.ext.cpp.syntax.MemInitializer
memInitializerArguments :: Typed.TypedTerm Syntax.MemInitializer -> Typed.TypedTerm [Syntax.Expression]
memInitializerArguments x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.MemInitializer"),
        Model.projectionFieldName = (Model.Name "arguments")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.cpp.syntax.MemInitializer
memInitializerMemInitializer :: Typed.TypedName Syntax.MemInitializer
memInitializerMemInitializer = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.MemInitializer")

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

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

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

-- | DSL constructor for hydra.ext.cpp.syntax.MemberAccessOperation
memberAccessOperation :: Typed.TypedTerm Syntax.PostfixExpression -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.MemberAccessOperation
memberAccessOperation object member =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.MemberAccessOperation"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "object"),
          Model.fieldTerm = (Typed.unTypedTerm object)},
        Model.Field {
          Model.fieldName = (Model.Name "member"),
          Model.fieldTerm = (Typed.unTypedTerm member)}]}))

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

-- | DSL name token for hydra.ext.cpp.syntax.MemberAccessOperation
memberAccessOperationMemberAccessOperation :: Typed.TypedName Syntax.MemberAccessOperation
memberAccessOperationMemberAccessOperation = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.MemberAccessOperation")

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

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

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

-- | DSL injection for the constructor variant of hydra.ext.cpp.syntax.MemberDeclaration
memberDeclarationConstructor :: Typed.TypedTerm Syntax.ConstructorDeclaration -> Typed.TypedTerm Syntax.MemberDeclaration
memberDeclarationConstructor x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.MemberDeclaration"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "constructor"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the destructor variant of hydra.ext.cpp.syntax.MemberDeclaration
memberDeclarationDestructor :: Typed.TypedTerm Syntax.DestructorDeclaration -> Typed.TypedTerm Syntax.MemberDeclaration
memberDeclarationDestructor x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.MemberDeclaration"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "destructor"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the function variant of hydra.ext.cpp.syntax.MemberDeclaration
memberDeclarationFunction :: Typed.TypedTerm Syntax.FunctionDeclaration -> Typed.TypedTerm Syntax.MemberDeclaration
memberDeclarationFunction x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.MemberDeclaration"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "function"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.cpp.syntax.MemberDeclaration
memberDeclarationMemberDeclaration :: Typed.TypedName Syntax.MemberDeclaration
memberDeclarationMemberDeclaration = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.MemberDeclaration")

-- | DSL injection for the nestedClass variant of hydra.ext.cpp.syntax.MemberDeclaration
memberDeclarationNestedClass :: Typed.TypedTerm Syntax.ClassDeclaration -> Typed.TypedTerm Syntax.MemberDeclaration
memberDeclarationNestedClass x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.MemberDeclaration"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "nestedClass"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the template variant of hydra.ext.cpp.syntax.MemberDeclaration
memberDeclarationTemplate :: Typed.TypedTerm Syntax.TemplateDeclaration -> Typed.TypedTerm Syntax.MemberDeclaration
memberDeclarationTemplate x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.MemberDeclaration"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "template"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the variable variant of hydra.ext.cpp.syntax.MemberDeclaration
memberDeclarationVariable :: Typed.TypedTerm Syntax.VariableDeclaration -> Typed.TypedTerm Syntax.MemberDeclaration
memberDeclarationVariable x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.MemberDeclaration"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "variable"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the accessLabel variant of hydra.ext.cpp.syntax.MemberSpecification
memberSpecificationAccessLabel :: Typed.TypedTerm Syntax.AccessSpecifier -> Typed.TypedTerm Syntax.MemberSpecification
memberSpecificationAccessLabel x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.MemberSpecification"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "accessLabel"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the member variant of hydra.ext.cpp.syntax.MemberSpecification
memberSpecificationMember :: Typed.TypedTerm Syntax.MemberDeclaration -> Typed.TypedTerm Syntax.MemberSpecification
memberSpecificationMember x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.MemberSpecification"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "member"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.cpp.syntax.MemberSpecification
memberSpecificationMemberSpecification :: Typed.TypedName Syntax.MemberSpecification
memberSpecificationMemberSpecification = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.MemberSpecification")

-- | DSL constructor for hydra.ext.cpp.syntax.ModuloOperation
moduloOperation :: Typed.TypedTerm Syntax.MultiplicativeExpression -> Typed.TypedTerm Syntax.UnaryExpression -> Typed.TypedTerm Syntax.ModuloOperation
moduloOperation left right =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.ModuloOperation"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Typed.unTypedTerm left)},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Typed.unTypedTerm right)}]}))

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

-- | DSL name token for hydra.ext.cpp.syntax.ModuloOperation
moduloOperationModuloOperation :: Typed.TypedName Syntax.ModuloOperation
moduloOperationModuloOperation = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.ModuloOperation")

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

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

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

-- | DSL injection for the divide variant of hydra.ext.cpp.syntax.MultiplicativeExpression
multiplicativeExpressionDivide :: Typed.TypedTerm Syntax.DivideOperation -> Typed.TypedTerm Syntax.MultiplicativeExpression
multiplicativeExpressionDivide x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.MultiplicativeExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "divide"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the modulo variant of hydra.ext.cpp.syntax.MultiplicativeExpression
multiplicativeExpressionModulo :: Typed.TypedTerm Syntax.ModuloOperation -> Typed.TypedTerm Syntax.MultiplicativeExpression
multiplicativeExpressionModulo x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.MultiplicativeExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "modulo"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.cpp.syntax.MultiplicativeExpression
multiplicativeExpressionMultiplicativeExpression :: Typed.TypedName Syntax.MultiplicativeExpression
multiplicativeExpressionMultiplicativeExpression =
    Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.MultiplicativeExpression")

-- | DSL injection for the multiply variant of hydra.ext.cpp.syntax.MultiplicativeExpression
multiplicativeExpressionMultiply :: Typed.TypedTerm Syntax.MultiplyOperation -> Typed.TypedTerm Syntax.MultiplicativeExpression
multiplicativeExpressionMultiply x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.MultiplicativeExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "multiply"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the unary variant of hydra.ext.cpp.syntax.MultiplicativeExpression
multiplicativeExpressionUnary :: Typed.TypedTerm Syntax.UnaryExpression -> Typed.TypedTerm Syntax.MultiplicativeExpression
multiplicativeExpressionUnary x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.MultiplicativeExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "unary"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for hydra.ext.cpp.syntax.MultiplyOperation
multiplyOperation :: Typed.TypedTerm Syntax.MultiplicativeExpression -> Typed.TypedTerm Syntax.UnaryExpression -> Typed.TypedTerm Syntax.MultiplyOperation
multiplyOperation left right =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.MultiplyOperation"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Typed.unTypedTerm left)},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Typed.unTypedTerm right)}]}))

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

-- | DSL name token for hydra.ext.cpp.syntax.MultiplyOperation
multiplyOperationMultiplyOperation :: Typed.TypedName Syntax.MultiplyOperation
multiplyOperationMultiplyOperation = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.MultiplyOperation")

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

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

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

-- | DSL constructor for hydra.ext.cpp.syntax.NamespaceDeclaration
namespaceDeclaration :: Typed.TypedTerm String -> Typed.TypedTerm [Syntax.Declaration] -> Typed.TypedTerm Syntax.NamespaceDeclaration
namespaceDeclaration name declarations =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.NamespaceDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)},
        Model.Field {
          Model.fieldName = (Model.Name "declarations"),
          Model.fieldTerm = (Typed.unTypedTerm declarations)}]}))

-- | DSL accessor for the declarations field of hydra.ext.cpp.syntax.NamespaceDeclaration
namespaceDeclarationDeclarations :: Typed.TypedTerm Syntax.NamespaceDeclaration -> Typed.TypedTerm [Syntax.Declaration]
namespaceDeclarationDeclarations x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.NamespaceDeclaration"),
        Model.projectionFieldName = (Model.Name "declarations")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

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

-- | DSL name token for hydra.ext.cpp.syntax.NamespaceDeclaration
namespaceDeclarationNamespaceDeclaration :: Typed.TypedName Syntax.NamespaceDeclaration
namespaceDeclarationNamespaceDeclaration = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.NamespaceDeclaration")

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

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

-- | DSL constructor for hydra.ext.cpp.syntax.NotEqualOperation
notEqualOperation :: Typed.TypedTerm Syntax.EqualityExpression -> Typed.TypedTerm Syntax.RelationalExpression -> Typed.TypedTerm Syntax.NotEqualOperation
notEqualOperation left right =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.NotEqualOperation"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Typed.unTypedTerm left)},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Typed.unTypedTerm right)}]}))

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

-- | DSL name token for hydra.ext.cpp.syntax.NotEqualOperation
notEqualOperationNotEqualOperation :: Typed.TypedName Syntax.NotEqualOperation
notEqualOperationNotEqualOperation = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.NotEqualOperation")

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

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

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

-- | DSL constructor for hydra.ext.cpp.syntax.Optional
optional :: Typed.TypedTerm Syntax.TypeExpression -> Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm Syntax.Optional
optional valueType value =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.Optional"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "valueType"),
          Model.fieldTerm = (Typed.unTypedTerm valueType)},
        Model.Field {
          Model.fieldName = (Model.Name "value"),
          Model.fieldTerm = (Typed.unTypedTerm value)}]}))

-- | DSL constructor for hydra.ext.cpp.syntax.OptionalDeclaration
optionalDeclaration :: Typed.TypedTerm Syntax.TypeExpression -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.OptionalDeclaration
optionalDeclaration valueType name =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.OptionalDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "valueType"),
          Model.fieldTerm = (Typed.unTypedTerm valueType)},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)}]}))

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

-- | DSL name token for hydra.ext.cpp.syntax.OptionalDeclaration
optionalDeclarationOptionalDeclaration :: Typed.TypedName Syntax.OptionalDeclaration
optionalDeclarationOptionalDeclaration = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.OptionalDeclaration")

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

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

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

-- | DSL name token for hydra.ext.cpp.syntax.Optional
optionalOptional :: Typed.TypedName Syntax.Optional
optionalOptional = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.Optional")

-- | DSL accessor for the value field of hydra.ext.cpp.syntax.Optional
optionalValue :: Typed.TypedTerm Syntax.Optional -> Typed.TypedTerm (Maybe Syntax.Expression)
optionalValue x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Optional"),
        Model.projectionFieldName = (Model.Name "value")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

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

-- | DSL updater for the value field of hydra.ext.cpp.syntax.Optional
optionalWithValue :: Typed.TypedTerm Syntax.Optional -> Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm Syntax.Optional
optionalWithValue original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.Optional"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "valueType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Optional"),
              Model.projectionFieldName = (Model.Name "valueType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "value"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

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

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

-- | DSL name token for hydra.ext.cpp.syntax.OverloadedLambdas
overloadedLambdasOverloadedLambdas :: Typed.TypedName Syntax.OverloadedLambdas
overloadedLambdasOverloadedLambdas = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.OverloadedLambdas")

-- | DSL constructor for hydra.ext.cpp.syntax.Parameter
parameter :: Typed.TypedTerm Syntax.TypeExpression -> Typed.TypedTerm String -> Typed.TypedTerm Bool -> Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm Syntax.Parameter
parameter type_ name unnamed defaultValue =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.Parameter"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm type_)},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)},
        Model.Field {
          Model.fieldName = (Model.Name "unnamed"),
          Model.fieldTerm = (Typed.unTypedTerm unnamed)},
        Model.Field {
          Model.fieldName = (Model.Name "defaultValue"),
          Model.fieldTerm = (Typed.unTypedTerm defaultValue)}]}))

-- | DSL accessor for the defaultValue field of hydra.ext.cpp.syntax.Parameter
parameterDefaultValue :: Typed.TypedTerm Syntax.Parameter -> Typed.TypedTerm (Maybe Syntax.Expression)
parameterDefaultValue x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Parameter"),
        Model.projectionFieldName = (Model.Name "defaultValue")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

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

-- | DSL name token for hydra.ext.cpp.syntax.Parameter
parameterParameter :: Typed.TypedName Syntax.Parameter
parameterParameter = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.Parameter")

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

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

-- | DSL updater for the defaultValue field of hydra.ext.cpp.syntax.Parameter
parameterWithDefaultValue :: Typed.TypedTerm Syntax.Parameter -> Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm Syntax.Parameter
parameterWithDefaultValue original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.Parameter"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Parameter"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Parameter"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "unnamed"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Parameter"),
              Model.projectionFieldName = (Model.Name "unnamed")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "defaultValue"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the name field of hydra.ext.cpp.syntax.Parameter
parameterWithName :: Typed.TypedTerm Syntax.Parameter -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.Parameter
parameterWithName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.Parameter"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Parameter"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "unnamed"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Parameter"),
              Model.projectionFieldName = (Model.Name "unnamed")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "defaultValue"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Parameter"),
              Model.projectionFieldName = (Model.Name "defaultValue")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the type field of hydra.ext.cpp.syntax.Parameter
parameterWithType :: Typed.TypedTerm Syntax.Parameter -> Typed.TypedTerm Syntax.TypeExpression -> Typed.TypedTerm Syntax.Parameter
parameterWithType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.Parameter"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Parameter"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "unnamed"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Parameter"),
              Model.projectionFieldName = (Model.Name "unnamed")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "defaultValue"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Parameter"),
              Model.projectionFieldName = (Model.Name "defaultValue")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the unnamed field of hydra.ext.cpp.syntax.Parameter
parameterWithUnnamed :: Typed.TypedTerm Syntax.Parameter -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.Parameter
parameterWithUnnamed original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.Parameter"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Parameter"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Parameter"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "unnamed"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "defaultValue"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Parameter"),
              Model.projectionFieldName = (Model.Name "defaultValue")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.cpp.syntax.PatternMatch
patternMatch :: Typed.TypedTerm Syntax.Visitor -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.PatternMatch
patternMatch visitor variant =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.PatternMatch"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "visitor"),
          Model.fieldTerm = (Typed.unTypedTerm visitor)},
        Model.Field {
          Model.fieldName = (Model.Name "variant"),
          Model.fieldTerm = (Typed.unTypedTerm variant)}]}))

-- | DSL name token for hydra.ext.cpp.syntax.PatternMatch
patternMatchPatternMatch :: Typed.TypedName Syntax.PatternMatch
patternMatchPatternMatch = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.PatternMatch")

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

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

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

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

-- | DSL constructor for hydra.ext.cpp.syntax.PointerMemberAccessOperation
pointerMemberAccessOperation :: Typed.TypedTerm Syntax.PostfixExpression -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.PointerMemberAccessOperation
pointerMemberAccessOperation pointer member =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.PointerMemberAccessOperation"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "pointer"),
          Model.fieldTerm = (Typed.unTypedTerm pointer)},
        Model.Field {
          Model.fieldName = (Model.Name "member"),
          Model.fieldTerm = (Typed.unTypedTerm member)}]}))

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

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

-- | DSL name token for hydra.ext.cpp.syntax.PointerMemberAccessOperation
pointerMemberAccessOperationPointerMemberAccessOperation :: Typed.TypedName Syntax.PointerMemberAccessOperation
pointerMemberAccessOperationPointerMemberAccessOperation =
    Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.PointerMemberAccessOperation")

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

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

-- | DSL injection for the functionCall variant of hydra.ext.cpp.syntax.PostfixExpression
postfixExpressionFunctionCall :: Typed.TypedTerm Syntax.FunctionCallOperation -> Typed.TypedTerm Syntax.PostfixExpression
postfixExpressionFunctionCall x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.PostfixExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "functionCall"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the memberAccess variant of hydra.ext.cpp.syntax.PostfixExpression
postfixExpressionMemberAccess :: Typed.TypedTerm Syntax.MemberAccessOperation -> Typed.TypedTerm Syntax.PostfixExpression
postfixExpressionMemberAccess x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.PostfixExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "memberAccess"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the pointerMemberAccess variant of hydra.ext.cpp.syntax.PostfixExpression
postfixExpressionPointerMemberAccess :: Typed.TypedTerm Syntax.PointerMemberAccessOperation -> Typed.TypedTerm Syntax.PostfixExpression
postfixExpressionPointerMemberAccess x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.PostfixExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "pointerMemberAccess"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

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

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

-- | DSL name token for hydra.ext.cpp.syntax.PostfixExpression
postfixExpressionPostfixExpression :: Typed.TypedName Syntax.PostfixExpression
postfixExpressionPostfixExpression = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.PostfixExpression")

-- | DSL injection for the primary variant of hydra.ext.cpp.syntax.PostfixExpression
postfixExpressionPrimary :: Typed.TypedTerm Syntax.PrimaryExpression -> Typed.TypedTerm Syntax.PostfixExpression
postfixExpressionPrimary x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.PostfixExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "primary"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the subscript variant of hydra.ext.cpp.syntax.PostfixExpression
postfixExpressionSubscript :: Typed.TypedTerm Syntax.SubscriptOperation -> Typed.TypedTerm Syntax.PostfixExpression
postfixExpressionSubscript x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.PostfixExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "subscript"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the templateFunctionCall variant of hydra.ext.cpp.syntax.PostfixExpression
postfixExpressionTemplateFunctionCall :: Typed.TypedTerm Syntax.TemplateFunctionCallOperation -> Typed.TypedTerm Syntax.PostfixExpression
postfixExpressionTemplateFunctionCall x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.PostfixExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "templateFunctionCall"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for hydra.ext.cpp.syntax.PragmaDirective
pragmaDirective :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.PragmaDirective
pragmaDirective content =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.PragmaDirective"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "content"),
          Model.fieldTerm = (Typed.unTypedTerm content)}]}))

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

-- | DSL name token for hydra.ext.cpp.syntax.PragmaDirective
pragmaDirectivePragmaDirective :: Typed.TypedName Syntax.PragmaDirective
pragmaDirectivePragmaDirective = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.PragmaDirective")

-- | DSL updater for the content field of hydra.ext.cpp.syntax.PragmaDirective
pragmaDirectiveWithContent :: Typed.TypedTerm Syntax.PragmaDirective -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.PragmaDirective
pragmaDirectiveWithContent original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.PragmaDirective"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "content"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL injection for the define variant of hydra.ext.cpp.syntax.PreprocessorDirective
preprocessorDirectiveDefine :: Typed.TypedTerm Syntax.DefineDirective -> Typed.TypedTerm Syntax.PreprocessorDirective
preprocessorDirectiveDefine x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.PreprocessorDirective"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "define"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the elif variant of hydra.ext.cpp.syntax.PreprocessorDirective
preprocessorDirectiveElif :: Typed.TypedTerm Syntax.ElifDirective -> Typed.TypedTerm Syntax.PreprocessorDirective
preprocessorDirectiveElif x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.PreprocessorDirective"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "elif"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the else variant of hydra.ext.cpp.syntax.PreprocessorDirective
preprocessorDirectiveElse :: Typed.TypedTerm Syntax.ElseDirective -> Typed.TypedTerm Syntax.PreprocessorDirective
preprocessorDirectiveElse x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.PreprocessorDirective"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "else"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the endif variant of hydra.ext.cpp.syntax.PreprocessorDirective
preprocessorDirectiveEndif :: Typed.TypedTerm Syntax.EndifDirective -> Typed.TypedTerm Syntax.PreprocessorDirective
preprocessorDirectiveEndif x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.PreprocessorDirective"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "endif"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the error variant of hydra.ext.cpp.syntax.PreprocessorDirective
preprocessorDirectiveError :: Typed.TypedTerm Syntax.ErrorDirective -> Typed.TypedTerm Syntax.PreprocessorDirective
preprocessorDirectiveError x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.PreprocessorDirective"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "error"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the if variant of hydra.ext.cpp.syntax.PreprocessorDirective
preprocessorDirectiveIf :: Typed.TypedTerm Syntax.IfDirective -> Typed.TypedTerm Syntax.PreprocessorDirective
preprocessorDirectiveIf x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.PreprocessorDirective"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "if"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the ifdef variant of hydra.ext.cpp.syntax.PreprocessorDirective
preprocessorDirectiveIfdef :: Typed.TypedTerm Syntax.IfdefDirective -> Typed.TypedTerm Syntax.PreprocessorDirective
preprocessorDirectiveIfdef x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.PreprocessorDirective"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "ifdef"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the ifndef variant of hydra.ext.cpp.syntax.PreprocessorDirective
preprocessorDirectiveIfndef :: Typed.TypedTerm Syntax.IfndefDirective -> Typed.TypedTerm Syntax.PreprocessorDirective
preprocessorDirectiveIfndef x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.PreprocessorDirective"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "ifndef"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the include variant of hydra.ext.cpp.syntax.PreprocessorDirective
preprocessorDirectiveInclude :: Typed.TypedTerm Syntax.IncludeDirective -> Typed.TypedTerm Syntax.PreprocessorDirective
preprocessorDirectiveInclude x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.PreprocessorDirective"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "include"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the line variant of hydra.ext.cpp.syntax.PreprocessorDirective
preprocessorDirectiveLine :: Typed.TypedTerm Syntax.LineDirective -> Typed.TypedTerm Syntax.PreprocessorDirective
preprocessorDirectiveLine x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.PreprocessorDirective"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "line"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the pragma variant of hydra.ext.cpp.syntax.PreprocessorDirective
preprocessorDirectivePragma :: Typed.TypedTerm Syntax.PragmaDirective -> Typed.TypedTerm Syntax.PreprocessorDirective
preprocessorDirectivePragma x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.PreprocessorDirective"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "pragma"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.cpp.syntax.PreprocessorDirective
preprocessorDirectivePreprocessorDirective :: Typed.TypedName Syntax.PreprocessorDirective
preprocessorDirectivePreprocessorDirective = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.PreprocessorDirective")

-- | DSL injection for the undef variant of hydra.ext.cpp.syntax.PreprocessorDirective
preprocessorDirectiveUndef :: Typed.TypedTerm Syntax.UndefDirective -> Typed.TypedTerm Syntax.PreprocessorDirective
preprocessorDirectiveUndef x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.PreprocessorDirective"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "undef"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the warning variant of hydra.ext.cpp.syntax.PreprocessorDirective
preprocessorDirectiveWarning :: Typed.TypedTerm Syntax.WarningDirective -> Typed.TypedTerm Syntax.PreprocessorDirective
preprocessorDirectiveWarning x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.PreprocessorDirective"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "warning"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the identifier variant of hydra.ext.cpp.syntax.PrimaryExpression
primaryExpressionIdentifier :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.PrimaryExpression
primaryExpressionIdentifier x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.PrimaryExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "identifier"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the lambda variant of hydra.ext.cpp.syntax.PrimaryExpression
primaryExpressionLambda :: Typed.TypedTerm Syntax.LambdaExpression -> Typed.TypedTerm Syntax.PrimaryExpression
primaryExpressionLambda x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.PrimaryExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "lambda"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the literal variant of hydra.ext.cpp.syntax.PrimaryExpression
primaryExpressionLiteral :: Typed.TypedTerm Syntax.Literal -> Typed.TypedTerm Syntax.PrimaryExpression
primaryExpressionLiteral x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.PrimaryExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "literal"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the parenthesized variant of hydra.ext.cpp.syntax.PrimaryExpression
primaryExpressionParenthesized :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.PrimaryExpression
primaryExpressionParenthesized x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.PrimaryExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "parenthesized"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.cpp.syntax.PrimaryExpression
primaryExpressionPrimaryExpression :: Typed.TypedName Syntax.PrimaryExpression
primaryExpressionPrimaryExpression = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.PrimaryExpression")

-- | DSL constructor for hydra.ext.cpp.syntax.ProductDeclaration
productDeclaration :: Typed.TypedTerm String -> Typed.TypedTerm [Syntax.VariableDeclaration] -> Typed.TypedTerm Syntax.ProductDeclaration
productDeclaration name fields =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.ProductDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)},
        Model.Field {
          Model.fieldName = (Model.Name "fields"),
          Model.fieldTerm = (Typed.unTypedTerm fields)}]}))

-- | DSL accessor for the fields field of hydra.ext.cpp.syntax.ProductDeclaration
productDeclarationFields :: Typed.TypedTerm Syntax.ProductDeclaration -> Typed.TypedTerm [Syntax.VariableDeclaration]
productDeclarationFields x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ProductDeclaration"),
        Model.projectionFieldName = (Model.Name "fields")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

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

-- | DSL name token for hydra.ext.cpp.syntax.ProductDeclaration
productDeclarationProductDeclaration :: Typed.TypedName Syntax.ProductDeclaration
productDeclarationProductDeclaration = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.ProductDeclaration")

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

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

-- | DSL constructor for hydra.ext.cpp.syntax.Program
program :: Typed.TypedTerm [Syntax.PreprocessorDirective] -> Typed.TypedTerm [Syntax.IncludeDirective] -> Typed.TypedTerm [Syntax.Declaration] -> Typed.TypedTerm Syntax.Program
program preprocessorDirectives includes declarations =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.Program"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "preprocessorDirectives"),
          Model.fieldTerm = (Typed.unTypedTerm preprocessorDirectives)},
        Model.Field {
          Model.fieldName = (Model.Name "includes"),
          Model.fieldTerm = (Typed.unTypedTerm includes)},
        Model.Field {
          Model.fieldName = (Model.Name "declarations"),
          Model.fieldTerm = (Typed.unTypedTerm declarations)}]}))

-- | DSL accessor for the declarations field of hydra.ext.cpp.syntax.Program
programDeclarations :: Typed.TypedTerm Syntax.Program -> Typed.TypedTerm [Syntax.Declaration]
programDeclarations x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Program"),
        Model.projectionFieldName = (Model.Name "declarations")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the includes field of hydra.ext.cpp.syntax.Program
programIncludes :: Typed.TypedTerm Syntax.Program -> Typed.TypedTerm [Syntax.IncludeDirective]
programIncludes x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Program"),
        Model.projectionFieldName = (Model.Name "includes")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the preprocessorDirectives field of hydra.ext.cpp.syntax.Program
programPreprocessorDirectives :: Typed.TypedTerm Syntax.Program -> Typed.TypedTerm [Syntax.PreprocessorDirective]
programPreprocessorDirectives x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Program"),
        Model.projectionFieldName = (Model.Name "preprocessorDirectives")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

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

-- | DSL updater for the declarations field of hydra.ext.cpp.syntax.Program
programWithDeclarations :: Typed.TypedTerm Syntax.Program -> Typed.TypedTerm [Syntax.Declaration] -> Typed.TypedTerm Syntax.Program
programWithDeclarations original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.Program"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "preprocessorDirectives"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Program"),
              Model.projectionFieldName = (Model.Name "preprocessorDirectives")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "includes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Program"),
              Model.projectionFieldName = (Model.Name "includes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "declarations"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the includes field of hydra.ext.cpp.syntax.Program
programWithIncludes :: Typed.TypedTerm Syntax.Program -> Typed.TypedTerm [Syntax.IncludeDirective] -> Typed.TypedTerm Syntax.Program
programWithIncludes original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.Program"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "preprocessorDirectives"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Program"),
              Model.projectionFieldName = (Model.Name "preprocessorDirectives")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "includes"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "declarations"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Program"),
              Model.projectionFieldName = (Model.Name "declarations")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the preprocessorDirectives field of hydra.ext.cpp.syntax.Program
programWithPreprocessorDirectives :: Typed.TypedTerm Syntax.Program -> Typed.TypedTerm [Syntax.PreprocessorDirective] -> Typed.TypedTerm Syntax.Program
programWithPreprocessorDirectives original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.Program"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "preprocessorDirectives"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "includes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Program"),
              Model.projectionFieldName = (Model.Name "includes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "declarations"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Program"),
              Model.projectionFieldName = (Model.Name "declarations")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.cpp.syntax.QualifiedIdentifier
qualifiedIdentifier :: Typed.TypedTerm String -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.QualifiedIdentifier
qualifiedIdentifier namespace name =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.QualifiedIdentifier"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "namespace"),
          Model.fieldTerm = (Typed.unTypedTerm namespace)},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)}]}))

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

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

-- | DSL name token for hydra.ext.cpp.syntax.QualifiedIdentifier
qualifiedIdentifierQualifiedIdentifier :: Typed.TypedName Syntax.QualifiedIdentifier
qualifiedIdentifierQualifiedIdentifier = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.QualifiedIdentifier")

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

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

-- | DSL constructor for hydra.ext.cpp.syntax.QualifiedType
qualifiedType :: Typed.TypedTerm Syntax.TypeExpression -> Typed.TypedTerm Syntax.TypeQualifier -> Typed.TypedTerm Syntax.QualifiedType
qualifiedType baseType qualifier =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.QualifiedType"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "baseType"),
          Model.fieldTerm = (Typed.unTypedTerm baseType)},
        Model.Field {
          Model.fieldName = (Model.Name "qualifier"),
          Model.fieldTerm = (Typed.unTypedTerm qualifier)}]}))

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

-- | DSL name token for hydra.ext.cpp.syntax.QualifiedType
qualifiedTypeQualifiedType :: Typed.TypedName Syntax.QualifiedType
qualifiedTypeQualifiedType = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.QualifiedType")

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

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

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

-- | DSL constructor for hydra.ext.cpp.syntax.RangeForStatement
rangeForStatement :: Typed.TypedTerm Syntax.TypeExpression -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Statement -> Typed.TypedTerm Syntax.RangeForStatement
rangeForStatement type_ variable range body =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.RangeForStatement"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm type_)},
        Model.Field {
          Model.fieldName = (Model.Name "variable"),
          Model.fieldTerm = (Typed.unTypedTerm variable)},
        Model.Field {
          Model.fieldName = (Model.Name "range"),
          Model.fieldTerm = (Typed.unTypedTerm range)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm body)}]}))

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

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

-- | DSL name token for hydra.ext.cpp.syntax.RangeForStatement
rangeForStatementRangeForStatement :: Typed.TypedName Syntax.RangeForStatement
rangeForStatementRangeForStatement = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.RangeForStatement")

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

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

-- | DSL updater for the body field of hydra.ext.cpp.syntax.RangeForStatement
rangeForStatementWithBody :: Typed.TypedTerm Syntax.RangeForStatement -> Typed.TypedTerm Syntax.Statement -> Typed.TypedTerm Syntax.RangeForStatement
rangeForStatementWithBody original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.RangeForStatement"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.RangeForStatement"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "variable"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.RangeForStatement"),
              Model.projectionFieldName = (Model.Name "variable")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "range"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.RangeForStatement"),
              Model.projectionFieldName = (Model.Name "range")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the range field of hydra.ext.cpp.syntax.RangeForStatement
rangeForStatementWithRange :: Typed.TypedTerm Syntax.RangeForStatement -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.RangeForStatement
rangeForStatementWithRange original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.RangeForStatement"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.RangeForStatement"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "variable"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.RangeForStatement"),
              Model.projectionFieldName = (Model.Name "variable")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "range"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.RangeForStatement"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the type field of hydra.ext.cpp.syntax.RangeForStatement
rangeForStatementWithType :: Typed.TypedTerm Syntax.RangeForStatement -> Typed.TypedTerm Syntax.TypeExpression -> Typed.TypedTerm Syntax.RangeForStatement
rangeForStatementWithType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.RangeForStatement"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "variable"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.RangeForStatement"),
              Model.projectionFieldName = (Model.Name "variable")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "range"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.RangeForStatement"),
              Model.projectionFieldName = (Model.Name "range")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.RangeForStatement"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the variable field of hydra.ext.cpp.syntax.RangeForStatement
rangeForStatementWithVariable :: Typed.TypedTerm Syntax.RangeForStatement -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.RangeForStatement
rangeForStatementWithVariable original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.RangeForStatement"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.RangeForStatement"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "variable"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "range"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.RangeForStatement"),
              Model.projectionFieldName = (Model.Name "range")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.RangeForStatement"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL injection for the greater variant of hydra.ext.cpp.syntax.RelationalExpression
relationalExpressionGreater :: Typed.TypedTerm Syntax.GreaterOperation -> Typed.TypedTerm Syntax.RelationalExpression
relationalExpressionGreater x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.RelationalExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "greater"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the greaterEqual variant of hydra.ext.cpp.syntax.RelationalExpression
relationalExpressionGreaterEqual :: Typed.TypedTerm Syntax.GreaterEqualOperation -> Typed.TypedTerm Syntax.RelationalExpression
relationalExpressionGreaterEqual x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.RelationalExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "greaterEqual"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the less variant of hydra.ext.cpp.syntax.RelationalExpression
relationalExpressionLess :: Typed.TypedTerm Syntax.LessOperation -> Typed.TypedTerm Syntax.RelationalExpression
relationalExpressionLess x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.RelationalExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "less"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the lessEqual variant of hydra.ext.cpp.syntax.RelationalExpression
relationalExpressionLessEqual :: Typed.TypedTerm Syntax.LessEqualOperation -> Typed.TypedTerm Syntax.RelationalExpression
relationalExpressionLessEqual x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.RelationalExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "lessEqual"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.cpp.syntax.RelationalExpression
relationalExpressionRelationalExpression :: Typed.TypedName Syntax.RelationalExpression
relationalExpressionRelationalExpression = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.RelationalExpression")

-- | DSL injection for the shift variant of hydra.ext.cpp.syntax.RelationalExpression
relationalExpressionShift :: Typed.TypedTerm Syntax.ShiftExpression -> Typed.TypedTerm Syntax.RelationalExpression
relationalExpressionShift x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.RelationalExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "shift"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for hydra.ext.cpp.syntax.RightShiftOperation
rightShiftOperation :: Typed.TypedTerm Syntax.ShiftExpression -> Typed.TypedTerm Syntax.AdditiveExpression -> Typed.TypedTerm Syntax.RightShiftOperation
rightShiftOperation left right =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.RightShiftOperation"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Typed.unTypedTerm left)},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Typed.unTypedTerm right)}]}))

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

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

-- | DSL name token for hydra.ext.cpp.syntax.RightShiftOperation
rightShiftOperationRightShiftOperation :: Typed.TypedName Syntax.RightShiftOperation
rightShiftOperationRightShiftOperation = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.RightShiftOperation")

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

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

-- | DSL constructor for hydra.ext.cpp.syntax.SelectionStatement
selectionStatement :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Statement -> Typed.TypedTerm (Maybe Syntax.Statement) -> Typed.TypedTerm Syntax.SelectionStatement
selectionStatement condition thenBranch elseBranch =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.SelectionStatement"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "condition"),
          Model.fieldTerm = (Typed.unTypedTerm condition)},
        Model.Field {
          Model.fieldName = (Model.Name "thenBranch"),
          Model.fieldTerm = (Typed.unTypedTerm thenBranch)},
        Model.Field {
          Model.fieldName = (Model.Name "elseBranch"),
          Model.fieldTerm = (Typed.unTypedTerm elseBranch)}]}))

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

-- | DSL accessor for the elseBranch field of hydra.ext.cpp.syntax.SelectionStatement
selectionStatementElseBranch :: Typed.TypedTerm Syntax.SelectionStatement -> Typed.TypedTerm (Maybe Syntax.Statement)
selectionStatementElseBranch x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.SelectionStatement"),
        Model.projectionFieldName = (Model.Name "elseBranch")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.cpp.syntax.SelectionStatement
selectionStatementSelectionStatement :: Typed.TypedName Syntax.SelectionStatement
selectionStatementSelectionStatement = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.SelectionStatement")

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

-- | DSL updater for the condition field of hydra.ext.cpp.syntax.SelectionStatement
selectionStatementWithCondition :: Typed.TypedTerm Syntax.SelectionStatement -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.SelectionStatement
selectionStatementWithCondition original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.SelectionStatement"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "condition"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "thenBranch"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.SelectionStatement"),
              Model.projectionFieldName = (Model.Name "thenBranch")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "elseBranch"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.SelectionStatement"),
              Model.projectionFieldName = (Model.Name "elseBranch")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the elseBranch field of hydra.ext.cpp.syntax.SelectionStatement
selectionStatementWithElseBranch :: Typed.TypedTerm Syntax.SelectionStatement -> Typed.TypedTerm (Maybe Syntax.Statement) -> Typed.TypedTerm Syntax.SelectionStatement
selectionStatementWithElseBranch original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.SelectionStatement"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "condition"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.SelectionStatement"),
              Model.projectionFieldName = (Model.Name "condition")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "thenBranch"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.SelectionStatement"),
              Model.projectionFieldName = (Model.Name "thenBranch")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "elseBranch"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the thenBranch field of hydra.ext.cpp.syntax.SelectionStatement
selectionStatementWithThenBranch :: Typed.TypedTerm Syntax.SelectionStatement -> Typed.TypedTerm Syntax.Statement -> Typed.TypedTerm Syntax.SelectionStatement
selectionStatementWithThenBranch original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.SelectionStatement"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "condition"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.SelectionStatement"),
              Model.projectionFieldName = (Model.Name "condition")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "thenBranch"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "elseBranch"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.SelectionStatement"),
              Model.projectionFieldName = (Model.Name "elseBranch")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.cpp.syntax.Set
set :: Typed.TypedTerm Syntax.TypeExpression -> Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.Set
set elementType elements =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.Set"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "elementType"),
          Model.fieldTerm = (Typed.unTypedTerm elementType)},
        Model.Field {
          Model.fieldName = (Model.Name "elements"),
          Model.fieldTerm = (Typed.unTypedTerm elements)}]}))

-- | DSL constructor for hydra.ext.cpp.syntax.SetDeclaration
setDeclaration :: Typed.TypedTerm Syntax.TypeExpression -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.SetDeclaration
setDeclaration elementType name =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.SetDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "elementType"),
          Model.fieldTerm = (Typed.unTypedTerm elementType)},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)}]}))

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

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

-- | DSL name token for hydra.ext.cpp.syntax.SetDeclaration
setDeclarationSetDeclaration :: Typed.TypedName Syntax.SetDeclaration
setDeclarationSetDeclaration = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.SetDeclaration")

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

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

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

-- | DSL accessor for the elements field of hydra.ext.cpp.syntax.Set
setElements :: Typed.TypedTerm Syntax.Set -> Typed.TypedTerm [Syntax.Expression]
setElements x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Set"),
        Model.projectionFieldName = (Model.Name "elements")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.cpp.syntax.Set
setSet :: Typed.TypedName Syntax.Set
setSet = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.Set")

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

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

-- | DSL injection for the additive variant of hydra.ext.cpp.syntax.ShiftExpression
shiftExpressionAdditive :: Typed.TypedTerm Syntax.AdditiveExpression -> Typed.TypedTerm Syntax.ShiftExpression
shiftExpressionAdditive x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ShiftExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "additive"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the leftShift variant of hydra.ext.cpp.syntax.ShiftExpression
shiftExpressionLeftShift :: Typed.TypedTerm Syntax.LeftShiftOperation -> Typed.TypedTerm Syntax.ShiftExpression
shiftExpressionLeftShift x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ShiftExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "leftShift"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the rightShift variant of hydra.ext.cpp.syntax.ShiftExpression
shiftExpressionRightShift :: Typed.TypedTerm Syntax.RightShiftOperation -> Typed.TypedTerm Syntax.ShiftExpression
shiftExpressionRightShift x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.ShiftExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "rightShift"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.cpp.syntax.ShiftExpression
shiftExpressionShiftExpression :: Typed.TypedName Syntax.ShiftExpression
shiftExpressionShiftExpression = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.ShiftExpression")

-- | DSL constructor for the hydra.ext.cpp.syntax.SizeofExpression wrapper
sizeofExpression :: Typed.TypedTerm Syntax.TypeExpression -> Typed.TypedTerm Syntax.SizeofExpression
sizeofExpression x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.cpp.syntax.SizeofExpression"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.cpp.syntax.SizeofExpression
sizeofExpressionSizeofExpression :: Typed.TypedName Syntax.SizeofExpression
sizeofExpressionSizeofExpression = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.SizeofExpression")

-- | DSL injection for the compound variant of hydra.ext.cpp.syntax.Statement
statementCompound :: Typed.TypedTerm Syntax.CompoundStatement -> Typed.TypedTerm Syntax.Statement
statementCompound x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Statement"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "compound"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the declaration variant of hydra.ext.cpp.syntax.Statement
statementDeclaration :: Typed.TypedTerm Syntax.VariableDeclaration -> Typed.TypedTerm Syntax.Statement
statementDeclaration x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Statement"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "declaration"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the expression variant of hydra.ext.cpp.syntax.Statement
statementExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Statement
statementExpression x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Statement"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "expression"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the iteration variant of hydra.ext.cpp.syntax.Statement
statementIteration :: Typed.TypedTerm Syntax.IterationStatement -> Typed.TypedTerm Syntax.Statement
statementIteration x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Statement"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "iteration"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the jump variant of hydra.ext.cpp.syntax.Statement
statementJump :: Typed.TypedTerm Syntax.JumpStatement -> Typed.TypedTerm Syntax.Statement
statementJump x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Statement"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "jump"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the labeled variant of hydra.ext.cpp.syntax.Statement
statementLabeled :: Typed.TypedTerm Syntax.LabeledStatement -> Typed.TypedTerm Syntax.Statement
statementLabeled x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Statement"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "labeled"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the selection variant of hydra.ext.cpp.syntax.Statement
statementSelection :: Typed.TypedTerm Syntax.SelectionStatement -> Typed.TypedTerm Syntax.Statement
statementSelection x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Statement"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "selection"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.cpp.syntax.Statement
statementStatement :: Typed.TypedName Syntax.Statement
statementStatement = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.Statement")

-- | DSL injection for the switch variant of hydra.ext.cpp.syntax.Statement
statementSwitch :: Typed.TypedTerm Syntax.SwitchStatement -> Typed.TypedTerm Syntax.Statement
statementSwitch x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Statement"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "switch"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

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

-- | DSL name token for hydra.ext.cpp.syntax.StringLiteral
stringLiteralStringLiteral :: Typed.TypedName Syntax.StringLiteral
stringLiteralStringLiteral = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.StringLiteral")

-- | DSL constructor for hydra.ext.cpp.syntax.SubscriptOperation
subscriptOperation :: Typed.TypedTerm Syntax.PostfixExpression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.SubscriptOperation
subscriptOperation array index =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.SubscriptOperation"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "array"),
          Model.fieldTerm = (Typed.unTypedTerm array)},
        Model.Field {
          Model.fieldName = (Model.Name "index"),
          Model.fieldTerm = (Typed.unTypedTerm index)}]}))

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

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

-- | DSL name token for hydra.ext.cpp.syntax.SubscriptOperation
subscriptOperationSubscriptOperation :: Typed.TypedName Syntax.SubscriptOperation
subscriptOperationSubscriptOperation = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.SubscriptOperation")

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

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

-- | DSL constructor for hydra.ext.cpp.syntax.SubtractOperation
subtractOperation :: Typed.TypedTerm Syntax.AdditiveExpression -> Typed.TypedTerm Syntax.MultiplicativeExpression -> Typed.TypedTerm Syntax.SubtractOperation
subtractOperation left right =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.SubtractOperation"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Typed.unTypedTerm left)},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Typed.unTypedTerm right)}]}))

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

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

-- | DSL name token for hydra.ext.cpp.syntax.SubtractOperation
subtractOperationSubtractOperation :: Typed.TypedName Syntax.SubtractOperation
subtractOperationSubtractOperation = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.SubtractOperation")

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

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

-- | DSL constructor for hydra.ext.cpp.syntax.SwitchStatement
switchStatement :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm [Syntax.CaseStatement] -> Typed.TypedTerm Syntax.SwitchStatement
switchStatement value cases =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.SwitchStatement"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "value"),
          Model.fieldTerm = (Typed.unTypedTerm value)},
        Model.Field {
          Model.fieldName = (Model.Name "cases"),
          Model.fieldTerm = (Typed.unTypedTerm cases)}]}))

-- | DSL accessor for the cases field of hydra.ext.cpp.syntax.SwitchStatement
switchStatementCases :: Typed.TypedTerm Syntax.SwitchStatement -> Typed.TypedTerm [Syntax.CaseStatement]
switchStatementCases x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.SwitchStatement"),
        Model.projectionFieldName = (Model.Name "cases")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.cpp.syntax.SwitchStatement
switchStatementSwitchStatement :: Typed.TypedName Syntax.SwitchStatement
switchStatementSwitchStatement = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.SwitchStatement")

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

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

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

-- | DSL name token for hydra.ext.cpp.syntax.TemplateArgument
templateArgumentTemplateArgument :: Typed.TypedName Syntax.TemplateArgument
templateArgumentTemplateArgument = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.TemplateArgument")

-- | DSL injection for the type variant of hydra.ext.cpp.syntax.TemplateArgument
templateArgumentType :: Typed.TypedTerm Syntax.TypeExpression -> Typed.TypedTerm Syntax.TemplateArgument
templateArgumentType x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TemplateArgument"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "type"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the value variant of hydra.ext.cpp.syntax.TemplateArgument
templateArgumentValue :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.TemplateArgument
templateArgumentValue x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TemplateArgument"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "value"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for hydra.ext.cpp.syntax.TemplateDeclaration
templateDeclaration :: Typed.TypedTerm Bool -> Typed.TypedTerm [String] -> Typed.TypedTerm Syntax.Declaration -> Typed.TypedTerm Syntax.TemplateDeclaration
templateDeclaration inline parameters declaration =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.TemplateDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "inline"),
          Model.fieldTerm = (Typed.unTypedTerm inline)},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Typed.unTypedTerm parameters)},
        Model.Field {
          Model.fieldName = (Model.Name "declaration"),
          Model.fieldTerm = (Typed.unTypedTerm declaration)}]}))

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

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

-- | DSL accessor for the parameters field of hydra.ext.cpp.syntax.TemplateDeclaration
templateDeclarationParameters :: Typed.TypedTerm Syntax.TemplateDeclaration -> Typed.TypedTerm [String]
templateDeclarationParameters x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TemplateDeclaration"),
        Model.projectionFieldName = (Model.Name "parameters")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.cpp.syntax.TemplateDeclaration
templateDeclarationTemplateDeclaration :: Typed.TypedName Syntax.TemplateDeclaration
templateDeclarationTemplateDeclaration = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.TemplateDeclaration")

-- | DSL updater for the declaration field of hydra.ext.cpp.syntax.TemplateDeclaration
templateDeclarationWithDeclaration :: Typed.TypedTerm Syntax.TemplateDeclaration -> Typed.TypedTerm Syntax.Declaration -> Typed.TypedTerm Syntax.TemplateDeclaration
templateDeclarationWithDeclaration original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.TemplateDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "inline"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TemplateDeclaration"),
              Model.projectionFieldName = (Model.Name "inline")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TemplateDeclaration"),
              Model.projectionFieldName = (Model.Name "parameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "declaration"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the inline field of hydra.ext.cpp.syntax.TemplateDeclaration
templateDeclarationWithInline :: Typed.TypedTerm Syntax.TemplateDeclaration -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.TemplateDeclaration
templateDeclarationWithInline original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.TemplateDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "inline"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TemplateDeclaration"),
              Model.projectionFieldName = (Model.Name "parameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "declaration"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TemplateDeclaration"),
              Model.projectionFieldName = (Model.Name "declaration")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the parameters field of hydra.ext.cpp.syntax.TemplateDeclaration
templateDeclarationWithParameters :: Typed.TypedTerm Syntax.TemplateDeclaration -> Typed.TypedTerm [String] -> Typed.TypedTerm Syntax.TemplateDeclaration
templateDeclarationWithParameters original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.TemplateDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "inline"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TemplateDeclaration"),
              Model.projectionFieldName = (Model.Name "inline")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "declaration"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TemplateDeclaration"),
              Model.projectionFieldName = (Model.Name "declaration")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.cpp.syntax.TemplateFunctionCallOperation
templateFunctionCallOperation :: Typed.TypedTerm Syntax.PostfixExpression -> Typed.TypedTerm [Syntax.TemplateArgument] -> Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.TemplateFunctionCallOperation
templateFunctionCallOperation function templateArguments arguments =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.TemplateFunctionCallOperation"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "function"),
          Model.fieldTerm = (Typed.unTypedTerm function)},
        Model.Field {
          Model.fieldName = (Model.Name "templateArguments"),
          Model.fieldTerm = (Typed.unTypedTerm templateArguments)},
        Model.Field {
          Model.fieldName = (Model.Name "arguments"),
          Model.fieldTerm = (Typed.unTypedTerm arguments)}]}))

-- | DSL accessor for the arguments field of hydra.ext.cpp.syntax.TemplateFunctionCallOperation
templateFunctionCallOperationArguments :: Typed.TypedTerm Syntax.TemplateFunctionCallOperation -> Typed.TypedTerm [Syntax.Expression]
templateFunctionCallOperationArguments x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TemplateFunctionCallOperation"),
        Model.projectionFieldName = (Model.Name "arguments")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

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

-- | DSL accessor for the templateArguments field of hydra.ext.cpp.syntax.TemplateFunctionCallOperation
templateFunctionCallOperationTemplateArguments :: Typed.TypedTerm Syntax.TemplateFunctionCallOperation -> Typed.TypedTerm [Syntax.TemplateArgument]
templateFunctionCallOperationTemplateArguments x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TemplateFunctionCallOperation"),
        Model.projectionFieldName = (Model.Name "templateArguments")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.cpp.syntax.TemplateFunctionCallOperation
templateFunctionCallOperationTemplateFunctionCallOperation :: Typed.TypedName Syntax.TemplateFunctionCallOperation
templateFunctionCallOperationTemplateFunctionCallOperation =
    Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.TemplateFunctionCallOperation")

-- | DSL updater for the arguments field of hydra.ext.cpp.syntax.TemplateFunctionCallOperation
templateFunctionCallOperationWithArguments :: Typed.TypedTerm Syntax.TemplateFunctionCallOperation -> Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.TemplateFunctionCallOperation
templateFunctionCallOperationWithArguments original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.TemplateFunctionCallOperation"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "function"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TemplateFunctionCallOperation"),
              Model.projectionFieldName = (Model.Name "function")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "templateArguments"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TemplateFunctionCallOperation"),
              Model.projectionFieldName = (Model.Name "templateArguments")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "arguments"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the function field of hydra.ext.cpp.syntax.TemplateFunctionCallOperation
templateFunctionCallOperationWithFunction :: Typed.TypedTerm Syntax.TemplateFunctionCallOperation -> Typed.TypedTerm Syntax.PostfixExpression -> Typed.TypedTerm Syntax.TemplateFunctionCallOperation
templateFunctionCallOperationWithFunction original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.TemplateFunctionCallOperation"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "function"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "templateArguments"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TemplateFunctionCallOperation"),
              Model.projectionFieldName = (Model.Name "templateArguments")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "arguments"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TemplateFunctionCallOperation"),
              Model.projectionFieldName = (Model.Name "arguments")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the templateArguments field of hydra.ext.cpp.syntax.TemplateFunctionCallOperation
templateFunctionCallOperationWithTemplateArguments :: Typed.TypedTerm Syntax.TemplateFunctionCallOperation -> Typed.TypedTerm [Syntax.TemplateArgument] -> Typed.TypedTerm Syntax.TemplateFunctionCallOperation
templateFunctionCallOperationWithTemplateArguments original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.TemplateFunctionCallOperation"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "function"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TemplateFunctionCallOperation"),
              Model.projectionFieldName = (Model.Name "function")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "templateArguments"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "arguments"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TemplateFunctionCallOperation"),
              Model.projectionFieldName = (Model.Name "arguments")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.cpp.syntax.TemplateType
templateType :: Typed.TypedTerm String -> Typed.TypedTerm [Syntax.TemplateArgument] -> Typed.TypedTerm Syntax.TemplateType
templateType name arguments =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.TemplateType"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)},
        Model.Field {
          Model.fieldName = (Model.Name "arguments"),
          Model.fieldTerm = (Typed.unTypedTerm arguments)}]}))

-- | DSL accessor for the arguments field of hydra.ext.cpp.syntax.TemplateType
templateTypeArguments :: Typed.TypedTerm Syntax.TemplateType -> Typed.TypedTerm [Syntax.TemplateArgument]
templateTypeArguments x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TemplateType"),
        Model.projectionFieldName = (Model.Name "arguments")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

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

-- | DSL name token for hydra.ext.cpp.syntax.TemplateType
templateTypeTemplateType :: Typed.TypedName Syntax.TemplateType
templateTypeTemplateType = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.TemplateType")

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

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

-- | DSL constructor for hydra.ext.cpp.syntax.TernaryExpression
ternaryExpression :: Typed.TypedTerm Syntax.LogicalOrExpression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.ConditionalExpression -> Typed.TypedTerm Syntax.TernaryExpression
ternaryExpression condition trueExpr falseExpr =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.TernaryExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "condition"),
          Model.fieldTerm = (Typed.unTypedTerm condition)},
        Model.Field {
          Model.fieldName = (Model.Name "trueExpr"),
          Model.fieldTerm = (Typed.unTypedTerm trueExpr)},
        Model.Field {
          Model.fieldName = (Model.Name "falseExpr"),
          Model.fieldTerm = (Typed.unTypedTerm falseExpr)}]}))

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

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

-- | DSL name token for hydra.ext.cpp.syntax.TernaryExpression
ternaryExpressionTernaryExpression :: Typed.TypedName Syntax.TernaryExpression
ternaryExpressionTernaryExpression = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.TernaryExpression")

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

-- | DSL updater for the condition field of hydra.ext.cpp.syntax.TernaryExpression
ternaryExpressionWithCondition :: Typed.TypedTerm Syntax.TernaryExpression -> Typed.TypedTerm Syntax.LogicalOrExpression -> Typed.TypedTerm Syntax.TernaryExpression
ternaryExpressionWithCondition original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.TernaryExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "condition"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "trueExpr"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TernaryExpression"),
              Model.projectionFieldName = (Model.Name "trueExpr")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "falseExpr"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TernaryExpression"),
              Model.projectionFieldName = (Model.Name "falseExpr")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the falseExpr field of hydra.ext.cpp.syntax.TernaryExpression
ternaryExpressionWithFalseExpr :: Typed.TypedTerm Syntax.TernaryExpression -> Typed.TypedTerm Syntax.ConditionalExpression -> Typed.TypedTerm Syntax.TernaryExpression
ternaryExpressionWithFalseExpr original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.TernaryExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "condition"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TernaryExpression"),
              Model.projectionFieldName = (Model.Name "condition")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "trueExpr"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TernaryExpression"),
              Model.projectionFieldName = (Model.Name "trueExpr")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "falseExpr"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the trueExpr field of hydra.ext.cpp.syntax.TernaryExpression
ternaryExpressionWithTrueExpr :: Typed.TypedTerm Syntax.TernaryExpression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.TernaryExpression
ternaryExpressionWithTrueExpr original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.TernaryExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "condition"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TernaryExpression"),
              Model.projectionFieldName = (Model.Name "condition")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "trueExpr"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "falseExpr"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TernaryExpression"),
              Model.projectionFieldName = (Model.Name "falseExpr")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL injection for the auto variant of hydra.ext.cpp.syntax.TypeExpression
typeExpressionAuto :: Typed.TypedTerm Syntax.TypeExpression
typeExpressionAuto =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TypeExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "auto"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the basic variant of hydra.ext.cpp.syntax.TypeExpression
typeExpressionBasic :: Typed.TypedTerm Syntax.BasicType -> Typed.TypedTerm Syntax.TypeExpression
typeExpressionBasic x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TypeExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "basic"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the function variant of hydra.ext.cpp.syntax.TypeExpression
typeExpressionFunction :: Typed.TypedTerm Syntax.FunctionType -> Typed.TypedTerm Syntax.TypeExpression
typeExpressionFunction x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TypeExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "function"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the qualified variant of hydra.ext.cpp.syntax.TypeExpression
typeExpressionQualified :: Typed.TypedTerm Syntax.QualifiedType -> Typed.TypedTerm Syntax.TypeExpression
typeExpressionQualified x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TypeExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "qualified"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the template variant of hydra.ext.cpp.syntax.TypeExpression
typeExpressionTemplate :: Typed.TypedTerm Syntax.TemplateType -> Typed.TypedTerm Syntax.TypeExpression
typeExpressionTemplate x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TypeExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "template"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.cpp.syntax.TypeExpression
typeExpressionTypeExpression :: Typed.TypedName Syntax.TypeExpression
typeExpressionTypeExpression = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.TypeExpression")

-- | DSL injection for the const variant of hydra.ext.cpp.syntax.TypeQualifier
typeQualifierConst :: Typed.TypedTerm Syntax.TypeQualifier
typeQualifierConst =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TypeQualifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "const"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the lvalueRef variant of hydra.ext.cpp.syntax.TypeQualifier
typeQualifierLvalueRef :: Typed.TypedTerm Syntax.TypeQualifier
typeQualifierLvalueRef =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TypeQualifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "lvalueRef"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the pointer variant of hydra.ext.cpp.syntax.TypeQualifier
typeQualifierPointer :: Typed.TypedTerm Syntax.TypeQualifier
typeQualifierPointer =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TypeQualifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "pointer"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the rvalueRef variant of hydra.ext.cpp.syntax.TypeQualifier
typeQualifierRvalueRef :: Typed.TypedTerm Syntax.TypeQualifier
typeQualifierRvalueRef =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TypeQualifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "rvalueRef"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL name token for hydra.ext.cpp.syntax.TypeQualifier
typeQualifierTypeQualifier :: Typed.TypedName Syntax.TypeQualifier
typeQualifierTypeQualifier = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.TypeQualifier")

-- | DSL constructor for hydra.ext.cpp.syntax.TypedefDeclaration
typedefDeclaration :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.TypeExpression -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.TypedefDeclaration
typedefDeclaration name type_ isUsing =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.TypedefDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm type_)},
        Model.Field {
          Model.fieldName = (Model.Name "isUsing"),
          Model.fieldTerm = (Typed.unTypedTerm isUsing)}]}))

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

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

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

-- | DSL name token for hydra.ext.cpp.syntax.TypedefDeclaration
typedefDeclarationTypedefDeclaration :: Typed.TypedName Syntax.TypedefDeclaration
typedefDeclarationTypedefDeclaration = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.TypedefDeclaration")

-- | DSL updater for the isUsing field of hydra.ext.cpp.syntax.TypedefDeclaration
typedefDeclarationWithIsUsing :: Typed.TypedTerm Syntax.TypedefDeclaration -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.TypedefDeclaration
typedefDeclarationWithIsUsing original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.TypedefDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TypedefDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TypedefDeclaration"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "isUsing"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the name field of hydra.ext.cpp.syntax.TypedefDeclaration
typedefDeclarationWithName :: Typed.TypedTerm Syntax.TypedefDeclaration -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.TypedefDeclaration
typedefDeclarationWithName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.TypedefDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TypedefDeclaration"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "isUsing"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TypedefDeclaration"),
              Model.projectionFieldName = (Model.Name "isUsing")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the type field of hydra.ext.cpp.syntax.TypedefDeclaration
typedefDeclarationWithType :: Typed.TypedTerm Syntax.TypedefDeclaration -> Typed.TypedTerm Syntax.TypeExpression -> Typed.TypedTerm Syntax.TypedefDeclaration
typedefDeclarationWithType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.TypedefDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TypedefDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "isUsing"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.TypedefDeclaration"),
              Model.projectionFieldName = (Model.Name "isUsing")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

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

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

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

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

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

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

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

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

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

-- | DSL injection for the postfix variant of hydra.ext.cpp.syntax.UnaryExpression
unaryExpressionPostfix :: Typed.TypedTerm Syntax.PostfixExpression -> Typed.TypedTerm Syntax.UnaryExpression
unaryExpressionPostfix x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.UnaryExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "postfix"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the sizeof variant of hydra.ext.cpp.syntax.UnaryExpression
unaryExpressionSizeof :: Typed.TypedTerm Syntax.SizeofExpression -> Typed.TypedTerm Syntax.UnaryExpression
unaryExpressionSizeof x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.UnaryExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "sizeof"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.cpp.syntax.UnaryExpression
unaryExpressionUnaryExpression :: Typed.TypedName Syntax.UnaryExpression
unaryExpressionUnaryExpression = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.UnaryExpression")

-- | DSL injection for the unaryOp variant of hydra.ext.cpp.syntax.UnaryExpression
unaryExpressionUnaryOp :: Typed.TypedTerm Syntax.UnaryOperation -> Typed.TypedTerm Syntax.UnaryExpression
unaryExpressionUnaryOp x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.UnaryExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "unaryOp"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for hydra.ext.cpp.syntax.UnaryOperation
unaryOperation :: Typed.TypedTerm Syntax.UnaryOperator -> Typed.TypedTerm Syntax.UnaryExpression -> Typed.TypedTerm Syntax.UnaryOperation
unaryOperation operator operand =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.UnaryOperation"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "operator"),
          Model.fieldTerm = (Typed.unTypedTerm operator)},
        Model.Field {
          Model.fieldName = (Model.Name "operand"),
          Model.fieldTerm = (Typed.unTypedTerm operand)}]}))

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

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

-- | DSL name token for hydra.ext.cpp.syntax.UnaryOperation
unaryOperationUnaryOperation :: Typed.TypedName Syntax.UnaryOperation
unaryOperationUnaryOperation = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.UnaryOperation")

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

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

-- | DSL injection for the addressOf variant of hydra.ext.cpp.syntax.UnaryOperator
unaryOperatorAddressOf :: Typed.TypedTerm Syntax.UnaryOperator
unaryOperatorAddressOf =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.UnaryOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "addressOf"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the bitwiseNot variant of hydra.ext.cpp.syntax.UnaryOperator
unaryOperatorBitwiseNot :: Typed.TypedTerm Syntax.UnaryOperator
unaryOperatorBitwiseNot =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.UnaryOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "bitwiseNot"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the dereference variant of hydra.ext.cpp.syntax.UnaryOperator
unaryOperatorDereference :: Typed.TypedTerm Syntax.UnaryOperator
unaryOperatorDereference =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.UnaryOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "dereference"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the logicalNot variant of hydra.ext.cpp.syntax.UnaryOperator
unaryOperatorLogicalNot :: Typed.TypedTerm Syntax.UnaryOperator
unaryOperatorLogicalNot =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.UnaryOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "logicalNot"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the minus variant of hydra.ext.cpp.syntax.UnaryOperator
unaryOperatorMinus :: Typed.TypedTerm Syntax.UnaryOperator
unaryOperatorMinus =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.UnaryOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "minus"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the plus variant of hydra.ext.cpp.syntax.UnaryOperator
unaryOperatorPlus :: Typed.TypedTerm Syntax.UnaryOperator
unaryOperatorPlus =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.UnaryOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "plus"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the preDecrement variant of hydra.ext.cpp.syntax.UnaryOperator
unaryOperatorPreDecrement :: Typed.TypedTerm Syntax.UnaryOperator
unaryOperatorPreDecrement =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.UnaryOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "preDecrement"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the preIncrement variant of hydra.ext.cpp.syntax.UnaryOperator
unaryOperatorPreIncrement :: Typed.TypedTerm Syntax.UnaryOperator
unaryOperatorPreIncrement =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.UnaryOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "preIncrement"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL name token for hydra.ext.cpp.syntax.UnaryOperator
unaryOperatorUnaryOperator :: Typed.TypedName Syntax.UnaryOperator
unaryOperatorUnaryOperator = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.UnaryOperator")

-- | DSL constructor for hydra.ext.cpp.syntax.UndefDirective
undefDirective :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.UndefDirective
undefDirective name =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.UndefDirective"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)}]}))

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

-- | DSL name token for hydra.ext.cpp.syntax.UndefDirective
undefDirectiveUndefDirective :: Typed.TypedName Syntax.UndefDirective
undefDirectiveUndefDirective = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.UndefDirective")

-- | DSL updater for the name field of hydra.ext.cpp.syntax.UndefDirective
undefDirectiveWithName :: Typed.TypedTerm Syntax.UndefDirective -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.UndefDirective
undefDirectiveWithName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.UndefDirective"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for hydra.ext.cpp.syntax.VariableDeclaration
variableDeclaration :: Typed.TypedTerm (Maybe Syntax.TypeExpression) -> Typed.TypedTerm String -> Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.VariableDeclaration
variableDeclaration type_ name initializer isAuto =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.VariableDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm type_)},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)},
        Model.Field {
          Model.fieldName = (Model.Name "initializer"),
          Model.fieldTerm = (Typed.unTypedTerm initializer)},
        Model.Field {
          Model.fieldName = (Model.Name "isAuto"),
          Model.fieldTerm = (Typed.unTypedTerm isAuto)}]}))

-- | DSL accessor for the initializer field of hydra.ext.cpp.syntax.VariableDeclaration
variableDeclarationInitializer :: Typed.TypedTerm Syntax.VariableDeclaration -> Typed.TypedTerm (Maybe Syntax.Expression)
variableDeclarationInitializer x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.VariableDeclaration"),
        Model.projectionFieldName = (Model.Name "initializer")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

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

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

-- | DSL accessor for the type field of hydra.ext.cpp.syntax.VariableDeclaration
variableDeclarationType :: Typed.TypedTerm Syntax.VariableDeclaration -> Typed.TypedTerm (Maybe Syntax.TypeExpression)
variableDeclarationType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.VariableDeclaration"),
        Model.projectionFieldName = (Model.Name "type")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.cpp.syntax.VariableDeclaration
variableDeclarationVariableDeclaration :: Typed.TypedName Syntax.VariableDeclaration
variableDeclarationVariableDeclaration = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.VariableDeclaration")

-- | DSL updater for the initializer field of hydra.ext.cpp.syntax.VariableDeclaration
variableDeclarationWithInitializer :: Typed.TypedTerm Syntax.VariableDeclaration -> Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm Syntax.VariableDeclaration
variableDeclarationWithInitializer original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.VariableDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.VariableDeclaration"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.VariableDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "initializer"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "isAuto"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.VariableDeclaration"),
              Model.projectionFieldName = (Model.Name "isAuto")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the isAuto field of hydra.ext.cpp.syntax.VariableDeclaration
variableDeclarationWithIsAuto :: Typed.TypedTerm Syntax.VariableDeclaration -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.VariableDeclaration
variableDeclarationWithIsAuto original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.VariableDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.VariableDeclaration"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.VariableDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "initializer"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.VariableDeclaration"),
              Model.projectionFieldName = (Model.Name "initializer")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "isAuto"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the name field of hydra.ext.cpp.syntax.VariableDeclaration
variableDeclarationWithName :: Typed.TypedTerm Syntax.VariableDeclaration -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.VariableDeclaration
variableDeclarationWithName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.VariableDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.VariableDeclaration"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "initializer"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.VariableDeclaration"),
              Model.projectionFieldName = (Model.Name "initializer")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "isAuto"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.VariableDeclaration"),
              Model.projectionFieldName = (Model.Name "isAuto")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the type field of hydra.ext.cpp.syntax.VariableDeclaration
variableDeclarationWithType :: Typed.TypedTerm Syntax.VariableDeclaration -> Typed.TypedTerm (Maybe Syntax.TypeExpression) -> Typed.TypedTerm Syntax.VariableDeclaration
variableDeclarationWithType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.VariableDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.VariableDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "initializer"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.VariableDeclaration"),
              Model.projectionFieldName = (Model.Name "initializer")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "isAuto"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.VariableDeclaration"),
              Model.projectionFieldName = (Model.Name "isAuto")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.cpp.syntax.VariantDeclaration
variantDeclaration :: Typed.TypedTerm [Syntax.TypeExpression] -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.VariantDeclaration
variantDeclaration types name =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.VariantDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "types"),
          Model.fieldTerm = (Typed.unTypedTerm types)},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)}]}))

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

-- | DSL accessor for the types field of hydra.ext.cpp.syntax.VariantDeclaration
variantDeclarationTypes :: Typed.TypedTerm Syntax.VariantDeclaration -> Typed.TypedTerm [Syntax.TypeExpression]
variantDeclarationTypes x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.VariantDeclaration"),
        Model.projectionFieldName = (Model.Name "types")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.cpp.syntax.VariantDeclaration
variantDeclarationVariantDeclaration :: Typed.TypedName Syntax.VariantDeclaration
variantDeclarationVariantDeclaration = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.VariantDeclaration")

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

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

-- | DSL constructor for hydra.ext.cpp.syntax.Vector
vector :: Typed.TypedTerm Syntax.TypeExpression -> Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.Vector
vector elementType elements =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.Vector"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "elementType"),
          Model.fieldTerm = (Typed.unTypedTerm elementType)},
        Model.Field {
          Model.fieldName = (Model.Name "elements"),
          Model.fieldTerm = (Typed.unTypedTerm elements)}]}))

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

-- | DSL accessor for the elements field of hydra.ext.cpp.syntax.Vector
vectorElements :: Typed.TypedTerm Syntax.Vector -> Typed.TypedTerm [Syntax.Expression]
vectorElements x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Vector"),
        Model.projectionFieldName = (Model.Name "elements")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.cpp.syntax.Vector
vectorVector :: Typed.TypedName Syntax.Vector
vectorVector = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.Vector")

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

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

-- | DSL injection for the lambda variant of hydra.ext.cpp.syntax.Visitor
visitorLambda :: Typed.TypedTerm Syntax.LambdaExpression -> Typed.TypedTerm Syntax.Visitor
visitorLambda x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Visitor"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "lambda"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the overloaded variant of hydra.ext.cpp.syntax.Visitor
visitorOverloaded :: Typed.TypedTerm Syntax.OverloadedLambdas -> Typed.TypedTerm Syntax.Visitor
visitorOverloaded x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.cpp.syntax.Visitor"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "overloaded"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.cpp.syntax.Visitor
visitorVisitor :: Typed.TypedName Syntax.Visitor
visitorVisitor = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.Visitor")

-- | DSL constructor for hydra.ext.cpp.syntax.WarningDirective
warningDirective :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.WarningDirective
warningDirective message =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.WarningDirective"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "message"),
          Model.fieldTerm = (Typed.unTypedTerm message)}]}))

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

-- | DSL name token for hydra.ext.cpp.syntax.WarningDirective
warningDirectiveWarningDirective :: Typed.TypedName Syntax.WarningDirective
warningDirectiveWarningDirective = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.WarningDirective")

-- | DSL updater for the message field of hydra.ext.cpp.syntax.WarningDirective
warningDirectiveWithMessage :: Typed.TypedTerm Syntax.WarningDirective -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.WarningDirective
warningDirectiveWithMessage original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.WarningDirective"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "message"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for hydra.ext.cpp.syntax.WhileStatement
whileStatement :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Statement -> Typed.TypedTerm Syntax.WhileStatement
whileStatement condition body =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.cpp.syntax.WhileStatement"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "condition"),
          Model.fieldTerm = (Typed.unTypedTerm condition)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm body)}]}))

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

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

-- | DSL name token for hydra.ext.cpp.syntax.WhileStatement
whileStatementWhileStatement :: Typed.TypedName Syntax.WhileStatement
whileStatementWhileStatement = Typed.TypedName (Model.Name "hydra.ext.cpp.syntax.WhileStatement")

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

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