hydra-kernel-0.17.2: src/main/haskell/Hydra/Dsl/Regex.hs

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

-- | DSL functions for hydra.regex

module Hydra.Dsl.Regex where

import qualified Hydra.Core as Core
import qualified Hydra.Decode.Regex as DecodeRegex
import qualified Hydra.Encode.Regex as EncodeRegex
import qualified Hydra.Regex as Regex
import qualified Hydra.Typed as Typed
import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)
import qualified Data.Scientific as Sci

-- | DSL injection for the anchorEnd variant of hydra.regex.Atom
atomAnchorEnd :: Typed.TypedTerm Regex.Atom
atomAnchorEnd =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.regex.Atom"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "anchorEnd"),
        Core.fieldTerm = Core.TermUnit}}))

-- | DSL injection for the anchorStart variant of hydra.regex.Atom
atomAnchorStart :: Typed.TypedTerm Regex.Atom
atomAnchorStart =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.regex.Atom"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "anchorStart"),
        Core.fieldTerm = Core.TermUnit}}))

-- | DSL injection for the any variant of hydra.regex.Atom
atomAny :: Typed.TypedTerm Regex.Atom
atomAny =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.regex.Atom"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "any"),
        Core.fieldTerm = Core.TermUnit}}))

-- | DSL name token for hydra.regex.Atom
atomAtom :: Typed.TypedName Regex.Atom
atomAtom = Typed.TypedName (Core.Name "hydra.regex.Atom")

-- | DSL injection for the class variant of hydra.regex.Atom
atomClass :: Typed.TypedTerm Regex.CharacterClass -> Typed.TypedTerm Regex.Atom
atomClass x =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.regex.Atom"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "class"),
        Core.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the group variant of hydra.regex.Atom
atomGroup :: Typed.TypedTerm Regex.Alternation -> Typed.TypedTerm Regex.Atom
atomGroup x =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.regex.Atom"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "group"),
        Core.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the literal variant of hydra.regex.Atom
atomLiteral :: Typed.TypedTerm Int -> Typed.TypedTerm Regex.Atom
atomLiteral x =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.regex.Atom"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "literal"),
        Core.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for hydra.regex.CharacterClass
characterClass :: Typed.TypedTerm Bool -> Typed.TypedTerm [Regex.ClassItem] -> Typed.TypedTerm Regex.CharacterClass
characterClass negated items =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.regex.CharacterClass"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "negated"),
          Core.fieldTerm = (Typed.unTypedTerm negated)},
        Core.Field {
          Core.fieldName = (Core.Name "items"),
          Core.fieldTerm = (Typed.unTypedTerm items)}]}))

-- | DSL name token for hydra.regex.CharacterClass
characterClassCharacterClass :: Typed.TypedName Regex.CharacterClass
characterClassCharacterClass = Typed.TypedName (Core.Name "hydra.regex.CharacterClass")

-- | DSL accessor for the items field of hydra.regex.CharacterClass
characterClassItems :: Typed.TypedTerm Regex.CharacterClass -> Typed.TypedTerm [Regex.ClassItem]
characterClassItems x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.regex.CharacterClass"),
        Core.projectionFieldName = (Core.Name "items")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the negated field of hydra.regex.CharacterClass
characterClassNegated :: Typed.TypedTerm Regex.CharacterClass -> Typed.TypedTerm Bool
characterClassNegated x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.regex.CharacterClass"),
        Core.projectionFieldName = (Core.Name "negated")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the items field of hydra.regex.CharacterClass
characterClassWithItems :: Typed.TypedTerm Regex.CharacterClass -> Typed.TypedTerm [Regex.ClassItem] -> Typed.TypedTerm Regex.CharacterClass
characterClassWithItems original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.regex.CharacterClass"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "negated"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.regex.CharacterClass"),
              Core.projectionFieldName = (Core.Name "negated")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "items"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the negated field of hydra.regex.CharacterClass
characterClassWithNegated :: Typed.TypedTerm Regex.CharacterClass -> Typed.TypedTerm Bool -> Typed.TypedTerm Regex.CharacterClass
characterClassWithNegated original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.regex.CharacterClass"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "negated"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "items"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.regex.CharacterClass"),
              Core.projectionFieldName = (Core.Name "items")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.regex.CharacterRange
