Coders.hs

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

-- | Abstractions for paired transformations between languages

module Hydra.Coders where

import qualified Hydra.Core as Core
import qualified Hydra.Graph as Graph
import qualified Hydra.Util as Util
import qualified Hydra.Variants as Variants
import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)
import qualified Data.ByteString as B
import qualified Data.Int as I
import qualified Data.List as L
import qualified Data.Map as M
import qualified Data.Set as S

-- | An evaluation context together with a source language and a target language
data AdapterContext =
  AdapterContext {
    -- | The underlying graph of elements and primitives
    adapterContextGraph :: Graph.Graph,
    -- | The language being encoded or decoded
    adapterContextLanguage :: Language,
    -- | A map of type names to adapters for those types
    adapterContextAdapters :: (M.Map Core.Name (Util.Adapter Core.Type Core.Type Core.Term Core.Term))}

_AdapterContext = Core.Name "hydra.coders.AdapterContext"

_AdapterContext_graph = Core.Name "graph"

_AdapterContext_language = Core.Name "language"

_AdapterContext_adapters = Core.Name "adapters"

-- | Indicates either the 'out' or the 'in' direction of a coder
data CoderDirection =
  CoderDirectionEncode  |
  CoderDirectionDecode
  deriving (Eq, Ord, Read, Show)

_CoderDirection = Core.Name "hydra.coders.CoderDirection"

_CoderDirection_encode = Core.Name "encode"

_CoderDirection_decode = Core.Name "decode"

-- | A named language together with language-specific constraints
data Language =
  Language {
    -- | The unique name of the language
    languageName :: LanguageName,
    -- | The constraints which characterize the language
    languageConstraints :: LanguageConstraints}

_Language = Core.Name "hydra.coders.Language"

_Language_name = Core.Name "name"

_Language_constraints = Core.Name "constraints"

-- | A set of constraints on valid type and term expressions, characterizing a language
data LanguageConstraints =
  LanguageConstraints {
    -- | All supported elimination variants
    languageConstraintsEliminationVariants :: (S.Set Variants.EliminationVariant),
    -- | All supported literal variants
    languageConstraintsLiteralVariants :: (S.Set Variants.LiteralVariant),
    -- | All supported float types
    languageConstraintsFloatTypes :: (S.Set Core.FloatType),
    -- | All supported function variants
    languageConstraintsFunctionVariants :: (S.Set Variants.FunctionVariant),
    -- | All supported integer types
    languageConstraintsIntegerTypes :: (S.Set Core.IntegerType),
    -- | All supported term variants
    languageConstraintsTermVariants :: (S.Set Variants.TermVariant),
    -- | All supported type variants
    languageConstraintsTypeVariants :: (S.Set Variants.TypeVariant),
    -- | A logical set of types, as a predicate which tests a type for inclusion
    languageConstraintsTypes :: (Core.Type -> Bool)}

_LanguageConstraints = Core.Name "hydra.coders.LanguageConstraints"

_LanguageConstraints_eliminationVariants = Core.Name "eliminationVariants"

_LanguageConstraints_literalVariants = Core.Name "literalVariants"

_LanguageConstraints_floatTypes = Core.Name "floatTypes"

_LanguageConstraints_functionVariants = Core.Name "functionVariants"

_LanguageConstraints_integerTypes = Core.Name "integerTypes"

_LanguageConstraints_termVariants = Core.Name "termVariants"

_LanguageConstraints_typeVariants = Core.Name "typeVariants"

_LanguageConstraints_types = Core.Name "types"

-- | The unique name of a language
newtype LanguageName =
  LanguageName {
    unLanguageName :: String}
  deriving (Eq, Ord, Read, Show)

_LanguageName = Core.Name "hydra.coders.LanguageName"

-- | A bidirectional encoder which maps between the same type and term languages on either side
type SymmetricAdapter t v = (Util.Adapter t t v v)

_SymmetricAdapter = Core.Name "hydra.coders.SymmetricAdapter"

-- | Specifies either a pre-order or post-order traversal
data TraversalOrder =
  -- | Pre-order traversal
  TraversalOrderPre  |
  -- | Post-order traversal
  TraversalOrderPost
  deriving (Eq, Ord, Read, Show)

_TraversalOrder = Core.Name "hydra.coders.TraversalOrder"

_TraversalOrder_pre = Core.Name "pre"

_TraversalOrder_post = Core.Name "post"

-- | A function which maps a Hydra type to a symmetric adapter between types and terms
type TypeAdapter = (AdapterContext -> Core.Type -> Either String (SymmetricAdapter Core.Type Core.Term))

_TypeAdapter = Core.Name "hydra.coders.TypeAdapter"