hydra-kernel-0.18.0: src/main/haskell/Hydra/Core/Lib/Optionals.hs

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

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

module Hydra.Core.Lib.Optionals 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

apply :: Packaging.PrimitiveDefinition
apply =
    Packaging.PrimitiveDefinition {
      Packaging.primitiveDefinitionName = (Model.Name "hydra.core.lib.optionals.apply"),
      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {
        Packaging.entityMetadataDescription = (Just "Applicative apply for optionals: combine an optional function and an optional argument."),
        Packaging.entityMetadataComments = [
          "apply(mf, mx) returns given(f x) when mf is given(f) and mx is given(x), and none if either is none.",
          "The applicative apply for optionals; threads a function-in-context with a value-in-context.",
          "Total. Corresponds to Haskell's (<*>) :: Maybe (a -> b) -> Maybe a -> Maybe b."],
        Packaging.entityMetadataSeeAlso = [],
        Packaging.entityMetadataLifecycle = Nothing,
        Packaging.entityMetadataProvisions = []})),
      Packaging.primitiveDefinitionSignature = Typing.TermSignature {
        Typing.termSignatureTypeParameters = [
          Typing.TypeParameter {
            Typing.typeParameterName = (Model.Name "x"),
            Typing.typeParameterConstraints = []},
          Typing.TypeParameter {
            Typing.typeParameterName = (Model.Name "y"),
            Typing.typeParameterConstraints = []}],
        Typing.termSignatureParameters = [
          Typing.Parameter {
            Typing.parameterName = (Model.Name "mf"),
            Typing.parameterDescription = (Just "the optional function"),
            Typing.parameterType = (Model.TypeOptional (Model.TypeFunction (Model.FunctionType {
              Model.functionTypeDomain = (Model.TypeVariable (Model.Name "x")),
              Model.functionTypeCodomain = (Model.TypeVariable (Model.Name "y"))}))),
            Typing.parameterIsLazy = False},
          Typing.Parameter {
            Typing.parameterName = (Model.Name "mx"),
            Typing.parameterDescription = (Just "the optional argument"),
            Typing.parameterType = (Model.TypeOptional (Model.TypeVariable (Model.Name "x"))),
            Typing.parameterIsLazy = False}],
        Typing.termSignatureResult = Typing.Result {
          Typing.resultDescription = Nothing,
          Typing.resultType = (Model.TypeOptional (Model.TypeVariable (Model.Name "y")))}},
      Packaging.primitiveDefinitionIsPure = True,
      Packaging.primitiveDefinitionIsTotal = True,
      Packaging.primitiveDefinitionDefaultImplementation = (Just (Model.TermLambda (Model.Lambda {
        Model.lambdaParameter = (Model.Name "mf"),
        Model.lambdaDomain = Nothing,
        Model.lambdaBody = (Model.TermLambda (Model.Lambda {
          Model.lambdaParameter = (Model.Name "mx"),
          Model.lambdaDomain = Nothing,
          Model.lambdaBody = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermApplication (Model.Application {
              Model.applicationFunction = (Model.TermVariable (Model.Name "hydra.core.lib.optionals.bind")),
              Model.applicationArgument = (Model.TermVariable (Model.Name "mf"))})),
            Model.applicationArgument = (Model.TermLambda (Model.Lambda {
              Model.lambdaParameter = (Model.Name "f"),
              Model.lambdaDomain = Nothing,
              Model.lambdaBody = (Model.TermApplication (Model.Application {
                Model.applicationFunction = (Model.TermApplication (Model.Application {
                  Model.applicationFunction = (Model.TermVariable (Model.Name "hydra.core.lib.optionals.map")),
                  Model.applicationArgument = (Model.TermLambda (Model.Lambda {
                    Model.lambdaParameter = (Model.Name "x"),
                    Model.lambdaDomain = Nothing,
                    Model.lambdaBody = (Model.TermApplication (Model.Application {
                      Model.applicationFunction = (Model.TermVariable (Model.Name "f")),
                      Model.applicationArgument = (Model.TermVariable (Model.Name "x"))}))}))})),
                Model.applicationArgument = (Model.TermVariable (Model.Name "mx"))}))}))}))}))})))}

bind :: Packaging.PrimitiveDefinition
bind =
    Packaging.PrimitiveDefinition {
      Packaging.primitiveDefinitionName = (Model.Name "hydra.core.lib.optionals.bind"),
      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {
        Packaging.entityMetadataDescription = (Just "Monadic bind for optionals."),
        Packaging.entityMetadataComments = [
          "bind(m, f) returns f(x) when m is given(x), and none when m is none.",
          "The monadic bind for optionals; used to chain computations that may be absent.",
          "Total. Corresponds to Haskell's (>>=) :: Maybe a -> (a -> Maybe b) -> Maybe b."],
        Packaging.entityMetadataSeeAlso = [],
        Packaging.entityMetadataLifecycle = Nothing,
        Packaging.entityMetadataProvisions = []})),
      Packaging.primitiveDefinitionSignature = Typing.TermSignature {
        Typing.termSignatureTypeParameters = [
          Typing.TypeParameter {
            Typing.typeParameterName = (Model.Name "x"),
            Typing.typeParameterConstraints = []},
          Typing.TypeParameter {
            Typing.typeParameterName = (Model.Name "y"),
            Typing.typeParameterConstraints = []}],
        Typing.termSignatureParameters = [
          Typing.Parameter {
            Typing.parameterName = (Model.Name "m"),
            Typing.parameterDescription = (Just "the optional value to bind"),
            Typing.parameterType = (Model.TypeOptional (Model.TypeVariable (Model.Name "x"))),
            Typing.parameterIsLazy = False},
          Typing.Parameter {
            Typing.parameterName = (Model.Name "f"),
            Typing.parameterDescription = (Just "the continuation to apply to the contained value"),
            Typing.parameterType = (Model.TypeFunction (Model.FunctionType {
              Model.functionTypeDomain = (Model.TypeVariable (Model.Name "x")),
              Model.functionTypeCodomain = (Model.TypeOptional (Model.TypeVariable (Model.Name "y")))})),
            Typing.parameterIsLazy = False}],
        Typing.termSignatureResult = Typing.Result {
          Typing.resultDescription = Nothing,
          Typing.resultType = (Model.TypeOptional (Model.TypeVariable (Model.Name "y")))}},
      Packaging.primitiveDefinitionIsPure = True,
      Packaging.primitiveDefinitionIsTotal = True,
      Packaging.primitiveDefinitionDefaultImplementation = (Just (Model.TermLambda (Model.Lambda {
        Model.lambdaParameter = (Model.Name "m"),
        Model.lambdaDomain = Nothing,
        Model.lambdaBody = (Model.TermLambda (Model.Lambda {
          Model.lambdaParameter = (Model.Name "f"),
          Model.lambdaDomain = Nothing,
          Model.lambdaBody = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermApplication (Model.Application {
              Model.applicationFunction = (Model.TermApplication (Model.Application {
                Model.applicationFunction = (Model.TermVariable (Model.Name "hydra.core.lib.optionals.match")),
                Model.applicationArgument = (Model.TermVariable (Model.Name "m"))})),
              Model.applicationArgument = (Model.TermOptional Nothing)})),
            Model.applicationArgument = (Model.TermVariable (Model.Name "f"))}))}))})))}

