Regex.hs

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

-- | Primitives in the hydra.core.lib.regex module.

module Hydra.Core.Lib.Regex where

import qualified Hydra.Core.Ast as Ast
import qualified Hydra.Core.Coders as Coders
import qualified Hydra.Core.Diff as Diff
import qualified Hydra.Core.Docs as Docs
import qualified Hydra.Core.Error.Checking as Checking
import qualified Hydra.Core.Error.File as ErrorFile
import qualified Hydra.Core.Error.Model as ErrorModel
import qualified Hydra.Core.Error.Packaging as ErrorPackaging
import qualified Hydra.Core.Error.System as ErrorSystem
import qualified Hydra.Core.Errors as Errors
import qualified Hydra.Core.File as File
import qualified Hydra.Core.Graph as Graph
import qualified Hydra.Core.Json.Model as JsonModel
import qualified Hydra.Core.Markdown as Markdown
import qualified Hydra.Core.Model as Model
import qualified Hydra.Core.Packaging as Packaging
import qualified Hydra.Core.Parsing as Parsing
import qualified Hydra.Core.Paths as Paths
import qualified Hydra.Core.Query as Query
import qualified Hydra.Core.Regex as Regex
import qualified Hydra.Core.Relational as Relational
import qualified Hydra.Core.System as System
import qualified Hydra.Core.Tabular as Tabular
import qualified Hydra.Core.Testing as Testing
import qualified Hydra.Core.Time as Time
import qualified Hydra.Core.Topology as Topology
import qualified Hydra.Core.Typed as Typed
import qualified Hydra.Core.Typing as Typing
import qualified Hydra.Core.Util as Util
import qualified Hydra.Core.Validation as Validation
import qualified Hydra.Core.Variants as Variants
import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines)
import qualified Data.Scientific as Sci
import Data.Void

find :: Packaging.PrimitiveDefinition
find =
    Packaging.PrimitiveDefinition {
      Packaging.primitiveDefinitionName = (Model.Name "hydra.core.lib.regex.find"),
      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {
        Packaging.entityMetadataDescription = (Just "Find the first regex match within a string, returning the matched substring if any."),
        Packaging.entityMetadataComments = [
          "find(pat, s) returns Just(t) where t is the leftmost-longest substring of s matching pat, or Nothing if pat does not match anywhere in s.",
          "Pattern syntax and semantics are Hydra-defined and translingual; see docs/specification/regex.md.",
          "Total; a pattern that does not parse under the Hydra regex grammar is treated as not matching anywhere, the same as a well-formed pattern with no match."],
        Packaging.entityMetadataSeeAlso = [],
        Packaging.entityMetadataLifecycle = Nothing,
        Packaging.entityMetadataProvisions = []})),
      Packaging.primitiveDefinitionSignature = Typing.TermSignature {
        Typing.termSignatureTypeParameters = [],
        Typing.termSignatureParameters = [
          Typing.Parameter {
            Typing.parameterName = (Model.Name "pat"),
            Typing.parameterDescription = (Just "the regex pattern to search for"),
            Typing.parameterType = (Model.TypeLiteral Model.LiteralTypeString),
            Typing.parameterIsLazy = False},
          Typing.Parameter {
            Typing.parameterName = (Model.Name "s"),
            Typing.parameterDescription = (Just "the string to search within"),
            Typing.parameterType = (Model.TypeLiteral Model.LiteralTypeString),
            Typing.parameterIsLazy = False}],
        Typing.termSignatureResult = Typing.Result {
          Typing.resultDescription = Nothing,
          Typing.resultType = (Model.TypeOptional (Model.TypeLiteral Model.LiteralTypeString))}},
      Packaging.primitiveDefinitionIsPure = True,
      Packaging.primitiveDefinitionIsTotal = True,
      Packaging.primitiveDefinitionDefaultImplementation = Nothing}

findAll :: Packaging.PrimitiveDefinition
findAll =
    Packaging.PrimitiveDefinition {
      Packaging.primitiveDefinitionName = (Model.Name "hydra.core.lib.regex.findAll"),
      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {
        Packaging.entityMetadataDescription = (Just "Find all non-overlapping regex matches within a string."),
        Packaging.entityMetadataComments = [
          "findAll(pat, s) returns the list of all leftmost-longest, non-overlapping matches of pat in s, in the order they appear. Returns the empty list if pat does not match anywhere.",
          "Pattern syntax and semantics are Hydra-defined and translingual; see docs/specification/regex.md.",
          "Total; an unparseable pattern yields the empty list, the same as a well-formed pattern with no matches."],
        Packaging.entityMetadataSeeAlso = [],
        Packaging.entityMetadataLifecycle = Nothing,
        Packaging.entityMetadataProvisions = []})),
      Packaging.primitiveDefinitionSignature = Typing.TermSignature {
        Typing.termSignatureTypeParameters = [],
        Typing.termSignatureParameters = [
          Typing.Parameter {
            Typing.parameterName = (Model.Name "pat"),
            Typing.parameterDescription = (Just "the regex pattern to search for"),
            Typing.parameterType = (Model.TypeLiteral Model.LiteralTypeString),
            Typing.parameterIsLazy = False},
          Typing.Parameter {
            Typing.parameterName = (Model.Name "s"),
            Typing.parameterDescription = (Just "the string to search within"),
            Typing.parameterType = (Model.TypeLiteral Model.LiteralTypeString),
            Typing.parameterIsLazy = False}],
        Typing.termSignatureResult = Typing.Result {
          Typing.resultDescription = Nothing,
          Typing.resultType = (Model.TypeList (Model.TypeLiteral Model.LiteralTypeString))}},
      Packaging.primitiveDefinitionIsPure = True,
      Packaging.primitiveDefinitionIsTotal = True,
      Packaging.primitiveDefinitionDefaultImplementation = Nothing}