characterRange :: Typed.TypedTerm Int -> Typed.TypedTerm Int -> Typed.TypedTerm Regex.CharacterRange
characterRange from to =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.regex.CharacterRange"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "from"),
          Core.fieldTerm = (Typed.unTypedTerm from)},
        Core.Field {
          Core.fieldName = (Core.Name "to"),
          Core.fieldTerm = (Typed.unTypedTerm to)}]}))

-- | DSL name token for hydra.regex.CharacterRange
characterRangeCharacterRange :: Typed.TypedName Regex.CharacterRange
characterRangeCharacterRange = Typed.TypedName (Core.Name "hydra.regex.CharacterRange")

-- | DSL accessor for the from field of hydra.regex.CharacterRange
characterRangeFrom :: Typed.TypedTerm Regex.CharacterRange -> Typed.TypedTerm Int
characterRangeFrom x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.regex.CharacterRange"),
        Core.projectionFieldName = (Core.Name "from")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the to field of hydra.regex.CharacterRange
characterRangeTo :: Typed.TypedTerm Regex.CharacterRange -> Typed.TypedTerm Int
characterRangeTo x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.regex.CharacterRange"),
        Core.projectionFieldName = (Core.Name "to")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the from field of hydra.regex.CharacterRange
characterRangeWithFrom :: Typed.TypedTerm Regex.CharacterRange -> Typed.TypedTerm Int -> Typed.TypedTerm Regex.CharacterRange
characterRangeWithFrom original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.regex.CharacterRange"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "from"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "to"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.regex.CharacterRange"),
              Core.projectionFieldName = (Core.Name "to")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the to field of hydra.regex.CharacterRange
characterRangeWithTo :: Typed.TypedTerm Regex.CharacterRange -> Typed.TypedTerm Int -> Typed.TypedTerm Regex.CharacterRange
characterRangeWithTo original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.regex.CharacterRange"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "from"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.regex.CharacterRange"),
              Core.projectionFieldName = (Core.Name "from")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "to"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL injection for the character variant of hydra.regex.ClassItem
classItemCharacter :: Typed.TypedTerm Int -> Typed.TypedTerm Regex.ClassItem
classItemCharacter x =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.regex.ClassItem"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "character"),
        Core.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.regex.ClassItem
classItemClassItem :: Typed.TypedName Regex.ClassItem
classItemClassItem = Typed.TypedName (Core.Name "hydra.regex.ClassItem")

-- | DSL injection for the range variant of hydra.regex.ClassItem
classItemRange :: Typed.TypedTerm Regex.CharacterRange -> Typed.TypedTerm Regex.ClassItem
classItemRange x =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.regex.ClassItem"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "range"),
        Core.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for hydra.regex.Quantified
quantified :: Typed.TypedTerm Regex.Atom -> Typed.TypedTerm Regex.Quantifier -> Typed.TypedTerm Regex.Quantified
quantified atom quantifier =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.regex.Quantified"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "atom"),
          Core.fieldTerm = (Typed.unTypedTerm atom)},
        Core.Field {
          Core.fieldName = (Core.Name "quantifier"),
          Core.fieldTerm = (Typed.unTypedTerm quantifier)}]}))

-- | DSL accessor for the atom field of hydra.regex.Quantified
quantifiedAtom :: Typed.TypedTerm Regex.Quantified -> Typed.TypedTerm Regex.Atom
quantifiedAtom x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.regex.Quantified"),
        Core.projectionFieldName = (Core.Name "atom")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.regex.Quantified
quantifiedQuantified :: Typed.TypedName Regex.Quantified
quantifiedQuantified = Typed.TypedName (Core.Name "hydra.regex.Quantified")

-- | DSL accessor for the quantifier field of hydra.regex.Quantified
quantifiedQuantifier :: Typed.TypedTerm Regex.Quantified -> Typed.TypedTerm Regex.Quantifier
quantifiedQuantifier x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.regex.Quantified"),
        Core.projectionFieldName = (Core.Name "quantifier")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the atom field of hydra.regex.Quantified
quantifiedWithAtom :: Typed.TypedTerm Regex.Quantified -> Typed.TypedTerm Regex.Atom -> Typed.TypedTerm Regex.Quantified
quantifiedWithAtom original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.regex.Quantified"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "atom"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "quantifier"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.regex.Quantified"),
              Core.projectionFieldName = (Core.Name "quantifier")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the quantifier field of hydra.regex.Quantified