compose :: Packaging.PrimitiveDefinition
compose =
    Packaging.PrimitiveDefinition {
      Packaging.primitiveDefinitionName = (Model.Name "hydra.core.lib.optionals.compose"),
      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {
        Packaging.entityMetadataDescription = (Just "Kleisli composition for optionals."),
        Packaging.entityMetadataComments = [
          "compose(f, g, x) returns the Kleisli composition of f and g applied to x: bind(f(x), g).",
          "If either f or the second stage produces none, the result is none.",
          "Total. Corresponds to Haskell's Kleisli composition for Maybe, (>=>) :: (a -> Maybe b) -> (b -> Maybe c) -> a -> Maybe c."],
        Packaging.entityMetadataSeeAlso = [],
        Packaging.entityMetadataLifecycle = Nothing,
        Packaging.entityMetadataProvisions = []})),
      Packaging.primitiveDefinitionSignature = Typing.TermSignature {
        Typing.termSignatureTypeParameters = [
          Typing.TypeParameter {
            Typing.typeParameterName = (Model.Name "x"),
            Typing.typeParameterConstraints = []},
          Typing.TypeParameter {
            Typing.typeParameterName = (Model.Name "y"),
            Typing.typeParameterConstraints = []},
          Typing.TypeParameter {
            Typing.typeParameterName = (Model.Name "z"),
            Typing.typeParameterConstraints = []}],
        Typing.termSignatureParameters = [
          Typing.Parameter {
            Typing.parameterName = (Model.Name "f"),
            Typing.parameterDescription = (Just "the first Kleisli arrow"),
            Typing.parameterType = (Model.TypeFunction (Model.FunctionType {
              Model.functionTypeDomain = (Model.TypeVariable (Model.Name "x")),
              Model.functionTypeCodomain = (Model.TypeOptional (Model.TypeVariable (Model.Name "y")))})),
            Typing.parameterIsLazy = False},
          Typing.Parameter {
            Typing.parameterName = (Model.Name "g"),
            Typing.parameterDescription = (Just "the second Kleisli arrow"),
            Typing.parameterType = (Model.TypeFunction (Model.FunctionType {
              Model.functionTypeDomain = (Model.TypeVariable (Model.Name "y")),
              Model.functionTypeCodomain = (Model.TypeOptional (Model.TypeVariable (Model.Name "z")))})),
            Typing.parameterIsLazy = False},
          Typing.Parameter {
            Typing.parameterName = (Model.Name "x"),
            Typing.parameterDescription = (Just "the value to apply the composition to"),
            Typing.parameterType = (Model.TypeVariable (Model.Name "x")),
            Typing.parameterIsLazy = False}],
        Typing.termSignatureResult = Typing.Result {
          Typing.resultDescription = Nothing,
          Typing.resultType = (Model.TypeOptional (Model.TypeVariable (Model.Name "z")))}},
      Packaging.primitiveDefinitionIsPure = True,
      Packaging.primitiveDefinitionIsTotal = True,
      Packaging.primitiveDefinitionDefaultImplementation = (Just (Model.TermLambda (Model.Lambda {
        Model.lambdaParameter = (Model.Name "f"),
        Model.lambdaDomain = Nothing,
        Model.lambdaBody = (Model.TermLambda (Model.Lambda {
          Model.lambdaParameter = (Model.Name "g"),
          Model.lambdaDomain = Nothing,
          Model.lambdaBody = (Model.TermLambda (Model.Lambda {
            Model.lambdaParameter = (Model.Name "x"),
            Model.lambdaDomain = Nothing,
            Model.lambdaBody = (Model.TermApplication (Model.Application {
              Model.applicationFunction = (Model.TermApplication (Model.Application {
                Model.applicationFunction = (Model.TermVariable (Model.Name "hydra.core.lib.optionals.bind")),
                Model.applicationArgument = (Model.TermApplication (Model.Application {
                  Model.applicationFunction = (Model.TermVariable (Model.Name "f")),
                  Model.applicationArgument = (Model.TermVariable (Model.Name "x"))}))})),
              Model.applicationArgument = (Model.TermVariable (Model.Name "g"))}))}))}))})))}

