-- | Abstractions for paired transformations between languages

module Hydra.Coders where

import qualified Hydra.Compute as Compute
import qualified Hydra.Core as Core
import qualified Hydra.Graph as Graph
import qualified Hydra.Mantle as Mantle
import Data.Int
import Data.List as L
import Data.Map as M
import Data.Set as S

-- | An evaluation context together with a source language and a target language
data AdapterContext = 
  AdapterContext {
    AdapterContext -> Graph
adapterContextGraph :: Graph.Graph,
    AdapterContext -> Language
adapterContextLanguage :: Language,
    AdapterContext
-> Map
     Name (Adapter AdapterContext AdapterContext Type Type Term Term)
adapterContextAdapters :: (Map Core.Name (Compute.Adapter AdapterContext AdapterContext Core.Type Core.Type Core.Term Core.Term))}

_AdapterContext :: Name
_AdapterContext = (String -> Name
Core.Name String
"hydra/coders.AdapterContext")

_AdapterContext_graph :: Name
_AdapterContext_graph = (String -> Name
Core.Name String
"graph")

_AdapterContext_language :: Name
_AdapterContext_language = (String -> Name
Core.Name String
"language")

_AdapterContext_adapters :: Name
_AdapterContext_adapters = (String -> Name
Core.Name String
"adapters")

-- | Indicates either the 'out' or the 'in' direction of a coder
data CoderDirection = 
  CoderDirectionEncode  |
  CoderDirectionDecode 
  deriving (CoderDirection -> CoderDirection -> Bool
(CoderDirection -> CoderDirection -> Bool)
-> (CoderDirection -> CoderDirection -> Bool) -> Eq CoderDirection
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CoderDirection -> CoderDirection -> Bool
== :: CoderDirection -> CoderDirection -> Bool
$c/= :: CoderDirection -> CoderDirection -> Bool
/= :: CoderDirection -> CoderDirection -> Bool
Eq, Eq CoderDirection
Eq CoderDirection =>
(CoderDirection -> CoderDirection -> Ordering)
-> (CoderDirection -> CoderDirection -> Bool)
-> (CoderDirection -> CoderDirection -> Bool)
-> (CoderDirection -> CoderDirection -> Bool)
-> (CoderDirection -> CoderDirection -> Bool)
-> (CoderDirection -> CoderDirection -> CoderDirection)
-> (CoderDirection -> CoderDirection -> CoderDirection)
-> Ord CoderDirection
CoderDirection -> CoderDirection -> Bool
CoderDirection -> CoderDirection -> Ordering
CoderDirection -> CoderDirection -> CoderDirection
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: CoderDirection -> CoderDirection -> Ordering
compare :: CoderDirection -> CoderDirection -> Ordering
$c< :: CoderDirection -> CoderDirection -> Bool
< :: CoderDirection -> CoderDirection -> Bool
$c<= :: CoderDirection -> CoderDirection -> Bool
<= :: CoderDirection -> CoderDirection -> Bool
$c> :: CoderDirection -> CoderDirection -> Bool
> :: CoderDirection -> CoderDirection -> Bool
$c>= :: CoderDirection -> CoderDirection -> Bool
>= :: CoderDirection -> CoderDirection -> Bool
$cmax :: CoderDirection -> CoderDirection -> CoderDirection
max :: CoderDirection -> CoderDirection -> CoderDirection
$cmin :: CoderDirection -> CoderDirection -> CoderDirection
min :: CoderDirection -> CoderDirection -> CoderDirection
Ord, ReadPrec [CoderDirection]
ReadPrec CoderDirection
Int -> ReadS CoderDirection
ReadS [CoderDirection]
(Int -> ReadS CoderDirection)
-> ReadS [CoderDirection]
-> ReadPrec CoderDirection
-> ReadPrec [CoderDirection]
-> Read CoderDirection
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS CoderDirection
readsPrec :: Int -> ReadS CoderDirection
$creadList :: ReadS [CoderDirection]
readList :: ReadS [CoderDirection]
$creadPrec :: ReadPrec CoderDirection
readPrec :: ReadPrec CoderDirection
$creadListPrec :: ReadPrec [CoderDirection]
readListPrec :: ReadPrec [CoderDirection]
Read, Int -> CoderDirection -> ShowS
[CoderDirection] -> ShowS
CoderDirection -> String
(Int -> CoderDirection -> ShowS)
-> (CoderDirection -> String)
-> ([CoderDirection] -> ShowS)
-> Show CoderDirection
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CoderDirection -> ShowS
showsPrec :: Int -> CoderDirection -> ShowS
$cshow :: CoderDirection -> String
show :: CoderDirection -> String
$cshowList :: [CoderDirection] -> ShowS
showList :: [CoderDirection] -> ShowS
Show)

