Reflect.hs

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

-- | Reflection functions for working with term, type, and literal type variants, as well as numeric precision.

module Hydra.Core.Reflect 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.Overlay.Haskell.Lib.Lists as Lists
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 the precision of a given floating-point type
floatTypePrecision :: Model.FloatType -> Util.Precision
floatTypePrecision x =
    case x of
      Model.FloatTypeFloat32 -> Util.PrecisionBits 32
      Model.FloatTypeFloat64 -> Util.PrecisionBits 64

-- | All floating-point types in a canonical order
floatTypes :: [Model.FloatType]
floatTypes =
    [
      Model.FloatTypeFloat32,
      Model.FloatTypeFloat64]

-- | Find the float type for a given floating-point value
floatValueType :: Model.FloatValue -> Model.FloatType
floatValueType x =
    case x of
      Model.FloatValueFloat32 _ -> Model.FloatTypeFloat32
      Model.FloatValueFloat64 _ -> Model.FloatTypeFloat64

-- | Find whether a given integer type is signed (true) or unsigned (false)
integerTypeIsSigned :: Model.IntegerType -> Bool
integerTypeIsSigned x =
    case x of
      Model.IntegerTypeBigint -> True
      Model.IntegerTypeInt8 -> True
      Model.IntegerTypeInt16 -> True
      Model.IntegerTypeInt32 -> True
      Model.IntegerTypeInt64 -> True
      Model.IntegerTypeUint8 -> False
      Model.IntegerTypeUint16 -> False
      Model.IntegerTypeUint32 -> False
      Model.IntegerTypeUint64 -> False

-- | Find the precision of a given integer type
integerTypePrecision :: Model.IntegerType -> Util.Precision
integerTypePrecision x =
    case x of
      Model.IntegerTypeBigint -> Util.PrecisionArbitrary
      Model.IntegerTypeInt8 -> Util.PrecisionBits 8
      Model.IntegerTypeInt16 -> Util.PrecisionBits 16
      Model.IntegerTypeInt32 -> Util.PrecisionBits 32
      Model.IntegerTypeInt64 -> Util.PrecisionBits 64
      Model.IntegerTypeUint8 -> Util.PrecisionBits 8
      Model.IntegerTypeUint16 -> Util.PrecisionBits 16
      Model.IntegerTypeUint32 -> Util.PrecisionBits 32
      Model.IntegerTypeUint64 -> Util.PrecisionBits 64

-- | All integer types, in a canonical order
integerTypes :: [Model.IntegerType]
integerTypes =
    [
      Model.IntegerTypeBigint,
      Model.IntegerTypeInt8,
      Model.IntegerTypeInt16,
      Model.IntegerTypeInt32,
      Model.IntegerTypeInt64,
      Model.IntegerTypeUint8,
      Model.IntegerTypeUint16,
      Model.IntegerTypeUint32,
      Model.IntegerTypeUint64]

-- | Find the integer type for a given integer value
integerValueType :: Model.IntegerValue -> Model.IntegerType
integerValueType x =
    case x of
      Model.IntegerValueBigint _ -> Model.IntegerTypeBigint
      Model.IntegerValueInt8 _ -> Model.IntegerTypeInt8
      Model.IntegerValueInt16 _ -> Model.IntegerTypeInt16
      Model.IntegerValueInt32 _ -> Model.IntegerTypeInt32
      Model.IntegerValueInt64 _ -> Model.IntegerTypeInt64
      Model.IntegerValueUint8 _ -> Model.IntegerTypeUint8
      Model.IntegerValueUint16 _ -> Model.IntegerTypeUint16
      Model.IntegerValueUint32 _ -> Model.IntegerTypeUint32
      Model.IntegerValueUint64 _ -> Model.IntegerTypeUint64

-- | Find the literal type for a given literal value
literalType :: Model.Literal -> Model.LiteralType
literalType x =
    case x of
      Model.LiteralBinary _ -> Model.LiteralTypeBinary
      Model.LiteralBoolean _ -> Model.LiteralTypeBoolean
      Model.LiteralDecimal _ -> Model.LiteralTypeDecimal
      Model.LiteralFloat v0 -> (\injected_ -> Model.LiteralTypeFloat injected_) (floatValueType v0)
      Model.LiteralInteger v0 -> (\injected_ -> Model.LiteralTypeInteger injected_) (integerValueType v0)
      Model.LiteralString _ -> Model.LiteralTypeString

-- | Find the literal type inject (constructor) for a given literal value
literalTypeVariant :: Model.LiteralType -> Variants.LiteralVariant
literalTypeVariant x =
    case x of
      Model.LiteralTypeBinary -> Variants.LiteralVariantBinary
      Model.LiteralTypeBoolean -> Variants.LiteralVariantBoolean
      Model.LiteralTypeDecimal -> Variants.LiteralVariantDecimal
      Model.LiteralTypeFloat _ -> Variants.LiteralVariantFloat
      Model.LiteralTypeInteger _ -> Variants.LiteralVariantInteger
      Model.LiteralTypeString -> Variants.LiteralVariantString

-- | All literal types, in a canonical order
literalTypes :: [Model.LiteralType]
literalTypes =
    Lists.concat [
      [
        Model.LiteralTypeBinary,
        Model.LiteralTypeBoolean,
        Model.LiteralTypeDecimal],
      (Lists.map (\x -> Model.LiteralTypeFloat x) floatTypes),
      (Lists.map (\x -> Model.LiteralTypeInteger x) integerTypes),
      [
        Model.LiteralTypeString]]