foldList :: Packaging.PrimitiveDefinition
foldList =
    Packaging.PrimitiveDefinition {
      Packaging.primitiveDefinitionName = (Model.Name "hydra.core.lib.optionals.foldList"),
      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {
        Packaging.entityMetadataDescription = (Just "Left-fold over a list with an optional-returning function, short-circuiting on none."),
        Packaging.entityMetadataComments = [
          "foldList(f, acc, xs) folds f over xs from the left, iterating while each application yields given, and returns none as soon as any step yields none. If every element is processed, the result is given of the final accumulator.",
          "foldList(f, acc, xs) is lists.foldl(\\m y -> bind(m, \\x -> f(x, y)), given(acc), xs); this defining equation is the specification, and the default implementation.",
          "Total. Corresponds to a short-circuiting foldM specialised to Maybe."],
        Packaging.entityMetadataSeeAlso = [],
        Packaging.entityMetadataLifecycle = Nothing,
        Packaging.entityMetadataProvisions = []})),
      Packaging.primitiveDefinitionSignature = Typing.TermSignature {
        Typing.termSignatureTypeParameters = [
          Typing.TypeParameter {
            Typing.typeParameterName = (Model.Name "x"),
            Typing.typeParameterConstraints = []},
          Typing.TypeParameter {
            Typing.typeParameterName = (Model.Name "y"),
            Typing.typeParameterConstraints = []}],
        Typing.termSignatureParameters = [
          Typing.Parameter {
            Typing.parameterName = (Model.Name "f"),
            Typing.parameterDescription = (Just "the optional-returning step function"),
            Typing.parameterType = (Model.TypeFunction (Model.FunctionType {
              Model.functionTypeDomain = (Model.TypeVariable (Model.Name "x")),
              Model.functionTypeCodomain = (Model.TypeFunction (Model.FunctionType {
                Model.functionTypeDomain = (Model.TypeVariable (Model.Name "y")),
                Model.functionTypeCodomain = (Model.TypeOptional (Model.TypeVariable (Model.Name "x")))}))})),
            Typing.parameterIsLazy = False},
          Typing.Parameter {
            Typing.parameterName = (Model.Name "acc"),
            Typing.parameterDescription = (Just "the initial accumulator"),
            Typing.parameterType = (Model.TypeVariable (Model.Name "x")),
            Typing.parameterIsLazy = False},
          Typing.Parameter {
            Typing.parameterName = (Model.Name "xs"),
            Typing.parameterDescription = (Just "the list to fold over"),
            Typing.parameterType = (Model.TypeList (Model.TypeVariable (Model.Name "y"))),
            Typing.parameterIsLazy = False}],
        Typing.termSignatureResult = Typing.Result {
          Typing.resultDescription = Nothing,
          Typing.resultType = (Model.TypeOptional (Model.TypeVariable (Model.Name "x")))}},
      Packaging.primitiveDefinitionIsPure = True,
      Packaging.primitiveDefinitionIsTotal = True,
      Packaging.primitiveDefinitionDefaultImplementation = (Just (Model.TermLambda (Model.Lambda {
        Model.lambdaParameter = (Model.Name "f"),
        Model.lambdaDomain = Nothing,
        Model.lambdaBody = (Model.TermLambda (Model.Lambda {
          Model.lambdaParameter = (Model.Name "acc"),
          Model.lambdaDomain = Nothing,
          Model.lambdaBody = (Model.TermLambda (Model.Lambda {
            Model.lambdaParameter = (Model.Name "xs"),
            Model.lambdaDomain = Nothing,
            Model.lambdaBody = (Model.TermApplication (Model.Application {
              Model.applicationFunction = (Model.TermApplication (Model.Application {
                Model.applicationFunction = (Model.TermApplication (Model.Application {
                  Model.applicationFunction = (Model.TermVariable (Model.Name "hydra.core.lib.lists.foldl")),
                  Model.applicationArgument = (Model.TermLambda (Model.Lambda {
                    Model.lambdaParameter = (Model.Name "m"),
                    Model.lambdaDomain = Nothing,
                    Model.lambdaBody = (Model.TermLambda (Model.Lambda {
                      Model.lambdaParameter = (Model.Name "y"),
                      Model.lambdaDomain = Nothing,
                      Model.lambdaBody = (Model.TermApplication (Model.Application {
                        Model.applicationFunction = (Model.TermApplication (Model.Application {
                          Model.applicationFunction = (Model.TermVariable (Model.Name "hydra.core.lib.optionals.bind")),
                          Model.applicationArgument = (Model.TermVariable (Model.Name "m"))})),
                        Model.applicationArgument = (Model.TermLambda (Model.Lambda {
                          Model.lambdaParameter = (Model.Name "x"),
                          Model.lambdaDomain = Nothing,
                          Model.lambdaBody = (Model.TermApplication (Model.Application {
                            Model.applicationFunction = (Model.TermApplication (Model.Application {
                              Model.applicationFunction = (Model.TermVariable (Model.Name "f")),
                              Model.applicationArgument = (Model.TermVariable (Model.Name "x"))})),
                            Model.applicationArgument = (Model.TermVariable (Model.Name "y"))}))}))}))}))}))})),
                Model.applicationArgument = (Model.TermApplication (Model.Application {
                  Model.applicationFunction = (Model.TermVariable (Model.Name "hydra.core.lib.optionals.given")),
                  Model.applicationArgument = (Model.TermVariable (Model.Name "acc"))}))})),
              Model.applicationArgument = (Model.TermVariable (Model.Name "xs"))}))}))}))})))}

given :: Packaging.PrimitiveDefinition
given =
    Packaging.PrimitiveDefinition {
      Packaging.primitiveDefinitionName = (Model.Name "hydra.core.lib.optionals.given"),
      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {
        Packaging.entityMetadataDescription = (Just "Wrap a value in given."),
        Packaging.entityMetadataComments = [
          "given(x) is the optional value containing x.",
          "The constructor for the present case of an optional value.",
          "Total. Corresponds to Haskell's Just :: a -> Maybe a."],
        Packaging.entityMetadataSeeAlso = [],
        Packaging.entityMetadataLifecycle = Nothing,
        Packaging.entityMetadataProvisions = []})),
      Packaging.primitiveDefinitionSignature = Typing.TermSignature {
        Typing.termSignatureTypeParameters = [
          Typing.TypeParameter {
            Typing.typeParameterName = (Model.Name "x"),
            Typing.typeParameterConstraints = []}],
        Typing.termSignatureParameters = [
          Typing.Parameter {
            Typing.parameterName = (Model.Name "x"),
            Typing.parameterDescription = (Just "the value to wrap in given"),
            Typing.parameterType = (Model.TypeVariable (Model.Name "x")),
            Typing.parameterIsLazy = False}],
        Typing.termSignatureResult = Typing.Result {
          Typing.resultDescription = Nothing,
          Typing.resultType = (Model.TypeOptional (Model.TypeVariable (Model.Name "x")))}},
      Packaging.primitiveDefinitionIsPure = True,
      Packaging.primitiveDefinitionIsTotal = True,
      Packaging.primitiveDefinitionDefaultImplementation = Nothing}