_CoderDirection :: Name
_CoderDirection = (String -> Name
Core.Name String
"hydra/coders.CoderDirection")

_CoderDirection_encode :: Name
_CoderDirection_encode = (String -> Name
Core.Name String
"encode")

_CoderDirection_decode :: Name
_CoderDirection_decode = (String -> Name
Core.Name String
"decode")

-- | A named language together with language-specific constraints
data Language = 
  Language {
    Language -> LanguageName
languageName :: LanguageName,
    Language -> LanguageConstraints
languageConstraints :: LanguageConstraints}

_Language :: Name
_Language = (String -> Name
Core.Name String
"hydra/coders.Language")

_Language_name :: Name
_Language_name = (String -> Name
Core.Name String
"name")

_Language_constraints :: Name
_Language_constraints = (String -> Name
Core.Name String
"constraints")

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

_LanguageConstraints :: Name
_LanguageConstraints = (String -> Name
Core.Name String
"hydra/coders.LanguageConstraints")

_LanguageConstraints_eliminationVariants :: Name
_LanguageConstraints_eliminationVariants = (String -> Name
Core.Name String
"eliminationVariants")

_LanguageConstraints_literalVariants :: Name
_LanguageConstraints_literalVariants = (String -> Name
Core.Name String
"literalVariants")

_LanguageConstraints_floatTypes :: Name
_LanguageConstraints_floatTypes = (String -> Name
Core.Name String
"floatTypes")

_LanguageConstraints_functionVariants :: Name
_LanguageConstraints_functionVariants = (String -> Name
Core.Name String
"functionVariants")

_LanguageConstraints_integerTypes :: Name
_LanguageConstraints_integerTypes = (String -> Name
Core.Name String
"integerTypes")

_LanguageConstraints_termVariants :: Name
_LanguageConstraints_termVariants = (String -> Name
Core.Name String
"termVariants")

_LanguageConstraints_typeVariants :: Name
_LanguageConstraints_typeVariants = (String -> Name
Core.Name String
"typeVariants")

_LanguageConstraints_types :: Name
_LanguageConstraints_types = (String -> Name
Core.Name String
"types")

-- | The unique name of a language
newtype LanguageName = 
  LanguageName {
    LanguageName -> String
unLanguageName :: String}
  deriving (LanguageName -> LanguageName -> Bool
(LanguageName -> LanguageName -> Bool)
-> (LanguageName -> LanguageName -> Bool) -> Eq LanguageName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: LanguageName -> LanguageName -> Bool
== :: LanguageName -> LanguageName -> Bool
$c/= :: LanguageName -> LanguageName -> Bool
/= :: LanguageName -> LanguageName -> Bool
Eq, Eq LanguageName
Eq LanguageName =>
(LanguageName -> LanguageName -> Ordering)
-> (LanguageName -> LanguageName -> Bool)
-> (LanguageName -> LanguageName -> Bool)
-> (LanguageName -> LanguageName -> Bool)
-> (LanguageName -> LanguageName -> Bool)
-> (LanguageName -> LanguageName -> LanguageName)
-> (LanguageName -> LanguageName -> LanguageName)
-> Ord LanguageName
LanguageName -> LanguageName -> Bool
LanguageName -> LanguageName -> Ordering
LanguageName -> LanguageName -> LanguageName
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: LanguageName -> LanguageName -> Ordering
compare :: LanguageName -> LanguageName -> Ordering
$c< :: LanguageName -> LanguageName -> Bool
< :: LanguageName -> LanguageName -> Bool
$c<= :: LanguageName -> LanguageName -> Bool
<= :: LanguageName -> LanguageName -> Bool
$c> :: LanguageName -> LanguageName -> Bool
> :: LanguageName -> LanguageName -> Bool
$c>= :: LanguageName -> LanguageName -> Bool
>= :: LanguageName -> LanguageName -> Bool
$cmax :: LanguageName -> LanguageName -> LanguageName
max :: LanguageName -> LanguageName -> LanguageName
$cmin :: LanguageName -> LanguageName -> LanguageName
min :: LanguageName -> LanguageName -> LanguageName
Ord, ReadPrec [LanguageName]
ReadPrec LanguageName
Int -> ReadS LanguageName
ReadS [LanguageName]
(Int -> ReadS LanguageName)
-> ReadS [LanguageName]
-> ReadPrec LanguageName
-> ReadPrec [LanguageName]
-> Read LanguageName
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS LanguageName
readsPrec :: Int -> ReadS LanguageName
$creadList :: ReadS [LanguageName]
readList :: ReadS [LanguageName]
$creadPrec :: ReadPrec LanguageName
readPrec :: ReadPrec LanguageName
$creadListPrec :: ReadPrec [LanguageName]
readListPrec :: ReadPrec [LanguageName]
Read, Int -> LanguageName -> ShowS
[LanguageName] -> ShowS
LanguageName -> String
(Int -> LanguageName -> ShowS)
-> (LanguageName -> String)
-> ([LanguageName] -> ShowS)
-> Show LanguageName
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> LanguageName -> ShowS
showsPrec :: Int -> LanguageName -> ShowS
$cshow :: LanguageName -> String
show :: LanguageName -> String
$cshowList :: [LanguageName] -> ShowS
showList :: [LanguageName] -> ShowS
Show)