matches :: Packaging.PrimitiveDefinition
matches =
    Packaging.PrimitiveDefinition {
      Packaging.primitiveDefinitionName = (Model.Name "hydra.core.lib.regex.matches"),
      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {
        Packaging.entityMetadataDescription = (Just "Test whether a regex matches an entire string."),
        Packaging.entityMetadataComments = [
          "matches(pat, s) returns true iff pat matches the whole of s (anchored at both ends; a match of a proper substring of s does not suffice). To test whether pat matches anywhere within s, use find.",
          "Pattern syntax and semantics are Hydra-defined and translingual; see docs/specification/regex.md.",
          "Total; an unparseable pattern yields false, the same as a well-formed pattern with no match."],
        Packaging.entityMetadataSeeAlso = [],
        Packaging.entityMetadataLifecycle = Nothing,
        Packaging.entityMetadataProvisions = []})),
      Packaging.primitiveDefinitionSignature = Typing.TermSignature {
        Typing.termSignatureTypeParameters = [],
        Typing.termSignatureParameters = [
          Typing.Parameter {
            Typing.parameterName = (Model.Name "pat"),
            Typing.parameterDescription = (Just "the regex pattern to test"),
            Typing.parameterType = (Model.TypeLiteral Model.LiteralTypeString),
            Typing.parameterIsLazy = False},
          Typing.Parameter {
            Typing.parameterName = (Model.Name "s"),
            Typing.parameterDescription = (Just "the string to test against"),
            Typing.parameterType = (Model.TypeLiteral Model.LiteralTypeString),
            Typing.parameterIsLazy = False}],
        Typing.termSignatureResult = Typing.Result {
          Typing.resultDescription = Nothing,
          Typing.resultType = (Model.TypeLiteral Model.LiteralTypeBoolean)}},
      Packaging.primitiveDefinitionIsPure = True,
      Packaging.primitiveDefinitionIsTotal = True,
      Packaging.primitiveDefinitionDefaultImplementation = Nothing}

replace :: Packaging.PrimitiveDefinition
replace =
    Packaging.PrimitiveDefinition {
      Packaging.primitiveDefinitionName = (Model.Name "hydra.core.lib.regex.replace"),
      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {
        Packaging.entityMetadataDescription = (Just "Replace the first regex match in a string with a replacement string."),
        Packaging.entityMetadataComments = [
          "replace(pat, repl, s) returns s with the first leftmost-longest match of pat replaced by repl. If pat does not match, s is returned unchanged.",
          "Replacement-string syntax (capture-group references such as $1 or \\\\1, literal escapes) is host-defined.",
          "Pattern syntax and semantics are Hydra-defined and translingual; see docs/specification/regex.md.",
          "Total; an unparseable pattern leaves s unchanged, the same as a well-formed pattern with no match."],
        Packaging.entityMetadataSeeAlso = [],
        Packaging.entityMetadataLifecycle = Nothing,
        Packaging.entityMetadataProvisions = []})),
      Packaging.primitiveDefinitionSignature = Typing.TermSignature {
        Typing.termSignatureTypeParameters = [],
        Typing.termSignatureParameters = [
          Typing.Parameter {
            Typing.parameterName = (Model.Name "pat"),
            Typing.parameterDescription = (Just "the regex pattern to match"),
            Typing.parameterType = (Model.TypeLiteral Model.LiteralTypeString),
            Typing.parameterIsLazy = False},
          Typing.Parameter {
            Typing.parameterName = (Model.Name "repl"),
            Typing.parameterDescription = (Just "the replacement string"),
            Typing.parameterType = (Model.TypeLiteral Model.LiteralTypeString),
            Typing.parameterIsLazy = False},
          Typing.Parameter {
            Typing.parameterName = (Model.Name "s"),
            Typing.parameterDescription = (Just "the string to operate on"),
            Typing.parameterType = (Model.TypeLiteral Model.LiteralTypeString),
            Typing.parameterIsLazy = False}],
        Typing.termSignatureResult = Typing.Result {
          Typing.resultDescription = Nothing,
          Typing.resultType = (Model.TypeLiteral Model.LiteralTypeString)}},
      Packaging.primitiveDefinitionIsPure = True,
      Packaging.primitiveDefinitionIsTotal = True,
      Packaging.primitiveDefinitionDefaultImplementation = Nothing}

