-- | The extension to graphs of Hydra's core type system (hydra/core)

module Hydra.Graph where

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

-- | An equality judgement: less than, equal to, or greater than
data Comparison = 
  ComparisonLessThan  |
  ComparisonEqualTo  |
  ComparisonGreaterThan 
  deriving (Comparison -> Comparison -> Bool
(Comparison -> Comparison -> Bool)
-> (Comparison -> Comparison -> Bool) -> Eq Comparison
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Comparison -> Comparison -> Bool
== :: Comparison -> Comparison -> Bool
$c/= :: Comparison -> Comparison -> Bool
/= :: Comparison -> Comparison -> Bool
Eq, Eq Comparison
Eq Comparison =>
(Comparison -> Comparison -> Ordering)
-> (Comparison -> Comparison -> Bool)
-> (Comparison -> Comparison -> Bool)
-> (Comparison -> Comparison -> Bool)
-> (Comparison -> Comparison -> Bool)
-> (Comparison -> Comparison -> Comparison)
-> (Comparison -> Comparison -> Comparison)
-> Ord Comparison
Comparison -> Comparison -> Bool
Comparison -> Comparison -> Ordering
Comparison -> Comparison -> Comparison
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 :: Comparison -> Comparison -> Ordering
compare :: Comparison -> Comparison -> Ordering
$c< :: Comparison -> Comparison -> Bool
< :: Comparison -> Comparison -> Bool
$c<= :: Comparison -> Comparison -> Bool
<= :: Comparison -> Comparison -> Bool
$c> :: Comparison -> Comparison -> Bool
> :: Comparison -> Comparison -> Bool
$c>= :: Comparison -> Comparison -> Bool
>= :: Comparison -> Comparison -> Bool
$cmax :: Comparison -> Comparison -> Comparison
max :: Comparison -> Comparison -> Comparison
$cmin :: Comparison -> Comparison -> Comparison
min :: Comparison -> Comparison -> Comparison
Ord, ReadPrec [Comparison]
ReadPrec Comparison
Int -> ReadS Comparison
ReadS [Comparison]
(Int -> ReadS Comparison)
-> ReadS [Comparison]
-> ReadPrec Comparison
-> ReadPrec [Comparison]
-> Read Comparison
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Comparison
readsPrec :: Int -> ReadS Comparison
$creadList :: ReadS [Comparison]
readList :: ReadS [Comparison]
$creadPrec :: ReadPrec Comparison
readPrec :: ReadPrec Comparison
$creadListPrec :: ReadPrec [Comparison]
readListPrec :: ReadPrec [Comparison]
Read, Int -> Comparison -> ShowS
[Comparison] -> ShowS
Comparison -> String
(Int -> Comparison -> ShowS)
-> (Comparison -> String)
-> ([Comparison] -> ShowS)
-> Show Comparison
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Comparison -> ShowS
showsPrec :: Int -> Comparison -> ShowS
$cshow :: Comparison -> String
show :: Comparison -> String
$cshowList :: [Comparison] -> ShowS
showList :: [Comparison] -> ShowS
Show)

_Comparison :: Name
_Comparison = (String -> Name
Core.Name String
"hydra/graph.Comparison")

_Comparison_lessThan :: Name
_Comparison_lessThan = (String -> Name
Core.Name String
"lessThan")

_Comparison_equalTo :: Name
_Comparison_equalTo = (String -> Name
Core.Name String
"equalTo")

_Comparison_greaterThan :: Name
_Comparison_greaterThan = (String -> Name
Core.Name String
"greaterThan")

-- | A graph, or set of name/term bindings together with parameters (annotations, primitives) and a schema graph
data Graph = 
  Graph {
    -- | All of the elements in the graph
    Graph -> Map Name Element
graphElements :: (Map Core.Name Element),
    -- | The lambda environment of this graph context; it indicates whether a variable is bound by a lambda (Nothing) or a let (Just term)
    Graph -> Map Name (Maybe Term)
graphEnvironment :: (Map Core.Name (Maybe Core.Term)),
    -- | The typing environment of the graph
    Graph -> Map Name TypeScheme
graphTypes :: (Map Core.Name Core.TypeScheme),
    -- | The body of the term which generated this context
    Graph -> Term
graphBody :: Core.Term,
    -- | All supported primitive constants and functions, by name
    Graph -> Map Name Primitive
graphPrimitives :: (Map Core.Name Primitive),
    -- | The schema of this graph. If this parameter is omitted (nothing), the graph is its own schema graph.
    Graph -> Maybe Graph
graphSchema :: (Maybe Graph)}