_LanguageName :: Name
_LanguageName = (String -> Name
Core.Name String
"hydra/coders.LanguageName")

-- | Specifies either a pre-order or post-order traversal
data TraversalOrder = 
  -- | Pre-order traversal
  TraversalOrderPre  |
  -- | Post-order traversal
  TraversalOrderPost 
  deriving (TraversalOrder -> TraversalOrder -> Bool
(TraversalOrder -> TraversalOrder -> Bool)
-> (TraversalOrder -> TraversalOrder -> Bool) -> Eq TraversalOrder
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TraversalOrder -> TraversalOrder -> Bool
== :: TraversalOrder -> TraversalOrder -> Bool
$c/= :: TraversalOrder -> TraversalOrder -> Bool
/= :: TraversalOrder -> TraversalOrder -> Bool
Eq, Eq TraversalOrder
Eq TraversalOrder =>
(TraversalOrder -> TraversalOrder -> Ordering)
-> (TraversalOrder -> TraversalOrder -> Bool)
-> (TraversalOrder -> TraversalOrder -> Bool)
-> (TraversalOrder -> TraversalOrder -> Bool)
-> (TraversalOrder -> TraversalOrder -> Bool)
-> (TraversalOrder -> TraversalOrder -> TraversalOrder)
-> (TraversalOrder -> TraversalOrder -> TraversalOrder)
-> Ord TraversalOrder
TraversalOrder -> TraversalOrder -> Bool
TraversalOrder -> TraversalOrder -> Ordering
TraversalOrder -> TraversalOrder -> TraversalOrder
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: TraversalOrder -> TraversalOrder -> Ordering
compare :: TraversalOrder -> TraversalOrder -> Ordering
$c< :: TraversalOrder -> TraversalOrder -> Bool
< :: TraversalOrder -> TraversalOrder -> Bool
$c<= :: TraversalOrder -> TraversalOrder -> Bool
<= :: TraversalOrder -> TraversalOrder -> Bool
$c> :: TraversalOrder -> TraversalOrder -> Bool
> :: TraversalOrder -> TraversalOrder -> Bool
$c>= :: TraversalOrder -> TraversalOrder -> Bool
>= :: TraversalOrder -> TraversalOrder -> Bool
$cmax :: TraversalOrder -> TraversalOrder -> TraversalOrder
max :: TraversalOrder -> TraversalOrder -> TraversalOrder
$cmin :: TraversalOrder -> TraversalOrder -> TraversalOrder
min :: TraversalOrder -> TraversalOrder -> TraversalOrder
Ord, ReadPrec [TraversalOrder]
ReadPrec TraversalOrder
Int -> ReadS TraversalOrder
ReadS [TraversalOrder]
(Int -> ReadS TraversalOrder)
-> ReadS [TraversalOrder]
-> ReadPrec TraversalOrder
-> ReadPrec [TraversalOrder]
-> Read TraversalOrder
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS TraversalOrder
readsPrec :: Int -> ReadS TraversalOrder
$creadList :: ReadS [TraversalOrder]
readList :: ReadS [TraversalOrder]
$creadPrec :: ReadPrec TraversalOrder
readPrec :: ReadPrec TraversalOrder
$creadListPrec :: ReadPrec [TraversalOrder]
readListPrec :: ReadPrec [TraversalOrder]
Read, Int -> TraversalOrder -> ShowS
[TraversalOrder] -> ShowS
TraversalOrder -> String
(Int -> TraversalOrder -> ShowS)
-> (TraversalOrder -> String)
-> ([TraversalOrder] -> ShowS)
-> Show TraversalOrder
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TraversalOrder -> ShowS
showsPrec :: Int -> TraversalOrder -> ShowS
$cshow :: TraversalOrder -> String
show :: TraversalOrder -> String
$cshowList :: [TraversalOrder] -> ShowS
showList :: [TraversalOrder] -> ShowS
Show)

_TraversalOrder :: Name
_TraversalOrder = (String -> Name
Core.Name String
"hydra/coders.TraversalOrder")

_TraversalOrder_pre :: Name
_TraversalOrder_pre = (String -> Name
Core.Name String
"pre")

_TraversalOrder_post :: Name
_TraversalOrder_post = (String -> Name
Core.Name String
"post")