replaceAll :: Packaging.PrimitiveDefinition
replaceAll =
    Packaging.PrimitiveDefinition {
      Packaging.primitiveDefinitionName = (Model.Name "hydra.core.lib.regex.replaceAll"),
      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {
        Packaging.entityMetadataDescription = (Just "Replace all non-overlapping regex matches in a string with a replacement string."),
        Packaging.entityMetadataComments = [
          "replaceAll(pat, repl, s) returns s with every leftmost-longest, non-overlapping match of pat replaced by repl. If pat does not match anywhere, s is returned unchanged.",
          "Replacement-string syntax is host-defined; see replace for the caveat.",
          "Pattern syntax and semantics are Hydra-defined and translingual; see docs/specification/regex.md.",
          "Total; an unparseable pattern leaves s unchanged, the same as a well-formed pattern with no match."],
        Packaging.entityMetadataSeeAlso = [],
        Packaging.entityMetadataLifecycle = Nothing,
        Packaging.entityMetadataProvisions = []})),
      Packaging.primitiveDefinitionSignature = Typing.TermSignature {
        Typing.termSignatureTypeParameters = [],
        Typing.termSignatureParameters = [
          Typing.Parameter {
            Typing.parameterName = (Model.Name "pat"),
            Typing.parameterDescription = (Just "the regex pattern to match"),
            Typing.parameterType = (Model.TypeLiteral Model.LiteralTypeString),
            Typing.parameterIsLazy = False},
          Typing.Parameter {
            Typing.parameterName = (Model.Name "repl"),
            Typing.parameterDescription = (Just "the replacement string"),
            Typing.parameterType = (Model.TypeLiteral Model.LiteralTypeString),
            Typing.parameterIsLazy = False},
          Typing.Parameter {
            Typing.parameterName = (Model.Name "s"),
            Typing.parameterDescription = (Just "the string to operate on"),
            Typing.parameterType = (Model.TypeLiteral Model.LiteralTypeString),
            Typing.parameterIsLazy = False}],
        Typing.termSignatureResult = Typing.Result {
          Typing.resultDescription = Nothing,
          Typing.resultType = (Model.TypeLiteral Model.LiteralTypeString)}},
      Packaging.primitiveDefinitionIsPure = True,
      Packaging.primitiveDefinitionIsTotal = True,
      Packaging.primitiveDefinitionDefaultImplementation = Nothing}

split :: Packaging.PrimitiveDefinition
split =
    Packaging.PrimitiveDefinition {
      Packaging.primitiveDefinitionName = (Model.Name "hydra.core.lib.regex.split"),
      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {
        Packaging.entityMetadataDescription = (Just "Split a string by occurrences of a regex pattern."),
        Packaging.entityMetadataComments = [
          "split(pat, s) returns the list of substrings of s obtained by splitting on every leftmost-longest, non-overlapping match of pat.",
          "Trailing empty splits are host-defined (some engines retain them, some discard them; for portable code, do not rely on the trailing-empty behavior).",
          "Pattern syntax and semantics are Hydra-defined and translingual; see docs/specification/regex.md.",
          "Total; an unparseable pattern yields the single-element list containing s, the same as a well-formed pattern with no match."],
        Packaging.entityMetadataSeeAlso = [],
        Packaging.entityMetadataLifecycle = Nothing,
        Packaging.entityMetadataProvisions = []})),
      Packaging.primitiveDefinitionSignature = Typing.TermSignature {
        Typing.termSignatureTypeParameters = [],
        Typing.termSignatureParameters = [
          Typing.Parameter {
            Typing.parameterName = (Model.Name "pat"),
            Typing.parameterDescription = (Just "the regex pattern to split on"),
            Typing.parameterType = (Model.TypeLiteral Model.LiteralTypeString),
            Typing.parameterIsLazy = False},
          Typing.Parameter {
            Typing.parameterName = (Model.Name "s"),
            Typing.parameterDescription = (Just "the string to split"),
            Typing.parameterType = (Model.TypeLiteral Model.LiteralTypeString),
            Typing.parameterIsLazy = False}],
        Typing.termSignatureResult = Typing.Result {
          Typing.resultDescription = Nothing,
          Typing.resultType = (Model.TypeList (Model.TypeLiteral Model.LiteralTypeString))}},
      Packaging.primitiveDefinitionIsPure = True,
      Packaging.primitiveDefinitionIsTotal = True,
      Packaging.primitiveDefinitionDefaultImplementation = Nothing}