givens :: Packaging.PrimitiveDefinition
givens =
    Packaging.PrimitiveDefinition {
      Packaging.primitiveDefinitionName = (Model.Name "hydra.core.lib.optionals.givens"),
      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {
        Packaging.entityMetadataDescription = (Just "Concatenate optionals, keeping only the present values."),
        Packaging.entityMetadataComments = [
          "givens(xs) returns the list of contained values from given elements of xs, in original order; none elements are discarded.",
          "Total. Corresponds to Haskell's Data.Maybe.catMaybes :: [Maybe a] -> [a]."],
        Packaging.entityMetadataSeeAlso = [],
        Packaging.entityMetadataLifecycle = Nothing,
        Packaging.entityMetadataProvisions = []})),
      Packaging.primitiveDefinitionSignature = Typing.TermSignature {
        Typing.termSignatureTypeParameters = [
          Typing.TypeParameter {
            Typing.typeParameterName = (Model.Name "x"),
            Typing.typeParameterConstraints = []}],
        Typing.termSignatureParameters = [
          Typing.Parameter {
            Typing.parameterName = (Model.Name "xs"),
            Typing.parameterDescription = (Just "the list of optionals to concatenate"),
            Typing.parameterType = (Model.TypeList (Model.TypeOptional (Model.TypeVariable (Model.Name "x")))),
            Typing.parameterIsLazy = False}],
        Typing.termSignatureResult = Typing.Result {
          Typing.resultDescription = Nothing,
          Typing.resultType = (Model.TypeList (Model.TypeVariable (Model.Name "x")))}},
      Packaging.primitiveDefinitionIsPure = True,
      Packaging.primitiveDefinitionIsTotal = True,
      Packaging.primitiveDefinitionDefaultImplementation = (Just (Model.TermLambda (Model.Lambda {
        Model.lambdaParameter = (Model.Name "xs"),
        Model.lambdaDomain = Nothing,
        Model.lambdaBody = (Model.TermApplication (Model.Application {
          Model.applicationFunction = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermApplication (Model.Application {
              Model.applicationFunction = (Model.TermVariable (Model.Name "hydra.core.lib.lists.foldr")),
              Model.applicationArgument = (Model.TermLambda (Model.Lambda {
                Model.lambdaParameter = (Model.Name "m"),
                Model.lambdaDomain = Nothing,
                Model.lambdaBody = (Model.TermLambda (Model.Lambda {
                  Model.lambdaParameter = (Model.Name "acc"),
                  Model.lambdaDomain = Nothing,
                  Model.lambdaBody = (Model.TermApplication (Model.Application {
                    Model.applicationFunction = (Model.TermApplication (Model.Application {
                      Model.applicationFunction = (Model.TermApplication (Model.Application {
                        Model.applicationFunction = (Model.TermVariable (Model.Name "hydra.core.lib.optionals.match")),
                        Model.applicationArgument = (Model.TermVariable (Model.Name "m"))})),
                      Model.applicationArgument = (Model.TermVariable (Model.Name "acc"))})),
                    Model.applicationArgument = (Model.TermLambda (Model.Lambda {
                      Model.lambdaParameter = (Model.Name "v"),
                      Model.lambdaDomain = Nothing,
                      Model.lambdaBody = (Model.TermApplication (Model.Application {
                        Model.applicationFunction = (Model.TermApplication (Model.Application {
                          Model.applicationFunction = (Model.TermVariable (Model.Name "hydra.core.lib.lists.cons")),
                          Model.applicationArgument = (Model.TermVariable (Model.Name "v"))})),
                        Model.applicationArgument = (Model.TermVariable (Model.Name "acc"))}))}))}))}))}))})),
            Model.applicationArgument = (Model.TermList [])})),
          Model.applicationArgument = (Model.TermVariable (Model.Name "xs"))}))})))}

isGiven :: Packaging.PrimitiveDefinition
isGiven =
    Packaging.PrimitiveDefinition {
      Packaging.primitiveDefinitionName = (Model.Name "hydra.core.lib.optionals.isGiven"),
      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {
        Packaging.entityMetadataDescription = (Just "Test whether an optional is present (given)."),
        Packaging.entityMetadataComments = [
          "isGiven(m) returns true iff m is a given variant.",
          "Total. Corresponds to Haskell's Data.Maybe.isJust :: Maybe a -> Bool."],
        Packaging.entityMetadataSeeAlso = [],
        Packaging.entityMetadataLifecycle = Nothing,
        Packaging.entityMetadataProvisions = []})),
      Packaging.primitiveDefinitionSignature = Typing.TermSignature {
        Typing.termSignatureTypeParameters = [
          Typing.TypeParameter {
            Typing.typeParameterName = (Model.Name "x"),
            Typing.typeParameterConstraints = []}],
        Typing.termSignatureParameters = [
          Typing.Parameter {
            Typing.parameterName = (Model.Name "m"),
            Typing.parameterDescription = (Just "the optional to test"),
            Typing.parameterType = (Model.TypeOptional (Model.TypeVariable (Model.Name "x"))),
            Typing.parameterIsLazy = False}],
        Typing.termSignatureResult = Typing.Result {
          Typing.resultDescription = Nothing,
          Typing.resultType = (Model.TypeLiteral Model.LiteralTypeBoolean)}},
      Packaging.primitiveDefinitionIsPure = True,
      Packaging.primitiveDefinitionIsTotal = True,
      Packaging.primitiveDefinitionDefaultImplementation = (Just (Model.TermLambda (Model.Lambda {
        Model.lambdaParameter = (Model.Name "m"),
        Model.lambdaDomain = Nothing,
        Model.lambdaBody = (Model.TermApplication (Model.Application {
          Model.applicationFunction = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermApplication (Model.Application {
              Model.applicationFunction = (Model.TermVariable (Model.Name "hydra.core.lib.optionals.match")),
              Model.applicationArgument = (Model.TermVariable (Model.Name "m"))})),
            Model.applicationArgument = (Model.TermLiteral (Model.LiteralBoolean False))})),
          Model.applicationArgument = (Model.TermLambda (Model.Lambda {
            Model.lambdaParameter = (Model.Name "_"),
            Model.lambdaDomain = Nothing,
            Model.lambdaBody = (Model.TermLiteral (Model.LiteralBoolean True))}))}))})))}

isNone :: Packaging.PrimitiveDefinition
isNone =
    Packaging.PrimitiveDefinition {
      Packaging.primitiveDefinitionName = (Model.Name "hydra.core.lib.optionals.isNone"),
      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {
        Packaging.entityMetadataDescription = (Just "Test whether an optional is absent (none)."),
        Packaging.entityMetadataComments = [
          "isNone(m) returns true iff m is the none variant.",
          "Total. Corresponds to Haskell's Data.Maybe.isNothing :: Maybe a -> Bool."],
        Packaging.entityMetadataSeeAlso = [],
        Packaging.entityMetadataLifecycle = Nothing,
        Packaging.entityMetadataProvisions = []})),
      Packaging.primitiveDefinitionSignature = Typing.TermSignature {
        Typing.termSignatureTypeParameters = [
          Typing.TypeParameter {
            Typing.typeParameterName = (Model.Name "x"),
            Typing.typeParameterConstraints = []}],
        Typing.termSignatureParameters = [
          Typing.Parameter {
            Typing.parameterName = (Model.Name "m"),
            Typing.parameterDescription = (Just "the optional to test"),
            Typing.parameterType = (Model.TypeOptional (Model.TypeVariable (Model.Name "x"))),
            Typing.parameterIsLazy = False}],
        Typing.termSignatureResult = Typing.Result {
          Typing.resultDescription = Nothing,
          Typing.resultType = (Model.TypeLiteral Model.LiteralTypeBoolean)}},
      Packaging.primitiveDefinitionIsPure = True,
      Packaging.primitiveDefinitionIsTotal = True,
      Packaging.primitiveDefinitionDefaultImplementation = (Just (Model.TermLambda (Model.Lambda {
        Model.lambdaParameter = (Model.Name "m"),
        Model.lambdaDomain = Nothing,
        Model.lambdaBody = (Model.TermApplication (Model.Application {
          Model.applicationFunction = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermApplication (Model.Application {
              Model.applicationFunction = (Model.TermVariable (Model.Name "hydra.core.lib.optionals.match")),
              Model.applicationArgument = (Model.TermVariable (Model.Name "m"))})),
            Model.applicationArgument = (Model.TermLiteral (Model.LiteralBoolean True))})),
          Model.applicationArgument = (Model.TermLambda (Model.Lambda {
            Model.lambdaParameter = (Model.Name "_"),
            Model.lambdaDomain = Nothing,
            Model.lambdaBody = (Model.TermLiteral (Model.LiteralBoolean False))}))}))})))}