_Graph :: Name
_Graph = (String -> Name
Core.Name String
"hydra/graph.Graph")

_Graph_elements :: Name
_Graph_elements = (String -> Name
Core.Name String
"elements")

_Graph_environment :: Name
_Graph_environment = (String -> Name
Core.Name String
"environment")

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

_Graph_body :: Name
_Graph_body = (String -> Name
Core.Name String
"body")

_Graph_primitives :: Name
_Graph_primitives = (String -> Name
Core.Name String
"primitives")

_Graph_schema :: Name
_Graph_schema = (String -> Name
Core.Name String
"schema")

-- | A graph element, having a name, data term (value), and schema term (type)
data Element = 
  Element {
    Element -> Name
elementName :: Core.Name,
    Element -> Term
elementData :: Core.Term}
  deriving (Element -> Element -> Bool
(Element -> Element -> Bool)
-> (Element -> Element -> Bool) -> Eq Element
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Element -> Element -> Bool
== :: Element -> Element -> Bool
$c/= :: Element -> Element -> Bool
/= :: Element -> Element -> Bool
Eq, Eq Element
Eq Element =>
(Element -> Element -> Ordering)
-> (Element -> Element -> Bool)
-> (Element -> Element -> Bool)
-> (Element -> Element -> Bool)
-> (Element -> Element -> Bool)
-> (Element -> Element -> Element)
-> (Element -> Element -> Element)
-> Ord Element
Element -> Element -> Bool
Element -> Element -> Ordering
Element -> Element -> Element
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 :: Element -> Element -> Ordering
compare :: Element -> Element -> Ordering
$c< :: Element -> Element -> Bool
< :: Element -> Element -> Bool
$c<= :: Element -> Element -> Bool
<= :: Element -> Element -> Bool
$c> :: Element -> Element -> Bool
> :: Element -> Element -> Bool
$c>= :: Element -> Element -> Bool
>= :: Element -> Element -> Bool
$cmax :: Element -> Element -> Element
max :: Element -> Element -> Element
$cmin :: Element -> Element -> Element
min :: Element -> Element -> Element
Ord, ReadPrec [Element]
ReadPrec Element
Int -> ReadS Element
ReadS [Element]
(Int -> ReadS Element)
-> ReadS [Element]
-> ReadPrec Element
-> ReadPrec [Element]
-> Read Element
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Element
readsPrec :: Int -> ReadS Element
$creadList :: ReadS [Element]
readList :: ReadS [Element]
$creadPrec :: ReadPrec Element
readPrec :: ReadPrec Element
$creadListPrec :: ReadPrec [Element]
readListPrec :: ReadPrec [Element]
Read, Int -> Element -> ShowS
[Element] -> ShowS
Element -> String
(Int -> Element -> ShowS)
-> (Element -> String) -> ([Element] -> ShowS) -> Show Element
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Element -> ShowS
showsPrec :: Int -> Element -> ShowS
$cshow :: Element -> String
show :: Element -> String
$cshowList :: [Element] -> ShowS
showList :: [Element] -> ShowS
Show)

_Element :: Name
_Element = (String -> Name
Core.Name String
"hydra/graph.Element")

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

_Element_data :: Name
_Element_data = (String -> Name
Core.Name String
"data")

-- | A built-in function
data Primitive = 
  Primitive {
    -- | The unique name of the primitive function
    Primitive -> Name
primitiveName :: Core.Name,
    -- | The type signature of the primitive function
    Primitive -> TypeScheme
primitiveType :: Core.TypeScheme,
    -- | A concrete implementation of the primitive function
    Primitive -> [Term] -> Flow Graph Term
primitiveImplementation :: ([Core.Term] -> Compute.Flow Graph Core.Term)}

_Primitive :: Name
_Primitive = (String -> Name
Core.Name String
"hydra/graph.Primitive")

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

_Primitive_type :: Name
_Primitive_type = (String -> Name
Core.Name String
"type")