-- | Find the literal inject (constructor) for a given literal value
literalVariant :: Model.Literal -> Variants.LiteralVariant
literalVariant arg_ = literalTypeVariant (literalType arg_)

-- | All literal variants, in a canonical order
literalVariants :: [Variants.LiteralVariant]
literalVariants =
    [
      Variants.LiteralVariantBinary,
      Variants.LiteralVariantBoolean,
      Variants.LiteralVariantDecimal,
      Variants.LiteralVariantFloat,
      Variants.LiteralVariantInteger,
      Variants.LiteralVariantString]

-- | Find the term inject (constructor) for a given term
termVariant :: Model.Term -> Variants.TermVariant
termVariant x =
    case x of
      Model.TermAnnotated _ -> Variants.TermVariantAnnotated
      Model.TermApplication _ -> Variants.TermVariantApplication
      Model.TermCases _ -> Variants.TermVariantCases
      Model.TermEither _ -> Variants.TermVariantEither
      Model.TermLambda _ -> Variants.TermVariantLambda
      Model.TermLet _ -> Variants.TermVariantLet
      Model.TermList _ -> Variants.TermVariantList
      Model.TermLiteral _ -> Variants.TermVariantLiteral
      Model.TermMap _ -> Variants.TermVariantMap
      Model.TermOptional _ -> Variants.TermVariantOptional
      Model.TermPair _ -> Variants.TermVariantPair
      Model.TermProject _ -> Variants.TermVariantProject
      Model.TermRecord _ -> Variants.TermVariantRecord
      Model.TermSet _ -> Variants.TermVariantSet
      Model.TermTypeApplication _ -> Variants.TermVariantTypeApplication
      Model.TermTypeLambda _ -> Variants.TermVariantTypeLambda
      Model.TermInject _ -> Variants.TermVariantInject
      Model.TermUnit -> Variants.TermVariantUnit
      Model.TermUnwrap _ -> Variants.TermVariantUnwrap
      Model.TermVariable _ -> Variants.TermVariantVariable
      Model.TermWrap _ -> Variants.TermVariantWrap

-- | All term (expression) variants, in a canonical order
termVariants :: [Variants.TermVariant]
termVariants =
    [
      Variants.TermVariantAnnotated,
      Variants.TermVariantApplication,
      Variants.TermVariantCases,
      Variants.TermVariantEither,
      Variants.TermVariantLambda,
      Variants.TermVariantLet,
      Variants.TermVariantList,
      Variants.TermVariantLiteral,
      Variants.TermVariantMap,
      Variants.TermVariantOptional,
      Variants.TermVariantPair,
      Variants.TermVariantProject,
      Variants.TermVariantRecord,
      Variants.TermVariantSet,
      Variants.TermVariantTypeLambda,
      Variants.TermVariantTypeApplication,
      Variants.TermVariantInject,
      Variants.TermVariantUnit,
      Variants.TermVariantUnwrap,
      Variants.TermVariantVariable,
      Variants.TermVariantWrap]

-- | Find the type inject (constructor) for a given type
typeVariant :: Model.Type -> Variants.TypeVariant
typeVariant x =
    case x of
      Model.TypeAnnotated _ -> Variants.TypeVariantAnnotated
      Model.TypeApplication _ -> Variants.TypeVariantApplication
      Model.TypeEffect _ -> Variants.TypeVariantEffect
      Model.TypeEither _ -> Variants.TypeVariantEither
      Model.TypeForall _ -> Variants.TypeVariantForall
      Model.TypeFunction _ -> Variants.TypeVariantFunction
      Model.TypeList _ -> Variants.TypeVariantList
      Model.TypeLiteral _ -> Variants.TypeVariantLiteral
      Model.TypeMap _ -> Variants.TypeVariantMap
      Model.TypeOptional _ -> Variants.TypeVariantOptional
      Model.TypePair _ -> Variants.TypeVariantPair
      Model.TypeRecord _ -> Variants.TypeVariantRecord
      Model.TypeSet _ -> Variants.TypeVariantSet
      Model.TypeUnion _ -> Variants.TypeVariantUnion
      Model.TypeUnit -> Variants.TypeVariantUnit
      Model.TypeVariable _ -> Variants.TypeVariantVariable
      Model.TypeVoid -> Variants.TypeVariantVoid
      Model.TypeWrap _ -> Variants.TypeVariantWrap

-- | All type variants, in a canonical order
typeVariants :: [Variants.TypeVariant]
typeVariants =
    [
      Variants.TypeVariantAnnotated,
      Variants.TypeVariantApplication,
      Variants.TypeVariantEffect,
      Variants.TypeVariantEither,
      Variants.TypeVariantForall,
      Variants.TypeVariantFunction,
      Variants.TypeVariantList,
      Variants.TypeVariantLiteral,
      Variants.TypeVariantMap,
      Variants.TypeVariantOptional,
      Variants.TypeVariantPair,
      Variants.TypeVariantRecord,
      Variants.TypeVariantSet,
      Variants.TypeVariantUnion,
      Variants.TypeVariantUnit,
      Variants.TypeVariantVariable,
      Variants.TypeVariantVoid,
      Variants.TypeVariantWrap]