map :: Packaging.PrimitiveDefinition
map =
    Packaging.PrimitiveDefinition {
      Packaging.primitiveDefinitionName = (Model.Name "hydra.core.lib.optionals.map"),
      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {
        Packaging.entityMetadataDescription = (Just "Map a function over an optional."),
        Packaging.entityMetadataComments = [
          "map(f, m) returns given(f x) when m is given(x), and none when m is none.",
          "The functor instance for optionals.",
          "Total. Corresponds to Haskell's fmap :: (a -> b) -> Maybe a -> Maybe b."],
        Packaging.entityMetadataSeeAlso = [],
        Packaging.entityMetadataLifecycle = Nothing,
        Packaging.entityMetadataProvisions = []})),
      Packaging.primitiveDefinitionSignature = Typing.TermSignature {
        Typing.termSignatureTypeParameters = [
          Typing.TypeParameter {
            Typing.typeParameterName = (Model.Name "x"),
            Typing.typeParameterConstraints = []},
          Typing.TypeParameter {
            Typing.typeParameterName = (Model.Name "y"),
            Typing.typeParameterConstraints = []}],
        Typing.termSignatureParameters = [
          Typing.Parameter {
            Typing.parameterName = (Model.Name "f"),
            Typing.parameterDescription = (Just "the function to apply to the contained value"),
            Typing.parameterType = (Model.TypeFunction (Model.FunctionType {
              Model.functionTypeDomain = (Model.TypeVariable (Model.Name "x")),
              Model.functionTypeCodomain = (Model.TypeVariable (Model.Name "y"))})),
            Typing.parameterIsLazy = False},
          Typing.Parameter {
            Typing.parameterName = (Model.Name "m"),
            Typing.parameterDescription = (Just "the optional to map over"),
            Typing.parameterType = (Model.TypeOptional (Model.TypeVariable (Model.Name "x"))),
            Typing.parameterIsLazy = False}],
        Typing.termSignatureResult = Typing.Result {
          Typing.resultDescription = Nothing,
          Typing.resultType = (Model.TypeOptional (Model.TypeVariable (Model.Name "y")))}},
      Packaging.primitiveDefinitionIsPure = True,
      Packaging.primitiveDefinitionIsTotal = True,
      Packaging.primitiveDefinitionDefaultImplementation = (Just (Model.TermLambda (Model.Lambda {
        Model.lambdaParameter = (Model.Name "f"),
        Model.lambdaDomain = Nothing,
        Model.lambdaBody = (Model.TermLambda (Model.Lambda {
          Model.lambdaParameter = (Model.Name "m"),
          Model.lambdaDomain = Nothing,
          Model.lambdaBody = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermApplication (Model.Application {
              Model.applicationFunction = (Model.TermApplication (Model.Application {
                Model.applicationFunction = (Model.TermVariable (Model.Name "hydra.core.lib.optionals.match")),
                Model.applicationArgument = (Model.TermVariable (Model.Name "m"))})),
              Model.applicationArgument = (Model.TermOptional Nothing)})),
            Model.applicationArgument = (Model.TermLambda (Model.Lambda {
              Model.lambdaParameter = (Model.Name "x"),
              Model.lambdaDomain = Nothing,
              Model.lambdaBody = (Model.TermOptional (Just (Model.TermApplication (Model.Application {
                Model.applicationFunction = (Model.TermVariable (Model.Name "f")),
                Model.applicationArgument = (Model.TermVariable (Model.Name "x"))}))))}))}))}))})))}

mapList :: Packaging.PrimitiveDefinition
mapList =
    Packaging.PrimitiveDefinition {
      Packaging.primitiveDefinitionName = (Model.Name "hydra.core.lib.optionals.mapList"),
      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {
        Packaging.entityMetadataDescription = (Just "Traverse a list in the optional monad."),
        Packaging.entityMetadataComments = [
          "mapList(f, xs) applies f to each element of xs. If every application yields given, the result is given of the list of contained values, in their original order. The result is none as soon as any application yields none.",
          "Total. Corresponds to Haskell's traverse :: (a -> Maybe b) -> [a] -> Maybe [b]."],
        Packaging.entityMetadataSeeAlso = [],
        Packaging.entityMetadataLifecycle = Nothing,
        Packaging.entityMetadataProvisions = []})),
      Packaging.primitiveDefinitionSignature = Typing.TermSignature {
        Typing.termSignatureTypeParameters = [
          Typing.TypeParameter {
            Typing.typeParameterName = (Model.Name "x"),
            Typing.typeParameterConstraints = []},
          Typing.TypeParameter {
            Typing.typeParameterName = (Model.Name "y"),
            Typing.typeParameterConstraints = []}],
        Typing.termSignatureParameters = [
          Typing.Parameter {
            Typing.parameterName = (Model.Name "f"),
            Typing.parameterDescription = (Just "the optional-returning function to apply to each element"),
            Typing.parameterType = (Model.TypeFunction (Model.FunctionType {
              Model.functionTypeDomain = (Model.TypeVariable (Model.Name "x")),
              Model.functionTypeCodomain = (Model.TypeOptional (Model.TypeVariable (Model.Name "y")))})),
            Typing.parameterIsLazy = False},
          Typing.Parameter {
            Typing.parameterName = (Model.Name "xs"),
            Typing.parameterDescription = (Just "the list to traverse"),
            Typing.parameterType = (Model.TypeList (Model.TypeVariable (Model.Name "x"))),
            Typing.parameterIsLazy = False}],
        Typing.termSignatureResult = Typing.Result {
          Typing.resultDescription = Nothing,
          Typing.resultType = (Model.TypeOptional (Model.TypeList (Model.TypeVariable (Model.Name "y"))))}},
      Packaging.primitiveDefinitionIsPure = True,
      Packaging.primitiveDefinitionIsTotal = True,
      Packaging.primitiveDefinitionDefaultImplementation = (Just (Model.TermLambda (Model.Lambda {
        Model.lambdaParameter = (Model.Name "f"),
        Model.lambdaDomain = Nothing,
        Model.lambdaBody = (Model.TermLambda (Model.Lambda {
          Model.lambdaParameter = (Model.Name "xs"),
          Model.lambdaDomain = Nothing,
          Model.lambdaBody = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermApplication (Model.Application {
              Model.applicationFunction = (Model.TermApplication (Model.Application {
                Model.applicationFunction = (Model.TermVariable (Model.Name "hydra.core.lib.lists.foldr")),
                Model.applicationArgument = (Model.TermLambda (Model.Lambda {
                  Model.lambdaParameter = (Model.Name "x"),
                  Model.lambdaDomain = Nothing,
                  Model.lambdaBody = (Model.TermLambda (Model.Lambda {
                    Model.lambdaParameter = (Model.Name "acc"),
                    Model.lambdaDomain = Nothing,
                    Model.lambdaBody = (Model.TermApplication (Model.Application {
                      Model.applicationFunction = (Model.TermApplication (Model.Application {
                        Model.applicationFunction = (Model.TermVariable (Model.Name "hydra.core.lib.optionals.bind")),
                        Model.applicationArgument = (Model.TermApplication (Model.Application {
                          Model.applicationFunction = (Model.TermVariable (Model.Name "f")),
                          Model.applicationArgument = (Model.TermVariable (Model.Name "x"))}))})),
                      Model.applicationArgument = (Model.TermLambda (Model.Lambda {
                        Model.lambdaParameter = (Model.Name "y"),
                        Model.lambdaDomain = Nothing,
                        Model.lambdaBody = (Model.TermApplication (Model.Application {
                          Model.applicationFunction = (Model.TermApplication (Model.Application {
                            Model.applicationFunction = (Model.TermVariable (Model.Name "hydra.core.lib.optionals.map")),
                            Model.applicationArgument = (Model.TermLambda (Model.Lambda {
                              Model.lambdaParameter = (Model.Name "ys"),
                              Model.lambdaDomain = Nothing,
                              Model.lambdaBody = (Model.TermApplication (Model.Application {
                                Model.applicationFunction = (Model.TermApplication (Model.Application {
                                  Model.applicationFunction = (Model.TermVariable (Model.Name "hydra.core.lib.lists.cons")),
                                  Model.applicationArgument = (Model.TermVariable (Model.Name "y"))})),
                                Model.applicationArgument = (Model.TermVariable (Model.Name "ys"))}))}))})),
                          Model.applicationArgument = (Model.TermVariable (Model.Name "acc"))}))}))}))}))}))})),
              Model.applicationArgument = (Model.TermApplication (Model.Application {
                Model.applicationFunction = (Model.TermVariable (Model.Name "hydra.core.lib.optionals.given")),
                Model.applicationArgument = (Model.TermList [])}))})),
            Model.applicationArgument = (Model.TermVariable (Model.Name "xs"))}))}))})))}