_Primitive_implementation :: Name
_Primitive_implementation = (String -> Name
Core.Name String
"implementation")

-- | A type together with a coder for mapping terms into arguments for primitive functions, and mapping computed results into terms
data TermCoder x = 
  TermCoder {
    forall x. TermCoder x -> Type
termCoderType :: Core.Type,
    forall x. TermCoder x -> Coder Graph Graph Term x
termCoderCoder :: (Compute.Coder Graph Graph Core.Term x)}

_TermCoder :: Name
_TermCoder = (String -> Name
Core.Name String
"hydra/graph.TermCoder")

_TermCoder_type :: Name
_TermCoder_type = (String -> Name
Core.Name String
"type")

_TermCoder_coder :: Name
_TermCoder_coder = (String -> Name
Core.Name String
"coder")

-- | Any of a small number of built-in type classes
data TypeClass = 
  TypeClassEquality  |
  TypeClassOrdering 
  deriving (TypeClass -> TypeClass -> Bool
(TypeClass -> TypeClass -> Bool)
-> (TypeClass -> TypeClass -> Bool) -> Eq TypeClass
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TypeClass -> TypeClass -> Bool
== :: TypeClass -> TypeClass -> Bool
$c/= :: TypeClass -> TypeClass -> Bool
/= :: TypeClass -> TypeClass -> Bool
Eq, Eq TypeClass
Eq TypeClass =>
(TypeClass -> TypeClass -> Ordering)
-> (TypeClass -> TypeClass -> Bool)
-> (TypeClass -> TypeClass -> Bool)
-> (TypeClass -> TypeClass -> Bool)
-> (TypeClass -> TypeClass -> Bool)
-> (TypeClass -> TypeClass -> TypeClass)
-> (TypeClass -> TypeClass -> TypeClass)
-> Ord TypeClass
TypeClass -> TypeClass -> Bool
TypeClass -> TypeClass -> Ordering
TypeClass -> TypeClass -> TypeClass
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 :: TypeClass -> TypeClass -> Ordering
compare :: TypeClass -> TypeClass -> Ordering
$c< :: TypeClass -> TypeClass -> Bool
< :: TypeClass -> TypeClass -> Bool
$c<= :: TypeClass -> TypeClass -> Bool
<= :: TypeClass -> TypeClass -> Bool
$c> :: TypeClass -> TypeClass -> Bool
> :: TypeClass -> TypeClass -> Bool
$c>= :: TypeClass -> TypeClass -> Bool
>= :: TypeClass -> TypeClass -> Bool
$cmax :: TypeClass -> TypeClass -> TypeClass
max :: TypeClass -> TypeClass -> TypeClass
$cmin :: TypeClass -> TypeClass -> TypeClass
min :: TypeClass -> TypeClass -> TypeClass
Ord, ReadPrec [TypeClass]
ReadPrec TypeClass
Int -> ReadS TypeClass
ReadS [TypeClass]
(Int -> ReadS TypeClass)
-> ReadS [TypeClass]
-> ReadPrec TypeClass
-> ReadPrec [TypeClass]
-> Read TypeClass
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS TypeClass
readsPrec :: Int -> ReadS TypeClass
$creadList :: ReadS [TypeClass]
readList :: ReadS [TypeClass]
$creadPrec :: ReadPrec TypeClass
readPrec :: ReadPrec TypeClass
$creadListPrec :: ReadPrec [TypeClass]
readListPrec :: ReadPrec [TypeClass]
Read, Int -> TypeClass -> ShowS
[TypeClass] -> ShowS
TypeClass -> String
(Int -> TypeClass -> ShowS)
-> (TypeClass -> String)
-> ([TypeClass] -> ShowS)
-> Show TypeClass
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TypeClass -> ShowS
showsPrec :: Int -> TypeClass -> ShowS
$cshow :: TypeClass -> String
show :: TypeClass -> String
$cshowList :: [TypeClass] -> ShowS
showList :: [TypeClass] -> ShowS
Show)

_TypeClass :: Name
_TypeClass = (String -> Name
Core.Name String
"hydra/graph.TypeClass")

_TypeClass_equality :: Name
_TypeClass_equality = (String -> Name
Core.Name String
"equality")

_TypeClass_ordering :: Name
_TypeClass_ordering = (String -> Name
Core.Name String
"ordering")