Regex.hs

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

-- | Term encoders for hydra.regex

module Hydra.Encode.Regex where

import qualified Hydra.Core as Core
import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists
import qualified Hydra.Regex as Regex
import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)
import qualified Data.Scientific as Sci

-- | Encoder for hydra.regex.Alternation
alternation :: [Regex.RegexSequence] -> Core.Term
alternation xs = Core.TermList (Lists.map regexSequence xs)

-- | Encoder for hydra.regex.Atom
atom :: Regex.Atom -> Core.Term
atom x =
    case x of
      Regex.AtomLiteral v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.regex.Atom"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "literal"),
          Core.fieldTerm = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 v0)))}})
      Regex.AtomAny -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.regex.Atom"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "any"),
          Core.fieldTerm = Core.TermUnit}})
      Regex.AtomAnchorStart -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.regex.Atom"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "anchorStart"),
          Core.fieldTerm = Core.TermUnit}})
      Regex.AtomAnchorEnd -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.regex.Atom"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "anchorEnd"),
          Core.fieldTerm = Core.TermUnit}})
      Regex.AtomGroup v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.regex.Atom"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "group"),
          Core.fieldTerm = (alternation v0)}})
      Regex.AtomClass v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.regex.Atom"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "class"),
          Core.fieldTerm = (characterClass v0)}})

-- | Encoder for hydra.regex.CharacterClass
characterClass :: Regex.CharacterClass -> Core.Term
characterClass x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.regex.CharacterClass"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "negated"),
          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralBoolean x2)) (Regex.characterClassNegated x))},
        Core.Field {
          Core.fieldName = (Core.Name "items"),
          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map classItem xs)) (Regex.characterClassItems x))}]})

-- | Encoder for hydra.regex.CharacterRange
characterRange :: Regex.CharacterRange -> Core.Term
characterRange x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.regex.CharacterRange"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "from"),
          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 x2))) (Regex.characterRangeFrom x))},
        Core.Field {
          Core.fieldName = (Core.Name "to"),
          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 x2))) (Regex.characterRangeTo x))}]})

-- | Encoder for hydra.regex.ClassItem
classItem :: Regex.ClassItem -> Core.Term
classItem x =
    case x of
      Regex.ClassItemCharacter v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.regex.ClassItem"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "character"),
          Core.fieldTerm = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 v0)))}})
      Regex.ClassItemRange v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.regex.ClassItem"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "range"),
          Core.fieldTerm = (characterRange v0)}})

-- | Encoder for hydra.regex.Quantified
quantified :: Regex.Quantified -> Core.Term
quantified x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.regex.Quantified"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "atom"),
          Core.fieldTerm = (atom (Regex.quantifiedAtom x))},
        Core.Field {
          Core.fieldName = (Core.Name "quantifier"),
          Core.fieldTerm = (quantifier (Regex.quantifiedQuantifier x))}]})

-- | Encoder for hydra.regex.Quantifier
quantifier :: Regex.Quantifier -> Core.Term
quantifier x =
    case x of
      Regex.QuantifierOne -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.regex.Quantifier"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "one"),
          Core.fieldTerm = Core.TermUnit}})
      Regex.QuantifierZeroOrOne -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.regex.Quantifier"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "zeroOrOne"),
          Core.fieldTerm = Core.TermUnit}})
      Regex.QuantifierZeroOrMore -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.regex.Quantifier"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "zeroOrMore"),
          Core.fieldTerm = Core.TermUnit}})
      Regex.QuantifierOneOrMore -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.regex.Quantifier"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "oneOrMore"),
          Core.fieldTerm = Core.TermUnit}})
      Regex.QuantifierExactly v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.regex.Quantifier"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "exactly"),
          Core.fieldTerm = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 v0)))}})
      Regex.QuantifierAtLeast v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.regex.Quantifier"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "atLeast"),
          Core.fieldTerm = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 v0)))}})
      Regex.QuantifierRange_ v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.regex.Quantifier"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "range"),
          Core.fieldTerm = (quantifierRange v0)}})

-- | Encoder for hydra.regex.QuantifierRange
quantifierRange :: Regex.QuantifierRange -> Core.Term
quantifierRange x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.regex.QuantifierRange"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "min"),
          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 x2))) (Regex.quantifierRangeMin x))},
        Core.Field {
          Core.fieldName = (Core.Name "max"),
          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 x2))) (Regex.quantifierRangeMax x))}]})

-- | Encoder for hydra.regex.Regex
regex :: Regex.Alternation -> Core.Term
regex = alternation

-- | Encoder for hydra.regex.RegexSequence
regexSequence :: [Regex.Quantified] -> Core.Term
regexSequence xs = Core.TermList (Lists.map quantified xs)