mapOptional :: Packaging.PrimitiveDefinition
mapOptional =
    Packaging.PrimitiveDefinition {
      Packaging.primitiveDefinitionName = (Model.Name "hydra.core.lib.optionals.mapOptional"),
      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {
        Packaging.entityMetadataDescription = (Just "Map a partial function over a list, keeping only the present results."),
        Packaging.entityMetadataComments = [
          "mapOptional(f, xs) applies f to each element of xs and returns the list of contained values from given results in original order; none results are discarded.",
          "Total. Corresponds to Haskell's Data.Maybe.mapMaybe :: (a -> Maybe b) -> [a] -> [b].",
          "Deprecated since 0.18. Use: hydra.core.lib.lists.mapGivens."],
        Packaging.entityMetadataSeeAlso = [],
        Packaging.entityMetadataLifecycle = (Just (Packaging.LifecycleInfo {
          Packaging.lifecycleInfoAvailableSince = Nothing,
          Packaging.lifecycleInfoDeprecatedSince = (Just (Packaging.Version "0.18"))})),
        Packaging.entityMetadataProvisions = []})),
      Packaging.primitiveDefinitionSignature = Typing.TermSignature {
        Typing.termSignatureTypeParameters = [
          Typing.TypeParameter {
            Typing.typeParameterName = (Model.Name "x"),
            Typing.typeParameterConstraints = []},
          Typing.TypeParameter {
            Typing.typeParameterName = (Model.Name "y"),
            Typing.typeParameterConstraints = []}],
        Typing.termSignatureParameters = [
          Typing.Parameter {
            Typing.parameterName = (Model.Name "f"),
            Typing.parameterDescription = (Just "the partial function to apply to each element"),
            Typing.parameterType = (Model.TypeFunction (Model.FunctionType {
              Model.functionTypeDomain = (Model.TypeVariable (Model.Name "x")),
              Model.functionTypeCodomain = (Model.TypeOptional (Model.TypeVariable (Model.Name "y")))})),
            Typing.parameterIsLazy = False},
          Typing.Parameter {
            Typing.parameterName = (Model.Name "xs"),
            Typing.parameterDescription = (Just "the list to map over"),
            Typing.parameterType = (Model.TypeList (Model.TypeVariable (Model.Name "x"))),
            Typing.parameterIsLazy = False}],
        Typing.termSignatureResult = Typing.Result {
          Typing.resultDescription = Nothing,
          Typing.resultType = (Model.TypeList (Model.TypeVariable (Model.Name "y")))}},
      Packaging.primitiveDefinitionIsPure = True,
      Packaging.primitiveDefinitionIsTotal = True,
      Packaging.primitiveDefinitionDefaultImplementation = (Just (Model.TermLambda (Model.Lambda {
        Model.lambdaParameter = (Model.Name "f"),
        Model.lambdaDomain = Nothing,
        Model.lambdaBody = (Model.TermLambda (Model.Lambda {
          Model.lambdaParameter = (Model.Name "xs"),
          Model.lambdaDomain = Nothing,
          Model.lambdaBody = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermVariable (Model.Name "hydra.core.lib.optionals.givens")),
            Model.applicationArgument = (Model.TermApplication (Model.Application {
              Model.applicationFunction = (Model.TermApplication (Model.Application {
                Model.applicationFunction = (Model.TermVariable (Model.Name "hydra.core.lib.lists.map")),
                Model.applicationArgument = (Model.TermVariable (Model.Name "f"))})),
              Model.applicationArgument = (Model.TermVariable (Model.Name "xs"))}))}))}))})))}