quantifiedWithQuantifier :: Typed.TypedTerm Regex.Quantified -> Typed.TypedTerm Regex.Quantifier -> Typed.TypedTerm Regex.Quantified
quantifiedWithQuantifier original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.regex.Quantified"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "atom"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.regex.Quantified"),
              Core.projectionFieldName = (Core.Name "atom")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "quantifier"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL injection for the atLeast variant of hydra.regex.Quantifier
quantifierAtLeast :: Typed.TypedTerm Int -> Typed.TypedTerm Regex.Quantifier
quantifierAtLeast x =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.regex.Quantifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "atLeast"),
        Core.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the exactly variant of hydra.regex.Quantifier
quantifierExactly :: Typed.TypedTerm Int -> Typed.TypedTerm Regex.Quantifier
quantifierExactly x =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.regex.Quantifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "exactly"),
        Core.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the one variant of hydra.regex.Quantifier
quantifierOne :: Typed.TypedTerm Regex.Quantifier
quantifierOne =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.regex.Quantifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "one"),
        Core.fieldTerm = Core.TermUnit}}))

-- | DSL injection for the oneOrMore variant of hydra.regex.Quantifier
quantifierOneOrMore :: Typed.TypedTerm Regex.Quantifier
quantifierOneOrMore =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.regex.Quantifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "oneOrMore"),
        Core.fieldTerm = Core.TermUnit}}))

-- | DSL name token for hydra.regex.Quantifier
quantifierQuantifier :: Typed.TypedName Regex.Quantifier
quantifierQuantifier = Typed.TypedName (Core.Name "hydra.regex.Quantifier")

-- | DSL injection for the range variant of hydra.regex.Quantifier
quantifierRange :: Typed.TypedTerm Regex.QuantifierRange -> Typed.TypedTerm Regex.Quantifier
quantifierRange x =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.regex.Quantifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "range"),
        Core.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for hydra.regex.QuantifierRange
quantifierRange2 :: Typed.TypedTerm Int -> Typed.TypedTerm Int -> Typed.TypedTerm Regex.QuantifierRange
quantifierRange2 min max =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.regex.QuantifierRange"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "min"),
          Core.fieldTerm = (Typed.unTypedTerm min)},
        Core.Field {
          Core.fieldName = (Core.Name "max"),
          Core.fieldTerm = (Typed.unTypedTerm max)}]}))

-- | DSL accessor for the max field of hydra.regex.QuantifierRange
quantifierRangeMax :: Typed.TypedTerm Regex.QuantifierRange -> Typed.TypedTerm Int
quantifierRangeMax x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.regex.QuantifierRange"),
        Core.projectionFieldName = (Core.Name "max")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the min field of hydra.regex.QuantifierRange
quantifierRangeMin :: Typed.TypedTerm Regex.QuantifierRange -> Typed.TypedTerm Int
quantifierRangeMin x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.regex.QuantifierRange"),
        Core.projectionFieldName = (Core.Name "min")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.regex.QuantifierRange
quantifierRangeQuantifierRange :: Typed.TypedName Regex.QuantifierRange
quantifierRangeQuantifierRange = Typed.TypedName (Core.Name "hydra.regex.QuantifierRange")

-- | DSL updater for the max field of hydra.regex.QuantifierRange
quantifierRangeWithMax :: Typed.TypedTerm Regex.QuantifierRange -> Typed.TypedTerm Int -> Typed.TypedTerm Regex.QuantifierRange
quantifierRangeWithMax original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.regex.QuantifierRange"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "min"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.regex.QuantifierRange"),
              Core.projectionFieldName = (Core.Name "min")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "max"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the min field of hydra.regex.QuantifierRange
quantifierRangeWithMin :: Typed.TypedTerm Regex.QuantifierRange -> Typed.TypedTerm Int -> Typed.TypedTerm Regex.QuantifierRange
quantifierRangeWithMin original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.regex.QuantifierRange"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "min"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "max"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.regex.QuantifierRange"),
              Core.projectionFieldName = (Core.Name "max")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL injection for the zeroOrMore variant of hydra.regex.Quantifier
quantifierZeroOrMore :: Typed.TypedTerm Regex.Quantifier
quantifierZeroOrMore =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.regex.Quantifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "zeroOrMore"),
        Core.fieldTerm = Core.TermUnit}}))

-- | DSL injection for the zeroOrOne variant of hydra.regex.Quantifier
quantifierZeroOrOne :: Typed.TypedTerm Regex.Quantifier
quantifierZeroOrOne =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.regex.Quantifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "zeroOrOne"),
        Core.fieldTerm = Core.TermUnit}}))