mapSet :: Packaging.PrimitiveDefinition
mapSet =
    Packaging.PrimitiveDefinition {
      Packaging.primitiveDefinitionName = (Model.Name "hydra.core.lib.optionals.mapSet"),
      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {
        Packaging.entityMetadataDescription = (Just "Traverse a set in the optional monad."),
        Packaging.entityMetadataComments = [
          "mapSet(f, s) applies f to each element of s. If every application yields given, the result is given of the set of contained values, deduplicated by the result type's ordering. The result is none as soon as any application yields none.",
          "Requires 'ordering' constraints on both element types (the set type contract).",
          "Total. Corresponds to a traverse-style operation specialised to Set in the Maybe monad."],
        Packaging.entityMetadataSeeAlso = [],
        Packaging.entityMetadataLifecycle = Nothing,
        Packaging.entityMetadataProvisions = []})),
      Packaging.primitiveDefinitionSignature = Typing.TermSignature {
        Typing.termSignatureTypeParameters = [
          Typing.TypeParameter {
            Typing.typeParameterName = (Model.Name "x"),
            Typing.typeParameterConstraints = [
              Model.TypeClassConstraintSimple (Model.Name "ordering")]},
          Typing.TypeParameter {
            Typing.typeParameterName = (Model.Name "y"),
            Typing.typeParameterConstraints = [
              Model.TypeClassConstraintSimple (Model.Name "ordering")]}],
        Typing.termSignatureParameters = [
          Typing.Parameter {
            Typing.parameterName = (Model.Name "f"),
            Typing.parameterDescription = (Just "the optional-returning function to apply to each element"),
            Typing.parameterType = (Model.TypeFunction (Model.FunctionType {
              Model.functionTypeDomain = (Model.TypeVariable (Model.Name "x")),
              Model.functionTypeCodomain = (Model.TypeOptional (Model.TypeVariable (Model.Name "y")))})),
            Typing.parameterIsLazy = False},
          Typing.Parameter {
            Typing.parameterName = (Model.Name "s"),
            Typing.parameterDescription = (Just "the set to traverse"),
            Typing.parameterType = (Model.TypeSet (Model.TypeVariable (Model.Name "x"))),
            Typing.parameterIsLazy = False}],
        Typing.termSignatureResult = Typing.Result {
          Typing.resultDescription = Nothing,
          Typing.resultType = (Model.TypeOptional (Model.TypeSet (Model.TypeVariable (Model.Name "y"))))}},
      Packaging.primitiveDefinitionIsPure = True,
      Packaging.primitiveDefinitionIsTotal = True,
      Packaging.primitiveDefinitionDefaultImplementation = (Just (Model.TermLambda (Model.Lambda {
        Model.lambdaParameter = (Model.Name "f"),
        Model.lambdaDomain = Nothing,
        Model.lambdaBody = (Model.TermLambda (Model.Lambda {
          Model.lambdaParameter = (Model.Name "s"),
          Model.lambdaDomain = Nothing,
          Model.lambdaBody = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermApplication (Model.Application {
              Model.applicationFunction = (Model.TermVariable (Model.Name "hydra.core.lib.optionals.map")),
              Model.applicationArgument = (Model.TermLambda (Model.Lambda {
                Model.lambdaParameter = (Model.Name "ys"),
                Model.lambdaDomain = Nothing,
                Model.lambdaBody = (Model.TermApplication (Model.Application {
                  Model.applicationFunction = (Model.TermVariable (Model.Name "hydra.core.lib.sets.fromList")),
                  Model.applicationArgument = (Model.TermVariable (Model.Name "ys"))}))}))})),
            Model.applicationArgument = (Model.TermApplication (Model.Application {
              Model.applicationFunction = (Model.TermApplication (Model.Application {
                Model.applicationFunction = (Model.TermApplication (Model.Application {
                  Model.applicationFunction = (Model.TermVariable (Model.Name "hydra.core.lib.lists.foldr")),
                  Model.applicationArgument = (Model.TermLambda (Model.Lambda {
                    Model.lambdaParameter = (Model.Name "x"),
                    Model.lambdaDomain = Nothing,
                    Model.lambdaBody = (Model.TermLambda (Model.Lambda {
                      Model.lambdaParameter = (Model.Name "acc"),
                      Model.lambdaDomain = Nothing,
                      Model.lambdaBody = (Model.TermApplication (Model.Application {
                        Model.applicationFunction = (Model.TermApplication (Model.Application {
                          Model.applicationFunction = (Model.TermVariable (Model.Name "hydra.core.lib.optionals.bind")),
                          Model.applicationArgument = (Model.TermApplication (Model.Application {
                            Model.applicationFunction = (Model.TermVariable (Model.Name "f")),
                            Model.applicationArgument = (Model.TermVariable (Model.Name "x"))}))})),
                        Model.applicationArgument = (Model.TermLambda (Model.Lambda {
                          Model.lambdaParameter = (Model.Name "y"),
                          Model.lambdaDomain = Nothing,
                          Model.lambdaBody = (Model.TermApplication (Model.Application {
                            Model.applicationFunction = (Model.TermApplication (Model.Application {
                              Model.applicationFunction = (Model.TermVariable (Model.Name "hydra.core.lib.optionals.map")),
                              Model.applicationArgument = (Model.TermLambda (Model.Lambda {
                                Model.lambdaParameter = (Model.Name "ys"),
                                Model.lambdaDomain = Nothing,
                                Model.lambdaBody = (Model.TermApplication (Model.Application {
                                  Model.applicationFunction = (Model.TermApplication (Model.Application {
                                    Model.applicationFunction = (Model.TermVariable (Model.Name "hydra.core.lib.lists.cons")),
                                    Model.applicationArgument = (Model.TermVariable (Model.Name "y"))})),
                                  Model.applicationArgument = (Model.TermVariable (Model.Name "ys"))}))}))})),
                            Model.applicationArgument = (Model.TermVariable (Model.Name "acc"))}))}))}))}))}))})),
                Model.applicationArgument = (Model.TermApplication (Model.Application {
                  Model.applicationFunction = (Model.TermVariable (Model.Name "hydra.core.lib.optionals.given")),
                  Model.applicationArgument = (Model.TermList [])}))})),
              Model.applicationArgument = (Model.TermApplication (Model.Application {
                Model.applicationFunction = (Model.TermVariable (Model.Name "hydra.core.lib.sets.toList")),
                Model.applicationArgument = (Model.TermVariable (Model.Name "s"))}))}))}))}))})))}

match :: Packaging.PrimitiveDefinition
match =
    Packaging.PrimitiveDefinition {
      Packaging.primitiveDefinitionName = (Model.Name "hydra.core.lib.optionals.match"),
      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {
        Packaging.entityMetadataDescription = (Just "The fundamental eliminator for the optional type, scrutinee-first."),
        Packaging.entityMetadataComments = [
          "match(m, def, f) returns f(x) when m is given(x), and def when m is none.",
          "The fundamental eliminator for the optional type; every other primitive in this namespace can be derived from it. The optional value is the first argument, matching the convention for case-statement-like elimination.",
          "Total. Argument order is (m, def, f) rather than Haskell's maybe :: (def, f, m)."],
        Packaging.entityMetadataSeeAlso = [],
        Packaging.entityMetadataLifecycle = Nothing,
        Packaging.entityMetadataProvisions = []})),
      Packaging.primitiveDefinitionSignature = Typing.TermSignature {
        Typing.termSignatureTypeParameters = [
          Typing.TypeParameter {
            Typing.typeParameterName = (Model.Name "x"),
            Typing.typeParameterConstraints = []},
          Typing.TypeParameter {
            Typing.typeParameterName = (Model.Name "y"),
            Typing.typeParameterConstraints = []}],
        Typing.termSignatureParameters = [
          Typing.Parameter {
            Typing.parameterName = (Model.Name "m"),
            Typing.parameterDescription = (Just "the optional value to eliminate"),
            Typing.parameterType = (Model.TypeOptional (Model.TypeVariable (Model.Name "x"))),
            Typing.parameterIsLazy = False},
          Typing.Parameter {
            Typing.parameterName = (Model.Name "def"),
            Typing.parameterDescription = (Just "the value to return when the optional is none"),
            Typing.parameterType = (Model.TypeVariable (Model.Name "y")),
            Typing.parameterIsLazy = True},
          Typing.Parameter {
            Typing.parameterName = (Model.Name "f"),
            Typing.parameterDescription = (Just "the function to apply to the contained value when the optional is given"),
            Typing.parameterType = (Model.TypeFunction (Model.FunctionType {
              Model.functionTypeDomain = (Model.TypeVariable (Model.Name "x")),
              Model.functionTypeCodomain = (Model.TypeVariable (Model.Name "y"))})),
            Typing.parameterIsLazy = False}],
        Typing.termSignatureResult = Typing.Result {
          Typing.resultDescription = Nothing,
          Typing.resultType = (Model.TypeVariable (Model.Name "y"))}},
      Packaging.primitiveDefinitionIsPure = True,
      Packaging.primitiveDefinitionIsTotal = True,
      Packaging.primitiveDefinitionDefaultImplementation = Nothing}

toList :: Packaging.PrimitiveDefinition
toList =
    Packaging.PrimitiveDefinition {
      Packaging.primitiveDefinitionName = (Model.Name "hydra.core.lib.optionals.toList"),
      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {
        Packaging.entityMetadataDescription = (Just "Convert an optional to a list: given x maps to [x], none to []."),
        Packaging.entityMetadataComments = [
          "toList(m) returns [x] when m is given(x), and the empty list when m is none.",
          "Total. Corresponds to Haskell's Data.Maybe.maybeToList :: Maybe a -> [a]."],
        Packaging.entityMetadataSeeAlso = [],
        Packaging.entityMetadataLifecycle = Nothing,
        Packaging.entityMetadataProvisions = []})),
      Packaging.primitiveDefinitionSignature = Typing.TermSignature {
        Typing.termSignatureTypeParameters = [
          Typing.TypeParameter {
            Typing.typeParameterName = (Model.Name "x"),
            Typing.typeParameterConstraints = []}],
        Typing.termSignatureParameters = [
          Typing.Parameter {
            Typing.parameterName = (Model.Name "m"),
            Typing.parameterDescription = (Just "the optional to convert"),
            Typing.parameterType = (Model.TypeOptional (Model.TypeVariable (Model.Name "x"))),
            Typing.parameterIsLazy = False}],
        Typing.termSignatureResult = Typing.Result {
          Typing.resultDescription = Nothing,
          Typing.resultType = (Model.TypeList (Model.TypeVariable (Model.Name "x")))}},
      Packaging.primitiveDefinitionIsPure = True,
      Packaging.primitiveDefinitionIsTotal = True,
      Packaging.primitiveDefinitionDefaultImplementation = (Just (Model.TermLambda (Model.Lambda {
        Model.lambdaParameter = (Model.Name "m"),
        Model.lambdaDomain = Nothing,
        Model.lambdaBody = (Model.TermApplication (Model.Application {
          Model.applicationFunction = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermApplication (Model.Application {
              Model.applicationFunction = (Model.TermVariable (Model.Name "hydra.core.lib.optionals.match")),
              Model.applicationArgument = (Model.TermVariable (Model.Name "m"))})),
            Model.applicationArgument = (Model.TermList [])})),
          Model.applicationArgument = (Model.TermLambda (Model.Lambda {
            Model.lambdaParameter = (Model.Name "x"),
            Model.lambdaDomain = Nothing,
            Model.lambdaBody = (Model.TermList [
              Model.TermVariable (Model.Name "x")])}))}))})))}

withDefault :: Packaging.PrimitiveDefinition
withDefault =
    Packaging.PrimitiveDefinition {
      Packaging.primitiveDefinitionName = (Model.Name "hydra.core.lib.optionals.withDefault"),
      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {
        Packaging.entityMetadataDescription = (Just "Return the value contained in an optional, falling back to a default if absent."),
        Packaging.entityMetadataComments = [
          "withDefault(def, m) returns x when m is given(x), and def when m is none.",
          "Total. Corresponds to Haskell's Data.Maybe.fromMaybe :: a -> Maybe a -> a."],
        Packaging.entityMetadataSeeAlso = [],
        Packaging.entityMetadataLifecycle = Nothing,
        Packaging.entityMetadataProvisions = []})),
      Packaging.primitiveDefinitionSignature = Typing.TermSignature {
        Typing.termSignatureTypeParameters = [
          Typing.TypeParameter {
            Typing.typeParameterName = (Model.Name "x"),
            Typing.typeParameterConstraints = []}],
        Typing.termSignatureParameters = [
          Typing.Parameter {
            Typing.parameterName = (Model.Name "def"),
            Typing.parameterDescription = (Just "the default value to return when the optional is none"),
            Typing.parameterType = (Model.TypeVariable (Model.Name "x")),
            Typing.parameterIsLazy = True},
          Typing.Parameter {
            Typing.parameterName = (Model.Name "m"),
            Typing.parameterDescription = (Just "the optional to unwrap"),
            Typing.parameterType = (Model.TypeOptional (Model.TypeVariable (Model.Name "x"))),
            Typing.parameterIsLazy = False}],
        Typing.termSignatureResult = Typing.Result {
          Typing.resultDescription = Nothing,
          Typing.resultType = (Model.TypeVariable (Model.Name "x"))}},
      Packaging.primitiveDefinitionIsPure = True,
      Packaging.primitiveDefinitionIsTotal = True,
      Packaging.primitiveDefinitionDefaultImplementation = (Just (Model.TermLambda (Model.Lambda {
        Model.lambdaParameter = (Model.Name "def"),
        Model.lambdaDomain = Nothing,
        Model.lambdaBody = (Model.TermLambda (Model.Lambda {
          Model.lambdaParameter = (Model.Name "m"),
          Model.lambdaDomain = Nothing,
          Model.lambdaBody = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermApplication (Model.Application {
              Model.applicationFunction = (Model.TermApplication (Model.Application {
                Model.applicationFunction = (Model.TermVariable (Model.Name "hydra.core.lib.optionals.match")),
                Model.applicationArgument = (Model.TermVariable (Model.Name "m"))})),
              Model.applicationArgument = (Model.TermVariable (Model.Name "def"))})),
            Model.applicationArgument = (Model.TermLambda (Model.Lambda {
              Model.lambdaParameter = (Model.Name "x"),
              Model.lambdaDomain = Nothing,
              Model.lambdaBody = (Model.TermVariable (Model.Name "x"))}))}))}))})))}