-- | Hydra's core data model, defining types, terms, and their dependencies

module Hydra.Core where

import Data.List
import Data.Map
import Data.Set

-- | An object, such as a type or term, together with an annotation
data Annotated a m = 
  Annotated {
    forall a m. Annotated a m -> a
annotatedSubject :: a,
    forall a m. Annotated a m -> m
annotatedAnnotation :: m}
  deriving (Annotated a m -> Annotated a m -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall a m. (Eq a, Eq m) => Annotated a m -> Annotated a m -> Bool
/= :: Annotated a m -> Annotated a m -> Bool
$c/= :: forall a m. (Eq a, Eq m) => Annotated a m -> Annotated a m -> Bool
== :: Annotated a m -> Annotated a m -> Bool
$c== :: forall a m. (Eq a, Eq m) => Annotated a m -> Annotated a m -> Bool
Eq, Annotated a m -> Annotated a m -> Bool
Annotated a m -> Annotated a m -> Ordering
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
forall {a} {m}. (Ord a, Ord m) => Eq (Annotated a m)
forall a m.
(Ord a, Ord m) =>
Annotated a m -> Annotated a m -> Bool
forall a m.
(Ord a, Ord m) =>
Annotated a m -> Annotated a m -> Ordering
forall a m.
(Ord a, Ord m) =>
Annotated a m -> Annotated a m -> Annotated a m
min :: Annotated a m -> Annotated a m -> Annotated a m
$cmin :: forall a m.
(Ord a, Ord m) =>
Annotated a m -> Annotated a m -> Annotated a m
max :: Annotated a m -> Annotated a m -> Annotated a m
$cmax :: forall a m.
(Ord a, Ord m) =>
Annotated a m -> Annotated a m -> Annotated a m
>= :: Annotated a m -> Annotated a m -> Bool
$c>= :: forall a m.
(Ord a, Ord m) =>
Annotated a m -> Annotated a m -> Bool
> :: Annotated a m -> Annotated a m -> Bool
$c> :: forall a m.
(Ord a, Ord m) =>
Annotated a m -> Annotated a m -> Bool
<= :: Annotated a m -> Annotated a m -> Bool
$c<= :: forall a m.
(Ord a, Ord m) =>
Annotated a m -> Annotated a m -> Bool
< :: Annotated a m -> Annotated a m -> Bool
$c< :: forall a m.
(Ord a, Ord m) =>
Annotated a m -> Annotated a m -> Bool
compare :: Annotated a m -> Annotated a m -> Ordering
$ccompare :: forall a m.
(Ord a, Ord m) =>
Annotated a m -> Annotated a m -> Ordering
Ord, ReadPrec [Annotated a m]
ReadPrec (Annotated a m)
ReadS [Annotated a m]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
forall a m. (Read a, Read m) => ReadPrec [Annotated a m]
forall a m. (Read a, Read m) => ReadPrec (Annotated a m)
forall a m. (Read a, Read m) => Int -> ReadS (Annotated a m)
forall a m. (Read a, Read m) => ReadS [Annotated a m]
readListPrec :: ReadPrec [Annotated a m]
$creadListPrec :: forall a m. (Read a, Read m) => ReadPrec [Annotated a m]
readPrec :: ReadPrec (Annotated a m)
$creadPrec :: forall a m. (Read a, Read m) => ReadPrec (Annotated a m)
readList :: ReadS [Annotated a m]
$creadList :: forall a m. (Read a, Read m) => ReadS [Annotated a m]
readsPrec :: Int -> ReadS (Annotated a m)
$creadsPrec :: forall a m. (Read a, Read m) => Int -> ReadS (Annotated a m)
Read, Int -> Annotated a m -> ShowS
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall a m. (Show a, Show m) => Int -> Annotated a m -> ShowS
forall a m. (Show a, Show m) => [Annotated a m] -> ShowS
forall a m. (Show a, Show m) => Annotated a m -> String
showList :: [Annotated a m] -> ShowS
$cshowList :: forall a m. (Show a, Show m) => [Annotated a m] -> ShowS
show :: Annotated a m -> String
$cshow :: forall a m. (Show a, Show m) => Annotated a m -> String
showsPrec :: Int -> Annotated a m -> ShowS
$cshowsPrec :: forall a m. (Show a, Show m) => Int -> Annotated a m -> ShowS
Show)

_Annotated :: Name
_Annotated = (String -> Name
Name String
"hydra/core.Annotated")

_Annotated_subject :: FieldName
_Annotated_subject = (String -> FieldName
FieldName String
"subject")

_Annotated_annotation :: FieldName
_Annotated_annotation = (String -> FieldName
FieldName String
"annotation")

-- | A term which applies a function to an argument
data Application m = 
  Application {
    -- | The left-hand side of the application
    forall m. Application m -> Term m
applicationFunction :: (Term m),
    -- | The right-hand side of the application
    forall m. Application m -> Term m
applicationArgument :: (Term m)}
  deriving (Application m -> Application m -> Bool
forall m. Eq m => Application m -> Application m -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Application m -> Application m -> Bool
$c/= :: forall m. Eq m => Application m -> Application m -> Bool
== :: Application m -> Application m -> Bool
$c== :: forall m. Eq m => Application m -> Application m -> Bool
Eq, Application m -> Application m -> Bool
Application m -> Application m -> Ordering
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
forall {m}. Ord m => Eq (Application m)
forall m. Ord m => Application m -> Application m -> Bool
forall m. Ord m => Application m -> Application m -> Ordering
forall m. Ord m => Application m -> Application m -> Application m
min :: Application m -> Application m -> Application m
$cmin :: forall m. Ord m => Application m -> Application m -> Application m
max :: Application m -> Application m -> Application m
$cmax :: forall m. Ord m => Application m -> Application m -> Application m
>= :: Application m -> Application m -> Bool
$c>= :: forall m. Ord m => Application m -> Application m -> Bool
> :: Application m -> Application m -> Bool
$c> :: forall m. Ord m => Application m -> Application m -> Bool
<= :: Application m -> Application m -> Bool
$c<= :: forall m. Ord m => Application m -> Application m -> Bool
< :: Application m -> Application m -> Bool
$c< :: forall m. Ord m => Application m -> Application m -> Bool
compare :: Application m -> Application m -> Ordering
$ccompare :: forall m. Ord m => Application m -> Application m -> Ordering
Ord, ReadPrec [Application m]
ReadPrec (Application m)
ReadS [Application m]
forall m. (Read m, Ord m) => ReadPrec [Application m]
forall m. (Read m, Ord m) => ReadPrec (Application m)
forall m. (Read m, Ord m) => Int -> ReadS (Application m)
forall m. (Read m, Ord m) => ReadS [Application m]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Application m]
$creadListPrec :: forall m. (Read m, Ord m) => ReadPrec [Application m]
readPrec :: ReadPrec (Application m)
$creadPrec :: forall m. (Read m, Ord m) => ReadPrec (Application m)
readList :: ReadS [Application m]
$creadList :: forall m. (Read m, Ord m) => ReadS [Application m]
readsPrec :: Int -> ReadS (Application m)
$creadsPrec :: forall m. (Read m, Ord m) => Int -> ReadS (Application m)
Read, Int -> Application m -> ShowS
forall m. Show m => Int -> Application m -> ShowS
forall m. Show m => [Application m] -> ShowS
forall m. Show m => Application m -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Application m] -> ShowS
$cshowList :: forall m. Show m => [Application m] -> ShowS
show :: Application m -> String
$cshow :: forall m. Show m => Application m -> String
showsPrec :: Int -> Application m -> ShowS
$cshowsPrec :: forall m. Show m => Int -> Application m -> ShowS
Show)

_Application :: Name
_Application = (String -> Name
Name String
"hydra/core.Application")

_Application_function :: FieldName
_Application_function = (String -> FieldName
FieldName String
"function")

_Application_argument :: FieldName
_Application_argument = (String -> FieldName
FieldName String
"argument")

-- | The type-level analog of an application term
data ApplicationType m = 
  ApplicationType {
    -- | The left-hand side of the application
    forall m. ApplicationType m -> Type m
applicationTypeFunction :: (Type m),
    -- | The right-hand side of the application
    forall m. ApplicationType m -> Type m
applicationTypeArgument :: (Type m)}
  deriving (ApplicationType m -> ApplicationType m -> Bool
forall m. Eq m => ApplicationType m -> ApplicationType m -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ApplicationType m -> ApplicationType m -> Bool
$c/= :: forall m. Eq m => ApplicationType m -> ApplicationType m -> Bool
== :: ApplicationType m -> ApplicationType m -> Bool
$c== :: forall m. Eq m => ApplicationType m -> ApplicationType m -> Bool
Eq, ApplicationType m -> ApplicationType m -> Bool
ApplicationType m -> ApplicationType m -> Ordering
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
forall {m}. Ord m => Eq (ApplicationType m)
forall m. Ord m => ApplicationType m -> ApplicationType m -> Bool
forall m.
Ord m =>
ApplicationType m -> ApplicationType m -> Ordering
forall m.
Ord m =>
ApplicationType m -> ApplicationType m -> ApplicationType m
min :: ApplicationType m -> ApplicationType m -> ApplicationType m
$cmin :: forall m.
Ord m =>
ApplicationType m -> ApplicationType m -> ApplicationType m
max :: ApplicationType m -> ApplicationType m -> ApplicationType m
$cmax :: forall m.
Ord m =>
ApplicationType m -> ApplicationType m -> ApplicationType m
>= :: ApplicationType m -> ApplicationType m -> Bool
$c>= :: forall m. Ord m => ApplicationType m -> ApplicationType m -> Bool
> :: ApplicationType m -> ApplicationType m -> Bool
$c> :: forall m. Ord m => ApplicationType m -> ApplicationType m -> Bool
<= :: ApplicationType m -> ApplicationType m -> Bool
$c<= :: forall m. Ord m => ApplicationType m -> ApplicationType m -> Bool
< :: ApplicationType m -> ApplicationType m -> Bool
$c< :: forall m. Ord m => ApplicationType m -> ApplicationType m -> Bool
compare :: ApplicationType m -> ApplicationType m -> Ordering
$ccompare :: forall m.
Ord m =>
ApplicationType m -> ApplicationType m -> Ordering
Ord, ReadPrec [ApplicationType m]
ReadPrec (ApplicationType m)
ReadS [ApplicationType m]
forall m. Read m => ReadPrec [ApplicationType m]
forall m. Read m => ReadPrec (ApplicationType m)
forall m. Read m => Int -> ReadS (ApplicationType m)
forall m. Read m => ReadS [ApplicationType m]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ApplicationType m]
$creadListPrec :: forall m. Read m => ReadPrec [ApplicationType m]
readPrec :: ReadPrec (ApplicationType m)
$creadPrec :: forall m. Read m => ReadPrec (ApplicationType m)
readList :: ReadS [ApplicationType m]
$creadList :: forall m. Read m => ReadS [ApplicationType m]
readsPrec :: Int -> ReadS (ApplicationType m)
$creadsPrec :: forall m. Read m => Int -> ReadS (ApplicationType m)
Read, Int -> ApplicationType m -> ShowS
forall m. Show m => Int -> ApplicationType m -> ShowS
forall m. Show m => [ApplicationType m] -> ShowS
forall m. Show m => ApplicationType m -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ApplicationType m] -> ShowS
$cshowList :: forall m. Show m => [ApplicationType m] -> ShowS
show :: ApplicationType m -> String
$cshow :: forall m. Show m => ApplicationType m -> String
showsPrec :: Int -> ApplicationType m -> ShowS
$cshowsPrec :: forall m. Show m => Int -> ApplicationType m -> ShowS
Show)

_ApplicationType :: Name
_ApplicationType = (String -> Name
Name String
"hydra/core.ApplicationType")

_ApplicationType_function :: FieldName
_ApplicationType_function = (String -> FieldName
FieldName String
"function")

_ApplicationType_argument :: FieldName
_ApplicationType_argument = (String -> FieldName
FieldName String
"argument")

-- | A union elimination; a case statement
data CaseStatement m = 
  CaseStatement {
    forall m. CaseStatement m -> Name
caseStatementTypeName :: Name,
    forall m. CaseStatement m -> [Field m]
caseStatementCases :: [Field m]}
  deriving (CaseStatement m -> CaseStatement m -> Bool
forall m. Eq m => CaseStatement m -> CaseStatement m -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CaseStatement m -> CaseStatement m -> Bool
$c/= :: forall m. Eq m => CaseStatement m -> CaseStatement m -> Bool
== :: CaseStatement m -> CaseStatement m -> Bool
$c== :: forall m. Eq m => CaseStatement m -> CaseStatement m -> Bool
Eq, CaseStatement m -> CaseStatement m -> Bool
CaseStatement m -> CaseStatement m -> Ordering
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
forall {m}. Ord m => Eq (CaseStatement m)
forall m. Ord m => CaseStatement m -> CaseStatement m -> Bool
forall m. Ord m => CaseStatement m -> CaseStatement m -> Ordering
forall m.
Ord m =>
CaseStatement m -> CaseStatement m -> CaseStatement m
min :: CaseStatement m -> CaseStatement m -> CaseStatement m
$cmin :: forall m.
Ord m =>
CaseStatement m -> CaseStatement m -> CaseStatement m
max :: CaseStatement m -> CaseStatement m -> CaseStatement m
$cmax :: forall m.
Ord m =>
CaseStatement m -> CaseStatement m -> CaseStatement m
>= :: CaseStatement m -> CaseStatement m -> Bool
$c>= :: forall m. Ord m => CaseStatement m -> CaseStatement m -> Bool
> :: CaseStatement m -> CaseStatement m -> Bool
$c> :: forall m. Ord m => CaseStatement m -> CaseStatement m -> Bool
<= :: CaseStatement m -> CaseStatement m -> Bool
$c<= :: forall m. Ord m => CaseStatement m -> CaseStatement m -> Bool
< :: CaseStatement m -> CaseStatement m -> Bool
$c< :: forall m. Ord m => CaseStatement m -> CaseStatement m -> Bool
compare :: CaseStatement m -> CaseStatement m -> Ordering
$ccompare :: forall m. Ord m => CaseStatement m -> CaseStatement m -> Ordering
Ord, ReadPrec [CaseStatement m]
ReadPrec (CaseStatement m)
ReadS [CaseStatement m]
forall m. (Read m, Ord m) => ReadPrec [CaseStatement m]
forall m. (Read m, Ord m) => ReadPrec (CaseStatement m)
forall m. (Read m, Ord m) => Int -> ReadS (CaseStatement m)
forall m. (Read m, Ord m) => ReadS [CaseStatement m]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CaseStatement m]
$creadListPrec :: forall m. (Read m, Ord m) => ReadPrec [CaseStatement m]
readPrec :: ReadPrec (CaseStatement m)
$creadPrec :: forall m. (Read m, Ord m) => ReadPrec (CaseStatement m)
readList :: ReadS [CaseStatement m]
$creadList :: forall m. (Read m, Ord m) => ReadS [CaseStatement m]
readsPrec :: Int -> ReadS (CaseStatement m)
$creadsPrec :: forall m. (Read m, Ord m) => Int -> ReadS (CaseStatement m)
Read, Int -> CaseStatement m -> ShowS
forall m. Show m => Int -> CaseStatement m -> ShowS
forall m. Show m => [CaseStatement m] -> ShowS
forall m. Show m => CaseStatement m -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CaseStatement m] -> ShowS
$cshowList :: forall m. Show m => [CaseStatement m] -> ShowS
show :: CaseStatement m -> String
$cshow :: forall m. Show m => CaseStatement m -> String
showsPrec :: Int -> CaseStatement m -> ShowS
$cshowsPrec :: forall m. Show m => Int -> CaseStatement m -> ShowS
Show)

_CaseStatement :: Name
_CaseStatement = (String -> Name
Name String
"hydra/core.CaseStatement")

_CaseStatement_typeName :: FieldName
_CaseStatement_typeName = (String -> FieldName
FieldName String
"typeName")

_CaseStatement_cases :: FieldName
_CaseStatement_cases = (String -> FieldName
FieldName String
"cases")

-- | A corresponding elimination for an introduction term
data Elimination m = 
  -- | Eliminates an element by mapping it to its data term. This is Hydra's delta function.
  EliminationElement  |
  -- | Eliminates a list using a fold function; this function has the signature b -> [a] -> b
  EliminationList (Term m) |
  -- | Eliminates a nominal term by extracting the wrapped term
  EliminationNominal Name |
  -- | Eliminates an optional term by matching over the two possible cases
  EliminationOptional (OptionalCases m) |
  -- | Eliminates a record by projecting a given field
  EliminationRecord Projection |
  -- | Eliminates a union term by matching over the fields of the union. This is a case statement.
  EliminationUnion (CaseStatement m)
  deriving (Elimination m -> Elimination m -> Bool
forall m. Eq m => Elimination m -> Elimination m -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Elimination m -> Elimination m -> Bool
$c/= :: forall m. Eq m => Elimination m -> Elimination m -> Bool
== :: Elimination m -> Elimination m -> Bool
$c== :: forall m. Eq m => Elimination m -> Elimination m -> Bool
Eq, Elimination m -> Elimination m -> Ordering
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
forall {m}. Ord m => Eq (Elimination m)
forall m. Ord m => Elimination m -> Elimination m -> Bool
forall m. Ord m => Elimination m -> Elimination m -> Ordering
forall m. Ord m => Elimination m -> Elimination m -> Elimination m
min :: Elimination m -> Elimination m -> Elimination m
$cmin :: forall m. Ord m => Elimination m -> Elimination m -> Elimination m
max :: Elimination m -> Elimination m -> Elimination m
$cmax :: forall m. Ord m => Elimination m -> Elimination m -> Elimination m
>= :: Elimination m -> Elimination m -> Bool
$c>= :: forall m. Ord m => Elimination m -> Elimination m -> Bool
> :: Elimination m -> Elimination m -> Bool
$c> :: forall m. Ord m => Elimination m -> Elimination m -> Bool
<= :: Elimination m -> Elimination m -> Bool
$c<= :: forall m. Ord m => Elimination m -> Elimination m -> Bool
< :: Elimination m -> Elimination m -> Bool
$c< :: forall m. Ord m => Elimination m -> Elimination m -> Bool
compare :: Elimination m -> Elimination m -> Ordering
$ccompare :: forall m. Ord m => Elimination m -> Elimination m -> Ordering
Ord, ReadPrec [Elimination m]
ReadPrec (Elimination m)
ReadS [Elimination m]
forall m. (Read m, Ord m) => ReadPrec [Elimination m]
forall m. (Read m, Ord m) => ReadPrec (Elimination m)
forall m. (Read m, Ord m) => Int -> ReadS (Elimination m)
forall m. (Read m, Ord m) => ReadS [Elimination m]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Elimination m]
$creadListPrec :: forall m. (Read m, Ord m) => ReadPrec [Elimination m]
readPrec :: ReadPrec (Elimination m)
$creadPrec :: forall m. (Read m, Ord m) => ReadPrec (Elimination m)
readList :: ReadS [Elimination m]
$creadList :: forall m. (Read m, Ord m) => ReadS [Elimination m]
readsPrec :: Int -> ReadS (Elimination m)
$creadsPrec :: forall m. (Read m, Ord m) => Int -> ReadS (Elimination m)
Read, Int -> Elimination m -> ShowS
forall m. Show m => Int -> Elimination m -> ShowS
forall m. Show m => [Elimination m] -> ShowS
forall m. Show m => Elimination m -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Elimination m] -> ShowS
$cshowList :: forall m. Show m => [Elimination m] -> ShowS
show :: Elimination m -> String
$cshow :: forall m. Show m => Elimination m -> String
showsPrec :: Int -> Elimination m -> ShowS
$cshowsPrec :: forall m. Show m => Int -> Elimination m -> ShowS
Show)

_Elimination :: Name
_Elimination = (String -> Name
Name String
"hydra/core.Elimination")

_Elimination_element :: FieldName
_Elimination_element = (String -> FieldName
FieldName String
"element")

_Elimination_list :: FieldName
_Elimination_list = (String -> FieldName
FieldName String
"list")

_Elimination_nominal :: FieldName
_Elimination_nominal = (String -> FieldName
FieldName String
"nominal")

_Elimination_optional :: FieldName
_Elimination_optional = (String -> FieldName
FieldName String
"optional")

_Elimination_record :: FieldName
_Elimination_record = (String -> FieldName
FieldName String
"record")

_Elimination_union :: FieldName
_Elimination_union = (String -> FieldName
FieldName String
"union")

-- | A labeled term
data Field m = 
  Field {
    forall m. Field m -> FieldName
fieldName :: FieldName,
    forall m. Field m -> Term m
fieldTerm :: (Term m)}
  deriving (Field m -> Field m -> Bool
forall m. Eq m => Field m -> Field m -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Field m -> Field m -> Bool
$c/= :: forall m. Eq m => Field m -> Field m -> Bool
== :: Field m -> Field m -> Bool
$c== :: forall m. Eq m => Field m -> Field m -> Bool
Eq, Field m -> Field m -> Bool
Field m -> Field m -> Ordering
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
forall {m}. Ord m => Eq (Field m)
forall m. Ord m => Field m -> Field m -> Bool
forall m. Ord m => Field m -> Field m -> Ordering
forall m. Ord m => Field m -> Field m -> Field m
min :: Field m -> Field m -> Field m
$cmin :: forall m. Ord m => Field m -> Field m -> Field m
max :: Field m -> Field m -> Field m
$cmax :: forall m. Ord m => Field m -> Field m -> Field m
>= :: Field m -> Field m -> Bool
$c>= :: forall m. Ord m => Field m -> Field m -> Bool
> :: Field m -> Field m -> Bool
$c> :: forall m. Ord m => Field m -> Field m -> Bool
<= :: Field m -> Field m -> Bool
$c<= :: forall m. Ord m => Field m -> Field m -> Bool
< :: Field m -> Field m -> Bool
$c< :: forall m. Ord m => Field m -> Field m -> Bool
compare :: Field m -> Field m -> Ordering
$ccompare :: forall m. Ord m => Field m -> Field m -> Ordering
Ord, ReadPrec [Field m]
ReadPrec (Field m)
ReadS [Field m]
forall m. (Read m, Ord m) => ReadPrec [Field m]
forall m. (Read m, Ord m) => ReadPrec (Field m)
forall m. (Read m, Ord m) => Int -> ReadS (Field m)
forall m. (Read m, Ord m) => ReadS [Field m]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Field m]
$creadListPrec :: forall m. (Read m, Ord m) => ReadPrec [Field m]
readPrec :: ReadPrec (Field m)
$creadPrec :: forall m. (Read m, Ord m) => ReadPrec (Field m)
readList :: ReadS [Field m]
$creadList :: forall m. (Read m, Ord m) => ReadS [Field m]
readsPrec :: Int -> ReadS (Field m)
$creadsPrec :: forall m. (Read m, Ord m) => Int -> ReadS (Field m)
Read, Int -> Field m -> ShowS
forall m. Show m => Int -> Field m -> ShowS
forall m. Show m => [Field m] -> ShowS
forall m. Show m => Field m -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Field m] -> ShowS
$cshowList :: forall m. Show m => [Field m] -> ShowS
show :: Field m -> String
$cshow :: forall m. Show m => Field m -> String
showsPrec :: Int -> Field m -> ShowS
$cshowsPrec :: forall m. Show m => Int -> Field m -> ShowS
Show)

_Field :: Name
_Field = (String -> Name
Name String
"hydra/core.Field")

_Field_name :: FieldName
_Field_name = (String -> FieldName
FieldName String
"name")

_Field_term :: FieldName
_Field_term = (String -> FieldName
FieldName String
"term")

-- | The name of a field, unique within a record or union type
newtype FieldName = 
  FieldName {
    -- | The name of a field, unique within a record or union type
    FieldName -> String
unFieldName :: String}
  deriving (FieldName -> FieldName -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FieldName -> FieldName -> Bool
$c/= :: FieldName -> FieldName -> Bool
== :: FieldName -> FieldName -> Bool
$c== :: FieldName -> FieldName -> Bool
Eq, Eq FieldName
FieldName -> FieldName -> Bool
FieldName -> FieldName -> Ordering
FieldName -> FieldName -> FieldName
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
min :: FieldName -> FieldName -> FieldName
$cmin :: FieldName -> FieldName -> FieldName
max :: FieldName -> FieldName -> FieldName
$cmax :: FieldName -> FieldName -> FieldName
>= :: FieldName -> FieldName -> Bool
$c>= :: FieldName -> FieldName -> Bool
> :: FieldName -> FieldName -> Bool
$c> :: FieldName -> FieldName -> Bool
<= :: FieldName -> FieldName -> Bool
$c<= :: FieldName -> FieldName -> Bool
< :: FieldName -> FieldName -> Bool
$c< :: FieldName -> FieldName -> Bool
compare :: FieldName -> FieldName -> Ordering
$ccompare :: FieldName -> FieldName -> Ordering
Ord, ReadPrec [FieldName]
ReadPrec FieldName
Int -> ReadS FieldName
ReadS [FieldName]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [FieldName]
$creadListPrec :: ReadPrec [FieldName]
readPrec :: ReadPrec FieldName
$creadPrec :: ReadPrec FieldName
readList :: ReadS [FieldName]
$creadList :: ReadS [FieldName]
readsPrec :: Int -> ReadS FieldName
$creadsPrec :: Int -> ReadS FieldName
Read, Int -> FieldName -> ShowS
[FieldName] -> ShowS
FieldName -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FieldName] -> ShowS
$cshowList :: [FieldName] -> ShowS
show :: FieldName -> String
$cshow :: FieldName -> String
showsPrec :: Int -> FieldName -> ShowS
$cshowsPrec :: Int -> FieldName -> ShowS
Show)

_FieldName :: Name
_FieldName = (String -> Name
Name String
"hydra/core.FieldName")

-- | The name and type of a field
data FieldType m = 
  FieldType {
    forall m. FieldType m -> FieldName
fieldTypeName :: FieldName,
    forall m. FieldType m -> Type m
fieldTypeType :: (Type m)}
  deriving (FieldType m -> FieldType m -> Bool
forall m. Eq m => FieldType m -> FieldType m -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FieldType m -> FieldType m -> Bool
$c/= :: forall m. Eq m => FieldType m -> FieldType m -> Bool
== :: FieldType m -> FieldType m -> Bool
$c== :: forall m. Eq m => FieldType m -> FieldType m -> Bool
Eq, FieldType m -> FieldType m -> Bool
FieldType m -> FieldType m -> Ordering
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
forall {m}. Ord m => Eq (FieldType m)
forall m. Ord m => FieldType m -> FieldType m -> Bool
forall m. Ord m => FieldType m -> FieldType m -> Ordering
forall m. Ord m => FieldType m -> FieldType m -> FieldType m
min :: FieldType m -> FieldType m -> FieldType m
$cmin :: forall m. Ord m => FieldType m -> FieldType m -> FieldType m
max :: FieldType m -> FieldType m -> FieldType m
$cmax :: forall m. Ord m => FieldType m -> FieldType m -> FieldType m
>= :: FieldType m -> FieldType m -> Bool
$c>= :: forall m. Ord m => FieldType m -> FieldType m -> Bool
> :: FieldType m -> FieldType m -> Bool
$c> :: forall m. Ord m => FieldType m -> FieldType m -> Bool
<= :: FieldType m -> FieldType m -> Bool
$c<= :: forall m. Ord m => FieldType m -> FieldType m -> Bool
< :: FieldType m -> FieldType m -> Bool
$c< :: forall m. Ord m => FieldType m -> FieldType m -> Bool
compare :: FieldType m -> FieldType m -> Ordering
$ccompare :: forall m. Ord m => FieldType m -> FieldType m -> Ordering
Ord, ReadPrec [FieldType m]
ReadPrec (FieldType m)
ReadS [FieldType m]
forall m. Read m => ReadPrec [FieldType m]
forall m. Read m => ReadPrec (FieldType m)
forall m. Read m => Int -> ReadS (FieldType m)
forall m. Read m => ReadS [FieldType m]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [FieldType m]
$creadListPrec :: forall m. Read m => ReadPrec [FieldType m]
readPrec :: ReadPrec (FieldType m)
$creadPrec :: forall m. Read m => ReadPrec (FieldType m)
readList :: ReadS [FieldType m]
$creadList :: forall m. Read m => ReadS [FieldType m]
readsPrec :: Int -> ReadS (FieldType m)
$creadsPrec :: forall m. Read m => Int -> ReadS (FieldType m)
Read, Int -> FieldType m -> ShowS
forall m. Show m => Int -> FieldType m -> ShowS
forall m. Show m => [FieldType m] -> ShowS
forall m. Show m => FieldType m -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FieldType m] -> ShowS
$cshowList :: forall m. Show m => [FieldType m] -> ShowS
show :: FieldType m -> String
$cshow :: forall m. Show m => FieldType m -> String
showsPrec :: Int -> FieldType m -> ShowS
$cshowsPrec :: forall m. Show m => Int -> FieldType m -> ShowS
Show)

_FieldType :: Name
_FieldType = (String -> Name
Name String
"hydra/core.FieldType")

_FieldType_name :: FieldName
_FieldType_name = (String -> FieldName
FieldName String
"name")

_FieldType_type :: FieldName
_FieldType_type = (String -> FieldName
FieldName String
"type")

-- | A floating-point type
data FloatType = 
  FloatTypeBigfloat  |
  FloatTypeFloat32  |
  FloatTypeFloat64 
  deriving (FloatType -> FloatType -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FloatType -> FloatType -> Bool
$c/= :: FloatType -> FloatType -> Bool
== :: FloatType -> FloatType -> Bool
$c== :: FloatType -> FloatType -> Bool
Eq, Eq FloatType
FloatType -> FloatType -> Bool
FloatType -> FloatType -> Ordering
FloatType -> FloatType -> FloatType
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
min :: FloatType -> FloatType -> FloatType
$cmin :: FloatType -> FloatType -> FloatType
max :: FloatType -> FloatType -> FloatType
$cmax :: FloatType -> FloatType -> FloatType
>= :: FloatType -> FloatType -> Bool
$c>= :: FloatType -> FloatType -> Bool
> :: FloatType -> FloatType -> Bool
$c> :: FloatType -> FloatType -> Bool
<= :: FloatType -> FloatType -> Bool
$c<= :: FloatType -> FloatType -> Bool
< :: FloatType -> FloatType -> Bool
$c< :: FloatType -> FloatType -> Bool
compare :: FloatType -> FloatType -> Ordering
$ccompare :: FloatType -> FloatType -> Ordering
Ord, ReadPrec [FloatType]
ReadPrec FloatType
Int -> ReadS FloatType
ReadS [FloatType]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [FloatType]
$creadListPrec :: ReadPrec [FloatType]
readPrec :: ReadPrec FloatType
$creadPrec :: ReadPrec FloatType
readList :: ReadS [FloatType]
$creadList :: ReadS [FloatType]
readsPrec :: Int -> ReadS FloatType
$creadsPrec :: Int -> ReadS FloatType
Read, Int -> FloatType -> ShowS
[FloatType] -> ShowS
FloatType -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FloatType] -> ShowS
$cshowList :: [FloatType] -> ShowS
show :: FloatType -> String
$cshow :: FloatType -> String
showsPrec :: Int -> FloatType -> ShowS
$cshowsPrec :: Int -> FloatType -> ShowS
Show)

_FloatType :: Name
_FloatType = (String -> Name
Name String
"hydra/core.FloatType")

_FloatType_bigfloat :: FieldName
_FloatType_bigfloat = (String -> FieldName
FieldName String
"bigfloat")

_FloatType_float32 :: FieldName
_FloatType_float32 = (String -> FieldName
FieldName String
"float32")

_FloatType_float64 :: FieldName
_FloatType_float64 = (String -> FieldName
FieldName String
"float64")

-- | A floating-point literal value
data FloatValue = 
  -- | An arbitrary-precision floating-point value
  FloatValueBigfloat Double |
  -- | A 32-bit floating-point value
  FloatValueFloat32 Float |
  -- | A 64-bit floating-point value
  FloatValueFloat64 Double
  deriving (FloatValue -> FloatValue -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FloatValue -> FloatValue -> Bool
$c/= :: FloatValue -> FloatValue -> Bool
== :: FloatValue -> FloatValue -> Bool
$c== :: FloatValue -> FloatValue -> Bool
Eq, Eq FloatValue
FloatValue -> FloatValue -> Bool
FloatValue -> FloatValue -> Ordering
FloatValue -> FloatValue -> FloatValue
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
min :: FloatValue -> FloatValue -> FloatValue
$cmin :: FloatValue -> FloatValue -> FloatValue
max :: FloatValue -> FloatValue -> FloatValue
$cmax :: FloatValue -> FloatValue -> FloatValue
>= :: FloatValue -> FloatValue -> Bool
$c>= :: FloatValue -> FloatValue -> Bool
> :: FloatValue -> FloatValue -> Bool
$c> :: FloatValue -> FloatValue -> Bool
<= :: FloatValue -> FloatValue -> Bool
$c<= :: FloatValue -> FloatValue -> Bool
< :: FloatValue -> FloatValue -> Bool
$c< :: FloatValue -> FloatValue -> Bool
compare :: FloatValue -> FloatValue -> Ordering
$ccompare :: FloatValue -> FloatValue -> Ordering
Ord, ReadPrec [FloatValue]
ReadPrec FloatValue
Int -> ReadS FloatValue
ReadS [FloatValue]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [FloatValue]
$creadListPrec :: ReadPrec [FloatValue]
readPrec :: ReadPrec FloatValue
$creadPrec :: ReadPrec FloatValue
readList :: ReadS [FloatValue]
$creadList :: ReadS [FloatValue]
readsPrec :: Int -> ReadS FloatValue
$creadsPrec :: Int -> ReadS FloatValue
Read, Int -> FloatValue -> ShowS
[FloatValue] -> ShowS
FloatValue -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FloatValue] -> ShowS
$cshowList :: [FloatValue] -> ShowS
show :: FloatValue -> String
$cshow :: FloatValue -> String
showsPrec :: Int -> FloatValue -> ShowS
$cshowsPrec :: Int -> FloatValue -> ShowS
Show)

_FloatValue :: Name
_FloatValue = (String -> Name
Name String
"hydra/core.FloatValue")

_FloatValue_bigfloat :: FieldName
_FloatValue_bigfloat = (String -> FieldName
FieldName String
"bigfloat")

_FloatValue_float32 :: FieldName
_FloatValue_float32 = (String -> FieldName
FieldName String
"float32")

_FloatValue_float64 :: FieldName
_FloatValue_float64 = (String -> FieldName
FieldName String
"float64")

-- | A function
data Function m = 
  -- | Compares a term with a given term of the same type, producing a Comparison
  FunctionCompareTo (Term m) |
  -- | An elimination for any of a few term variants
  FunctionElimination (Elimination m) |
  -- | A function abstraction (lambda)
  FunctionLambda (Lambda m) |
  -- | A reference to a built-in (primitive) function
  FunctionPrimitive Name
  deriving (Function m -> Function m -> Bool
forall m. Eq m => Function m -> Function m -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Function m -> Function m -> Bool
$c/= :: forall m. Eq m => Function m -> Function m -> Bool
== :: Function m -> Function m -> Bool
$c== :: forall m. Eq m => Function m -> Function m -> Bool
Eq, Function m -> Function m -> Ordering
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
forall {m}. Ord m => Eq (Function m)
forall m. Ord m => Function m -> Function m -> Bool
forall m. Ord m => Function m -> Function m -> Ordering
forall m. Ord m => Function m -> Function m -> Function m
min :: Function m -> Function m -> Function m
$cmin :: forall m. Ord m => Function m -> Function m -> Function m
max :: Function m -> Function m -> Function m
$cmax :: forall m. Ord m => Function m -> Function m -> Function m
>= :: Function m -> Function m -> Bool
$c>= :: forall m. Ord m => Function m -> Function m -> Bool
> :: Function m -> Function m -> Bool
$c> :: forall m. Ord m => Function m -> Function m -> Bool
<= :: Function m -> Function m -> Bool
$c<= :: forall m. Ord m => Function m -> Function m -> Bool
< :: Function m -> Function m -> Bool
$c< :: forall m. Ord m => Function m -> Function m -> Bool
compare :: Function m -> Function m -> Ordering
$ccompare :: forall m. Ord m => Function m -> Function m -> Ordering
Ord, ReadPrec [Function m]
ReadPrec (Function m)
ReadS [Function m]
forall m. (Read m, Ord m) => ReadPrec [Function m]
forall m. (Read m, Ord m) => ReadPrec (Function m)
forall m. (Read m, Ord m) => Int -> ReadS (Function m)
forall m. (Read m, Ord m) => ReadS [Function m]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Function m]
$creadListPrec :: forall m. (Read m, Ord m) => ReadPrec [Function m]
readPrec :: ReadPrec (Function m)
$creadPrec :: forall m. (Read m, Ord m) => ReadPrec (Function m)
readList :: ReadS [Function m]
$creadList :: forall m. (Read m, Ord m) => ReadS [Function m]
readsPrec :: Int -> ReadS (Function m)
$creadsPrec :: forall m. (Read m, Ord m) => Int -> ReadS (Function m)
Read, Int -> Function m -> ShowS
forall m. Show m => Int -> Function m -> ShowS
forall m. Show m => [Function m] -> ShowS
forall m. Show m => Function m -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Function m] -> ShowS
$cshowList :: forall m. Show m => [Function m] -> ShowS
show :: Function m -> String
$cshow :: forall m. Show m => Function m -> String
showsPrec :: Int -> Function m -> ShowS
$cshowsPrec :: forall m. Show m => Int -> Function m -> ShowS
Show)

_Function :: Name
_Function = (String -> Name
Name String
"hydra/core.Function")

_Function_compareTo :: FieldName
_Function_compareTo = (String -> FieldName
FieldName String
"compareTo")

_Function_elimination :: FieldName
_Function_elimination = (String -> FieldName
FieldName String
"elimination")

_Function_lambda :: FieldName
_Function_lambda = (String -> FieldName
FieldName String
"lambda")

_Function_primitive :: FieldName
_Function_primitive = (String -> FieldName
FieldName String
"primitive")

-- | A function type, also known as an arrow type
data FunctionType m = 
  FunctionType {
    forall m. FunctionType m -> Type m
functionTypeDomain :: (Type m),
    forall m. FunctionType m -> Type m
functionTypeCodomain :: (Type m)}
  deriving (FunctionType m -> FunctionType m -> Bool
forall m. Eq m => FunctionType m -> FunctionType m -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FunctionType m -> FunctionType m -> Bool
$c/= :: forall m. Eq m => FunctionType m -> FunctionType m -> Bool
== :: FunctionType m -> FunctionType m -> Bool
$c== :: forall m. Eq m => FunctionType m -> FunctionType m -> Bool
Eq, FunctionType m -> FunctionType m -> Bool
FunctionType m -> FunctionType m -> Ordering
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
forall {m}. Ord m => Eq (FunctionType m)
forall m. Ord m => FunctionType m -> FunctionType m -> Bool
forall m. Ord m => FunctionType m -> FunctionType m -> Ordering
forall m.
Ord m =>
FunctionType m -> FunctionType m -> FunctionType m
min :: FunctionType m -> FunctionType m -> FunctionType m
$cmin :: forall m.
Ord m =>
FunctionType m -> FunctionType m -> FunctionType m
max :: FunctionType m -> FunctionType m -> FunctionType m
$cmax :: forall m.
Ord m =>
FunctionType m -> FunctionType m -> FunctionType m
>= :: FunctionType m -> FunctionType m -> Bool
$c>= :: forall m. Ord m => FunctionType m -> FunctionType m -> Bool
> :: FunctionType m -> FunctionType m -> Bool
$c> :: forall m. Ord m => FunctionType m -> FunctionType m -> Bool
<= :: FunctionType m -> FunctionType m -> Bool
$c<= :: forall m. Ord m => FunctionType m -> FunctionType m -> Bool
< :: FunctionType m -> FunctionType m -> Bool
$c< :: forall m. Ord m => FunctionType m -> FunctionType m -> Bool
compare :: FunctionType m -> FunctionType m -> Ordering
$ccompare :: forall m. Ord m => FunctionType m -> FunctionType m -> Ordering
Ord, ReadPrec [FunctionType m]
ReadPrec (FunctionType m)
ReadS [FunctionType m]
forall m. Read m => ReadPrec [FunctionType m]
forall m. Read m => ReadPrec (FunctionType m)
forall m. Read m => Int -> ReadS (FunctionType m)
forall m. Read m => ReadS [FunctionType m]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [FunctionType m]
$creadListPrec :: forall m. Read m => ReadPrec [FunctionType m]
readPrec :: ReadPrec (FunctionType m)
$creadPrec :: forall m. Read m => ReadPrec (FunctionType m)
readList :: ReadS [FunctionType m]
$creadList :: forall m. Read m => ReadS [FunctionType m]
readsPrec :: Int -> ReadS (FunctionType m)
$creadsPrec :: forall m. Read m => Int -> ReadS (FunctionType m)
Read, Int -> FunctionType m -> ShowS
forall m. Show m => Int -> FunctionType m -> ShowS
forall m. Show m => [FunctionType m] -> ShowS
forall m. Show m => FunctionType m -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FunctionType m] -> ShowS
$cshowList :: forall m. Show m => [FunctionType m] -> ShowS
show :: FunctionType m -> String
$cshow :: forall m. Show m => FunctionType m -> String
showsPrec :: Int -> FunctionType m -> ShowS
$cshowsPrec :: forall m. Show m => Int -> FunctionType m -> ShowS
Show)

_FunctionType :: Name
_FunctionType = (String -> Name
Name String
"hydra/core.FunctionType")

_FunctionType_domain :: FieldName
_FunctionType_domain = (String -> FieldName
FieldName String
"domain")

_FunctionType_codomain :: FieldName
_FunctionType_codomain = (String -> FieldName
FieldName String
"codomain")

-- | An integer type
data IntegerType = 
  IntegerTypeBigint  |
  IntegerTypeInt8  |
  IntegerTypeInt16  |
  IntegerTypeInt32  |
  IntegerTypeInt64  |
  IntegerTypeUint8  |
  IntegerTypeUint16  |
  IntegerTypeUint32  |
  IntegerTypeUint64 
  deriving (IntegerType -> IntegerType -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: IntegerType -> IntegerType -> Bool
$c/= :: IntegerType -> IntegerType -> Bool
== :: IntegerType -> IntegerType -> Bool
$c== :: IntegerType -> IntegerType -> Bool
Eq, Eq IntegerType
IntegerType -> IntegerType -> Bool
IntegerType -> IntegerType -> Ordering
IntegerType -> IntegerType -> IntegerType
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
min :: IntegerType -> IntegerType -> IntegerType
$cmin :: IntegerType -> IntegerType -> IntegerType
max :: IntegerType -> IntegerType -> IntegerType
$cmax :: IntegerType -> IntegerType -> IntegerType
>= :: IntegerType -> IntegerType -> Bool
$c>= :: IntegerType -> IntegerType -> Bool
> :: IntegerType -> IntegerType -> Bool
$c> :: IntegerType -> IntegerType -> Bool
<= :: IntegerType -> IntegerType -> Bool
$c<= :: IntegerType -> IntegerType -> Bool
< :: IntegerType -> IntegerType -> Bool
$c< :: IntegerType -> IntegerType -> Bool
compare :: IntegerType -> IntegerType -> Ordering
$ccompare :: IntegerType -> IntegerType -> Ordering
Ord, ReadPrec [IntegerType]
ReadPrec IntegerType
Int -> ReadS IntegerType
ReadS [IntegerType]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [IntegerType]
$creadListPrec :: ReadPrec [IntegerType]
readPrec :: ReadPrec IntegerType
$creadPrec :: ReadPrec IntegerType
readList :: ReadS [IntegerType]
$creadList :: ReadS [IntegerType]
readsPrec :: Int -> ReadS IntegerType
$creadsPrec :: Int -> ReadS IntegerType
Read, Int -> IntegerType -> ShowS
[IntegerType] -> ShowS
IntegerType -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [IntegerType] -> ShowS
$cshowList :: [IntegerType] -> ShowS
show :: IntegerType -> String
$cshow :: IntegerType -> String
showsPrec :: Int -> IntegerType -> ShowS
$cshowsPrec :: Int -> IntegerType -> ShowS
Show)

_IntegerType :: Name
_IntegerType = (String -> Name
Name String
"hydra/core.IntegerType")

_IntegerType_bigint :: FieldName
_IntegerType_bigint = (String -> FieldName
FieldName String
"bigint")

_IntegerType_int8 :: FieldName
_IntegerType_int8 = (String -> FieldName
FieldName String
"int8")

_IntegerType_int16 :: FieldName
_IntegerType_int16 = (String -> FieldName
FieldName String
"int16")

_IntegerType_int32 :: FieldName
_IntegerType_int32 = (String -> FieldName
FieldName String
"int32")

_IntegerType_int64 :: FieldName
_IntegerType_int64 = (String -> FieldName
FieldName String
"int64")

_IntegerType_uint8 :: FieldName
_IntegerType_uint8 = (String -> FieldName
FieldName String
"uint8")

_IntegerType_uint16 :: FieldName
_IntegerType_uint16 = (String -> FieldName
FieldName String
"uint16")

_IntegerType_uint32 :: FieldName
_IntegerType_uint32 = (String -> FieldName
FieldName String
"uint32")

_IntegerType_uint64 :: FieldName
_IntegerType_uint64 = (String -> FieldName
FieldName String
"uint64")

-- | An integer literal value
data IntegerValue = 
  -- | An arbitrary-precision integer value
  IntegerValueBigint Integer |
  -- | An 8-bit signed integer value
  IntegerValueInt8 Int |
  -- | A 16-bit signed integer value (short value)
  IntegerValueInt16 Int |
  -- | A 32-bit signed integer value (int value)
  IntegerValueInt32 Int |
  -- | A 64-bit signed integer value (long value)
  IntegerValueInt64 Integer |
  -- | An 8-bit unsigned integer value (byte)
  IntegerValueUint8 Int |
  -- | A 16-bit unsigned integer value
  IntegerValueUint16 Int |
  -- | A 32-bit unsigned integer value (unsigned int)
  IntegerValueUint32 Integer |
  -- | A 64-bit unsigned integer value (unsigned long)
  IntegerValueUint64 Integer
  deriving (IntegerValue -> IntegerValue -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: IntegerValue -> IntegerValue -> Bool
$c/= :: IntegerValue -> IntegerValue -> Bool
== :: IntegerValue -> IntegerValue -> Bool
$c== :: IntegerValue -> IntegerValue -> Bool
Eq, Eq IntegerValue
IntegerValue -> IntegerValue -> Bool
IntegerValue -> IntegerValue -> Ordering
IntegerValue -> IntegerValue -> IntegerValue
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
min :: IntegerValue -> IntegerValue -> IntegerValue
$cmin :: IntegerValue -> IntegerValue -> IntegerValue
max :: IntegerValue -> IntegerValue -> IntegerValue
$cmax :: IntegerValue -> IntegerValue -> IntegerValue
>= :: IntegerValue -> IntegerValue -> Bool
$c>= :: IntegerValue -> IntegerValue -> Bool
> :: IntegerValue -> IntegerValue -> Bool
$c> :: IntegerValue -> IntegerValue -> Bool
<= :: IntegerValue -> IntegerValue -> Bool
$c<= :: IntegerValue -> IntegerValue -> Bool
< :: IntegerValue -> IntegerValue -> Bool
$c< :: IntegerValue -> IntegerValue -> Bool
compare :: IntegerValue -> IntegerValue -> Ordering
$ccompare :: IntegerValue -> IntegerValue -> Ordering
Ord, ReadPrec [IntegerValue]
ReadPrec IntegerValue
Int -> ReadS IntegerValue
ReadS [IntegerValue]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [IntegerValue]
$creadListPrec :: ReadPrec [IntegerValue]
readPrec :: ReadPrec IntegerValue
$creadPrec :: ReadPrec IntegerValue
readList :: ReadS [IntegerValue]
$creadList :: ReadS [IntegerValue]
readsPrec :: Int -> ReadS IntegerValue
$creadsPrec :: Int -> ReadS IntegerValue
Read, Int -> IntegerValue -> ShowS
[IntegerValue] -> ShowS
IntegerValue -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [IntegerValue] -> ShowS
$cshowList :: [IntegerValue] -> ShowS
show :: IntegerValue -> String
$cshow :: IntegerValue -> String
showsPrec :: Int -> IntegerValue -> ShowS
$cshowsPrec :: Int -> IntegerValue -> ShowS
Show)

_IntegerValue :: Name
_IntegerValue = (String -> Name
Name String
"hydra/core.IntegerValue")

_IntegerValue_bigint :: FieldName
_IntegerValue_bigint = (String -> FieldName
FieldName String
"bigint")

_IntegerValue_int8 :: FieldName
_IntegerValue_int8 = (String -> FieldName
FieldName String
"int8")

_IntegerValue_int16 :: FieldName
_IntegerValue_int16 = (String -> FieldName
FieldName String
"int16")

_IntegerValue_int32 :: FieldName
_IntegerValue_int32 = (String -> FieldName
FieldName String
"int32")

_IntegerValue_int64 :: FieldName
_IntegerValue_int64 = (String -> FieldName
FieldName String
"int64")

_IntegerValue_uint8 :: FieldName
_IntegerValue_uint8 = (String -> FieldName
FieldName String
"uint8")

_IntegerValue_uint16 :: FieldName
_IntegerValue_uint16 = (String -> FieldName
FieldName String
"uint16")

_IntegerValue_uint32 :: FieldName
_IntegerValue_uint32 = (String -> FieldName
FieldName String
"uint32")

_IntegerValue_uint64 :: FieldName
_IntegerValue_uint64 = (String -> FieldName
FieldName String
"uint64")

-- | A function abstraction (lambda)
data Lambda m = 
  Lambda {
    -- | The parameter of the lambda
    forall m. Lambda m -> Variable
lambdaParameter :: Variable,
    -- | The body of the lambda
    forall m. Lambda m -> Term m
lambdaBody :: (Term m)}
  deriving (Lambda m -> Lambda m -> Bool
forall m. Eq m => Lambda m -> Lambda m -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Lambda m -> Lambda m -> Bool
$c/= :: forall m. Eq m => Lambda m -> Lambda m -> Bool
== :: Lambda m -> Lambda m -> Bool
$c== :: forall m. Eq m => Lambda m -> Lambda m -> Bool
Eq, Lambda m -> Lambda m -> Bool
Lambda m -> Lambda m -> Ordering
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
forall {m}. Ord m => Eq (Lambda m)
forall m. Ord m => Lambda m -> Lambda m -> Bool
forall m. Ord m => Lambda m -> Lambda m -> Ordering
forall m. Ord m => Lambda m -> Lambda m -> Lambda m
min :: Lambda m -> Lambda m -> Lambda m
$cmin :: forall m. Ord m => Lambda m -> Lambda m -> Lambda m
max :: Lambda m -> Lambda m -> Lambda m
$cmax :: forall m. Ord m => Lambda m -> Lambda m -> Lambda m
>= :: Lambda m -> Lambda m -> Bool
$c>= :: forall m. Ord m => Lambda m -> Lambda m -> Bool
> :: Lambda m -> Lambda m -> Bool
$c> :: forall m. Ord m => Lambda m -> Lambda m -> Bool
<= :: Lambda m -> Lambda m -> Bool
$c<= :: forall m. Ord m => Lambda m -> Lambda m -> Bool
< :: Lambda m -> Lambda m -> Bool
$c< :: forall m. Ord m => Lambda m -> Lambda m -> Bool
compare :: Lambda m -> Lambda m -> Ordering
$ccompare :: forall m. Ord m => Lambda m -> Lambda m -> Ordering
Ord, ReadPrec [Lambda m]
ReadPrec (Lambda m)
ReadS [Lambda m]
forall m. (Read m, Ord m) => ReadPrec [Lambda m]
forall m. (Read m, Ord m) => ReadPrec (Lambda m)
forall m. (Read m, Ord m) => Int -> ReadS (Lambda m)
forall m. (Read m, Ord m) => ReadS [Lambda m]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Lambda m]
$creadListPrec :: forall m. (Read m, Ord m) => ReadPrec [Lambda m]
readPrec :: ReadPrec (Lambda m)
$creadPrec :: forall m. (Read m, Ord m) => ReadPrec (Lambda m)
readList :: ReadS [Lambda m]
$creadList :: forall m. (Read m, Ord m) => ReadS [Lambda m]
readsPrec :: Int -> ReadS (Lambda m)
$creadsPrec :: forall m. (Read m, Ord m) => Int -> ReadS (Lambda m)
Read, Int -> Lambda m -> ShowS
forall m. Show m => Int -> Lambda m -> ShowS
forall m. Show m => [Lambda m] -> ShowS
forall m. Show m => Lambda m -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Lambda m] -> ShowS
$cshowList :: forall m. Show m => [Lambda m] -> ShowS
show :: Lambda m -> String
$cshow :: forall m. Show m => Lambda m -> String
showsPrec :: Int -> Lambda m -> ShowS
$cshowsPrec :: forall m. Show m => Int -> Lambda m -> ShowS
Show)

_Lambda :: Name
_Lambda = (String -> Name
Name String
"hydra/core.Lambda")

_Lambda_parameter :: FieldName
_Lambda_parameter = (String -> FieldName
FieldName String
"parameter")

_Lambda_body :: FieldName
_Lambda_body = (String -> FieldName
FieldName String
"body")

-- | A type abstraction; the type-level analog of a lambda term
data LambdaType m = 
  LambdaType {
    -- | The parameter of the lambda
    forall m. LambdaType m -> VariableType
lambdaTypeParameter :: VariableType,
    -- | The body of the lambda
    forall m. LambdaType m -> Type m
lambdaTypeBody :: (Type m)}
  deriving (LambdaType m -> LambdaType m -> Bool
forall m. Eq m => LambdaType m -> LambdaType m -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: LambdaType m -> LambdaType m -> Bool
$c/= :: forall m. Eq m => LambdaType m -> LambdaType m -> Bool
== :: LambdaType m -> LambdaType m -> Bool
$c== :: forall m. Eq m => LambdaType m -> LambdaType m -> Bool
Eq, LambdaType m -> LambdaType m -> Bool
LambdaType m -> LambdaType m -> Ordering
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
forall {m}. Ord m => Eq (LambdaType m)
forall m. Ord m => LambdaType m -> LambdaType m -> Bool
forall m. Ord m => LambdaType m -> LambdaType m -> Ordering
forall m. Ord m => LambdaType m -> LambdaType m -> LambdaType m
min :: LambdaType m -> LambdaType m -> LambdaType m
$cmin :: forall m. Ord m => LambdaType m -> LambdaType m -> LambdaType m
max :: LambdaType m -> LambdaType m -> LambdaType m
$cmax :: forall m. Ord m => LambdaType m -> LambdaType m -> LambdaType m
>= :: LambdaType m -> LambdaType m -> Bool
$c>= :: forall m. Ord m => LambdaType m -> LambdaType m -> Bool
> :: LambdaType m -> LambdaType m -> Bool
$c> :: forall m. Ord m => LambdaType m -> LambdaType m -> Bool
<= :: LambdaType m -> LambdaType m -> Bool
$c<= :: forall m. Ord m => LambdaType m -> LambdaType m -> Bool
< :: LambdaType m -> LambdaType m -> Bool
$c< :: forall m. Ord m => LambdaType m -> LambdaType m -> Bool
compare :: LambdaType m -> LambdaType m -> Ordering
$ccompare :: forall m. Ord m => LambdaType m -> LambdaType m -> Ordering
Ord, ReadPrec [LambdaType m]
ReadPrec (LambdaType m)
ReadS [LambdaType m]
forall m. Read m => ReadPrec [LambdaType m]
forall m. Read m => ReadPrec (LambdaType m)
forall m. Read m => Int -> ReadS (LambdaType m)
forall m. Read m => ReadS [LambdaType m]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [LambdaType m]
$creadListPrec :: forall m. Read m => ReadPrec [LambdaType m]
readPrec :: ReadPrec (LambdaType m)
$creadPrec :: forall m. Read m => ReadPrec (LambdaType m)
readList :: ReadS [LambdaType m]
$creadList :: forall m. Read m => ReadS [LambdaType m]
readsPrec :: Int -> ReadS (LambdaType m)
$creadsPrec :: forall m. Read m => Int -> ReadS (LambdaType m)
Read, Int -> LambdaType m -> ShowS
forall m. Show m => Int -> LambdaType m -> ShowS
forall m. Show m => [LambdaType m] -> ShowS
forall m. Show m => LambdaType m -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [LambdaType m] -> ShowS
$cshowList :: forall m. Show m => [LambdaType m] -> ShowS
show :: LambdaType m -> String
$cshow :: forall m. Show m => LambdaType m -> String
showsPrec :: Int -> LambdaType m -> ShowS
$cshowsPrec :: forall m. Show m => Int -> LambdaType m -> ShowS
Show)

_LambdaType :: Name
_LambdaType = (String -> Name
Name String
"hydra/core.LambdaType")

_LambdaType_parameter :: FieldName
_LambdaType_parameter = (String -> FieldName
FieldName String
"parameter")

_LambdaType_body :: FieldName
_LambdaType_body = (String -> FieldName
FieldName String
"body")

-- | A 'let' binding
data Let m = 
  Let {
    forall m. Let m -> Variable
letKey :: Variable,
    forall m. Let m -> Term m
letValue :: (Term m),
    forall m. Let m -> Term m
letEnvironment :: (Term m)}
  deriving (Let m -> Let m -> Bool
forall m. Eq m => Let m -> Let m -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Let m -> Let m -> Bool
$c/= :: forall m. Eq m => Let m -> Let m -> Bool
== :: Let m -> Let m -> Bool
$c== :: forall m. Eq m => Let m -> Let m -> Bool
Eq, Let m -> Let m -> Bool
Let m -> Let m -> Ordering
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
forall {m}. Ord m => Eq (Let m)
forall m. Ord m => Let m -> Let m -> Bool
forall m. Ord m => Let m -> Let m -> Ordering
forall m. Ord m => Let m -> Let m -> Let m
min :: Let m -> Let m -> Let m
$cmin :: forall m. Ord m => Let m -> Let m -> Let m
max :: Let m -> Let m -> Let m
$cmax :: forall m. Ord m => Let m -> Let m -> Let m
>= :: Let m -> Let m -> Bool
$c>= :: forall m. Ord m => Let m -> Let m -> Bool
> :: Let m -> Let m -> Bool
$c> :: forall m. Ord m => Let m -> Let m -> Bool
<= :: Let m -> Let m -> Bool
$c<= :: forall m. Ord m => Let m -> Let m -> Bool
< :: Let m -> Let m -> Bool
$c< :: forall m. Ord m => Let m -> Let m -> Bool
compare :: Let m -> Let m -> Ordering
$ccompare :: forall m. Ord m => Let m -> Let m -> Ordering
Ord, ReadPrec [Let m]
ReadPrec (Let m)
ReadS [Let m]
forall m. (Read m, Ord m) => ReadPrec [Let m]
forall m. (Read m, Ord m) => ReadPrec (Let m)
forall m. (Read m, Ord m) => Int -> ReadS (Let m)
forall m. (Read m, Ord m) => ReadS [Let m]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Let m]
$creadListPrec :: forall m. (Read m, Ord m) => ReadPrec [Let m]
readPrec :: ReadPrec (Let m)
$creadPrec :: forall m. (Read m, Ord m) => ReadPrec (Let m)
readList :: ReadS [Let m]
$creadList :: forall m. (Read m, Ord m) => ReadS [Let m]
readsPrec :: Int -> ReadS (Let m)
$creadsPrec :: forall m. (Read m, Ord m) => Int -> ReadS (Let m)
Read, Int -> Let m -> ShowS
forall m. Show m => Int -> Let m -> ShowS
forall m. Show m => [Let m] -> ShowS
forall m. Show m => Let m -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Let m] -> ShowS
$cshowList :: forall m. Show m => [Let m] -> ShowS
show :: Let m -> String
$cshow :: forall m. Show m => Let m -> String
showsPrec :: Int -> Let m -> ShowS
$cshowsPrec :: forall m. Show m => Int -> Let m -> ShowS
Show)

_Let :: Name
_Let = (String -> Name
Name String
"hydra/core.Let")

_Let_key :: FieldName
_Let_key = (String -> FieldName
FieldName String
"key")

_Let_value :: FieldName
_Let_value = (String -> FieldName
FieldName String
"value")

_Let_environment :: FieldName
_Let_environment = (String -> FieldName
FieldName String
"environment")

-- | A term constant; an instance of a literal type
data Literal = 
  -- | A binary literal
  LiteralBinary String |
  -- | A boolean literal
  LiteralBoolean Bool |
  -- | A floating-point literal
  LiteralFloat FloatValue |
  -- | An integer literal
  LiteralInteger IntegerValue |
  -- | A string literal
  LiteralString String
  deriving (Literal -> Literal -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Literal -> Literal -> Bool
$c/= :: Literal -> Literal -> Bool
== :: Literal -> Literal -> Bool
$c== :: Literal -> Literal -> Bool
Eq, Eq Literal
Literal -> Literal -> Bool
Literal -> Literal -> Ordering
Literal -> Literal -> Literal
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
min :: Literal -> Literal -> Literal
$cmin :: Literal -> Literal -> Literal
max :: Literal -> Literal -> Literal
$cmax :: Literal -> Literal -> Literal
>= :: Literal -> Literal -> Bool
$c>= :: Literal -> Literal -> Bool
> :: Literal -> Literal -> Bool
$c> :: Literal -> Literal -> Bool
<= :: Literal -> Literal -> Bool
$c<= :: Literal -> Literal -> Bool
< :: Literal -> Literal -> Bool
$c< :: Literal -> Literal -> Bool
compare :: Literal -> Literal -> Ordering
$ccompare :: Literal -> Literal -> Ordering
Ord, ReadPrec [Literal]
ReadPrec Literal
Int -> ReadS Literal
ReadS [Literal]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Literal]
$creadListPrec :: ReadPrec [Literal]
readPrec :: ReadPrec Literal
$creadPrec :: ReadPrec Literal
readList :: ReadS [Literal]
$creadList :: ReadS [Literal]
readsPrec :: Int -> ReadS Literal
$creadsPrec :: Int -> ReadS Literal
Read, Int -> Literal -> ShowS
[Literal] -> ShowS
Literal -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Literal] -> ShowS
$cshowList :: [Literal] -> ShowS
show :: Literal -> String
$cshow :: Literal -> String
showsPrec :: Int -> Literal -> ShowS
$cshowsPrec :: Int -> Literal -> ShowS
Show)

_Literal :: Name
_Literal = (String -> Name
Name String
"hydra/core.Literal")

_Literal_binary :: FieldName
_Literal_binary = (String -> FieldName
FieldName String
"binary")

_Literal_boolean :: FieldName
_Literal_boolean = (String -> FieldName
FieldName String
"boolean")

_Literal_float :: FieldName
_Literal_float = (String -> FieldName
FieldName String
"float")

_Literal_integer :: FieldName
_Literal_integer = (String -> FieldName
FieldName String
"integer")

_Literal_string :: FieldName
_Literal_string = (String -> FieldName
FieldName String
"string")

-- | Any of a fixed set of literal types, also called atomic types, base types, primitive types, or type constants
data LiteralType = 
  LiteralTypeBinary  |
  LiteralTypeBoolean  |
  LiteralTypeFloat FloatType |
  LiteralTypeInteger IntegerType |
  LiteralTypeString 
  deriving (LiteralType -> LiteralType -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: LiteralType -> LiteralType -> Bool
$c/= :: LiteralType -> LiteralType -> Bool
== :: LiteralType -> LiteralType -> Bool
$c== :: LiteralType -> LiteralType -> Bool
Eq, Eq LiteralType
LiteralType -> LiteralType -> Bool
LiteralType -> LiteralType -> Ordering
LiteralType -> LiteralType -> LiteralType
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
min :: LiteralType -> LiteralType -> LiteralType
$cmin :: LiteralType -> LiteralType -> LiteralType
max :: LiteralType -> LiteralType -> LiteralType
$cmax :: LiteralType -> LiteralType -> LiteralType
>= :: LiteralType -> LiteralType -> Bool
$c>= :: LiteralType -> LiteralType -> Bool
> :: LiteralType -> LiteralType -> Bool
$c> :: LiteralType -> LiteralType -> Bool
<= :: LiteralType -> LiteralType -> Bool
$c<= :: LiteralType -> LiteralType -> Bool
< :: LiteralType -> LiteralType -> Bool
$c< :: LiteralType -> LiteralType -> Bool
compare :: LiteralType -> LiteralType -> Ordering
$ccompare :: LiteralType -> LiteralType -> Ordering
Ord, ReadPrec [LiteralType]
ReadPrec LiteralType
Int -> ReadS LiteralType
ReadS [LiteralType]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [LiteralType]
$creadListPrec :: ReadPrec [LiteralType]
readPrec :: ReadPrec LiteralType
$creadPrec :: ReadPrec LiteralType
readList :: ReadS [LiteralType]
$creadList :: ReadS [LiteralType]
readsPrec :: Int -> ReadS LiteralType
$creadsPrec :: Int -> ReadS LiteralType
Read, Int -> LiteralType -> ShowS
[LiteralType] -> ShowS
LiteralType -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [LiteralType] -> ShowS
$cshowList :: [LiteralType] -> ShowS
show :: LiteralType -> String
$cshow :: LiteralType -> String
showsPrec :: Int -> LiteralType -> ShowS
$cshowsPrec :: Int -> LiteralType -> ShowS
Show)

_LiteralType :: Name
_LiteralType = (String -> Name
Name String
"hydra/core.LiteralType")

_LiteralType_binary :: FieldName
_LiteralType_binary = (String -> FieldName
FieldName String
"binary")

_LiteralType_boolean :: FieldName
_LiteralType_boolean = (String -> FieldName
FieldName String
"boolean")

_LiteralType_float :: FieldName
_LiteralType_float = (String -> FieldName
FieldName String
"float")

_LiteralType_integer :: FieldName
_LiteralType_integer = (String -> FieldName
FieldName String
"integer")

_LiteralType_string :: FieldName
_LiteralType_string = (String -> FieldName
FieldName String
"string")

-- | A map type
data MapType m = 
  MapType {
    forall m. MapType m -> Type m
mapTypeKeys :: (Type m),
    forall m. MapType m -> Type m
mapTypeValues :: (Type m)}
  deriving (MapType m -> MapType m -> Bool
forall m. Eq m => MapType m -> MapType m -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MapType m -> MapType m -> Bool
$c/= :: forall m. Eq m => MapType m -> MapType m -> Bool
== :: MapType m -> MapType m -> Bool
$c== :: forall m. Eq m => MapType m -> MapType m -> Bool
Eq, MapType m -> MapType m -> Bool
MapType m -> MapType m -> Ordering
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
forall {m}. Ord m => Eq (MapType m)
forall m. Ord m => MapType m -> MapType m -> Bool
forall m. Ord m => MapType m -> MapType m -> Ordering
forall m. Ord m => MapType m -> MapType m -> MapType m
min :: MapType m -> MapType m -> MapType m
$cmin :: forall m. Ord m => MapType m -> MapType m -> MapType m
max :: MapType m -> MapType m -> MapType m
$cmax :: forall m. Ord m => MapType m -> MapType m -> MapType m
>= :: MapType m -> MapType m -> Bool
$c>= :: forall m. Ord m => MapType m -> MapType m -> Bool
> :: MapType m -> MapType m -> Bool
$c> :: forall m. Ord m => MapType m -> MapType m -> Bool
<= :: MapType m -> MapType m -> Bool
$c<= :: forall m. Ord m => MapType m -> MapType m -> Bool
< :: MapType m -> MapType m -> Bool
$c< :: forall m. Ord m => MapType m -> MapType m -> Bool
compare :: MapType m -> MapType m -> Ordering
$ccompare :: forall m. Ord m => MapType m -> MapType m -> Ordering
Ord, ReadPrec [MapType m]
ReadPrec (MapType m)
ReadS [MapType m]
forall m. Read m => ReadPrec [MapType m]
forall m. Read m => ReadPrec (MapType m)
forall m. Read m => Int -> ReadS (MapType m)
forall m. Read m => ReadS [MapType m]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [MapType m]
$creadListPrec :: forall m. Read m => ReadPrec [MapType m]
readPrec :: ReadPrec (MapType m)
$creadPrec :: forall m. Read m => ReadPrec (MapType m)
readList :: ReadS [MapType m]
$creadList :: forall m. Read m => ReadS [MapType m]
readsPrec :: Int -> ReadS (MapType m)
$creadsPrec :: forall m. Read m => Int -> ReadS (MapType m)
Read, Int -> MapType m -> ShowS
forall m. Show m => Int -> MapType m -> ShowS
forall m. Show m => [MapType m] -> ShowS
forall m. Show m => MapType m -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MapType m] -> ShowS
$cshowList :: forall m. Show m => [MapType m] -> ShowS
show :: MapType m -> String
$cshow :: forall m. Show m => MapType m -> String
showsPrec :: Int -> MapType m -> ShowS
$cshowsPrec :: forall m. Show m => Int -> MapType m -> ShowS
Show)

_MapType :: Name
_MapType = (String -> Name
Name String
"hydra/core.MapType")

_MapType_keys :: FieldName
_MapType_keys = (String -> FieldName
FieldName String
"keys")

_MapType_values :: FieldName
_MapType_values = (String -> FieldName
FieldName String
"values")

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

_Name :: Name
_Name = (String -> Name
Name String
"hydra/core.Name")

-- | A term annotated with a fixed, named type; an instance of a newtype
data Named m = 
  Named {
    forall m. Named m -> Name
namedTypeName :: Name,
    forall m. Named m -> Term m
namedTerm :: (Term m)}
  deriving (Named m -> Named m -> Bool
forall m. Eq m => Named m -> Named m -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Named m -> Named m -> Bool
$c/= :: forall m. Eq m => Named m -> Named m -> Bool
== :: Named m -> Named m -> Bool
$c== :: forall m. Eq m => Named m -> Named m -> Bool
Eq, Named m -> Named m -> Bool
Named m -> Named m -> Ordering
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
forall {m}. Ord m => Eq (Named m)
forall m. Ord m => Named m -> Named m -> Bool
forall m. Ord m => Named m -> Named m -> Ordering
forall m. Ord m => Named m -> Named m -> Named m
min :: Named m -> Named m -> Named m
$cmin :: forall m. Ord m => Named m -> Named m -> Named m
max :: Named m -> Named m -> Named m
$cmax :: forall m. Ord m => Named m -> Named m -> Named m
>= :: Named m -> Named m -> Bool
$c>= :: forall m. Ord m => Named m -> Named m -> Bool
> :: Named m -> Named m -> Bool
$c> :: forall m. Ord m => Named m -> Named m -> Bool
<= :: Named m -> Named m -> Bool
$c<= :: forall m. Ord m => Named m -> Named m -> Bool
< :: Named m -> Named m -> Bool
$c< :: forall m. Ord m => Named m -> Named m -> Bool
compare :: Named m -> Named m -> Ordering
$ccompare :: forall m. Ord m => Named m -> Named m -> Ordering
Ord, ReadPrec [Named m]
ReadPrec (Named m)
ReadS [Named m]
forall m. (Read m, Ord m) => ReadPrec [Named m]
forall m. (Read m, Ord m) => ReadPrec (Named m)
forall m. (Read m, Ord m) => Int -> ReadS (Named m)
forall m. (Read m, Ord m) => ReadS [Named m]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Named m]
$creadListPrec :: forall m. (Read m, Ord m) => ReadPrec [Named m]
readPrec :: ReadPrec (Named m)
$creadPrec :: forall m. (Read m, Ord m) => ReadPrec (Named m)
readList :: ReadS [Named m]
$creadList :: forall m. (Read m, Ord m) => ReadS [Named m]
readsPrec :: Int -> ReadS (Named m)
$creadsPrec :: forall m. (Read m, Ord m) => Int -> ReadS (Named m)
Read, Int -> Named m -> ShowS
forall m. Show m => Int -> Named m -> ShowS
forall m. Show m => [Named m] -> ShowS
forall m. Show m => Named m -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Named m] -> ShowS
$cshowList :: forall m. Show m => [Named m] -> ShowS
show :: Named m -> String
$cshow :: forall m. Show m => Named m -> String
showsPrec :: Int -> Named m -> ShowS
$cshowsPrec :: forall m. Show m => Int -> Named m -> ShowS
Show)

_Named :: Name
_Named = (String -> Name
Name String
"hydra/core.Named")

_Named_typeName :: FieldName
_Named_typeName = (String -> FieldName
FieldName String
"typeName")

_Named_term :: FieldName
_Named_term = (String -> FieldName
FieldName String
"term")

-- | A case statement for matching optional terms
data OptionalCases m = 
  OptionalCases {
    -- | A term provided if the optional value is nothing
    forall m. OptionalCases m -> Term m
optionalCasesNothing :: (Term m),
    -- | A function which is applied of the optional value is non-nothing
    forall m. OptionalCases m -> Term m
optionalCasesJust :: (Term m)}
  deriving (OptionalCases m -> OptionalCases m -> Bool
forall m. Eq m => OptionalCases m -> OptionalCases m -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: OptionalCases m -> OptionalCases m -> Bool
$c/= :: forall m. Eq m => OptionalCases m -> OptionalCases m -> Bool
== :: OptionalCases m -> OptionalCases m -> Bool
$c== :: forall m. Eq m => OptionalCases m -> OptionalCases m -> Bool
Eq, OptionalCases m -> OptionalCases m -> Bool
OptionalCases m -> OptionalCases m -> Ordering
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
forall {m}. Ord m => Eq (OptionalCases m)
forall m. Ord m => OptionalCases m -> OptionalCases m -> Bool
forall m. Ord m => OptionalCases m -> OptionalCases m -> Ordering
forall m.
Ord m =>
OptionalCases m -> OptionalCases m -> OptionalCases m
min :: OptionalCases m -> OptionalCases m -> OptionalCases m
$cmin :: forall m.
Ord m =>
OptionalCases m -> OptionalCases m -> OptionalCases m
max :: OptionalCases m -> OptionalCases m -> OptionalCases m
$cmax :: forall m.
Ord m =>
OptionalCases m -> OptionalCases m -> OptionalCases m
>= :: OptionalCases m -> OptionalCases m -> Bool
$c>= :: forall m. Ord m => OptionalCases m -> OptionalCases m -> Bool
> :: OptionalCases m -> OptionalCases m -> Bool
$c> :: forall m. Ord m => OptionalCases m -> OptionalCases m -> Bool
<= :: OptionalCases m -> OptionalCases m -> Bool
$c<= :: forall m. Ord m => OptionalCases m -> OptionalCases m -> Bool
< :: OptionalCases m -> OptionalCases m -> Bool
$c< :: forall m. Ord m => OptionalCases m -> OptionalCases m -> Bool
compare :: OptionalCases m -> OptionalCases m -> Ordering
$ccompare :: forall m. Ord m => OptionalCases m -> OptionalCases m -> Ordering
Ord, ReadPrec [OptionalCases m]
ReadPrec (OptionalCases m)
ReadS [OptionalCases m]
forall m. (Read m, Ord m) => ReadPrec [OptionalCases m]
forall m. (Read m, Ord m) => ReadPrec (OptionalCases m)
forall m. (Read m, Ord m) => Int -> ReadS (OptionalCases m)
forall m. (Read m, Ord m) => ReadS [OptionalCases m]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [OptionalCases m]
$creadListPrec :: forall m. (Read m, Ord m) => ReadPrec [OptionalCases m]
readPrec :: ReadPrec (OptionalCases m)
$creadPrec :: forall m. (Read m, Ord m) => ReadPrec (OptionalCases m)
readList :: ReadS [OptionalCases m]
$creadList :: forall m. (Read m, Ord m) => ReadS [OptionalCases m]
readsPrec :: Int -> ReadS (OptionalCases m)
$creadsPrec :: forall m. (Read m, Ord m) => Int -> ReadS (OptionalCases m)
Read, Int -> OptionalCases m -> ShowS
forall m. Show m => Int -> OptionalCases m -> ShowS
forall m. Show m => [OptionalCases m] -> ShowS
forall m. Show m => OptionalCases m -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [OptionalCases m] -> ShowS
$cshowList :: forall m. Show m => [OptionalCases m] -> ShowS
show :: OptionalCases m -> String
$cshow :: forall m. Show m => OptionalCases m -> String
showsPrec :: Int -> OptionalCases m -> ShowS
$cshowsPrec :: forall m. Show m => Int -> OptionalCases m -> ShowS
Show)

_OptionalCases :: Name
_OptionalCases = (String -> Name
Name String
"hydra/core.OptionalCases")

_OptionalCases_nothing :: FieldName
_OptionalCases_nothing = (String -> FieldName
FieldName String
"nothing")

_OptionalCases_just :: FieldName
_OptionalCases_just = (String -> FieldName
FieldName String
"just")

-- | A record elimination; a projection
data Projection = 
  Projection {
    Projection -> Name
projectionTypeName :: Name,
    Projection -> FieldName
projectionField :: FieldName}
  deriving (Projection -> Projection -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Projection -> Projection -> Bool
$c/= :: Projection -> Projection -> Bool
== :: Projection -> Projection -> Bool
$c== :: Projection -> Projection -> Bool
Eq, Eq Projection
Projection -> Projection -> Bool
Projection -> Projection -> Ordering
Projection -> Projection -> Projection
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
min :: Projection -> Projection -> Projection
$cmin :: Projection -> Projection -> Projection
max :: Projection -> Projection -> Projection
$cmax :: Projection -> Projection -> Projection
>= :: Projection -> Projection -> Bool
$c>= :: Projection -> Projection -> Bool
> :: Projection -> Projection -> Bool
$c> :: Projection -> Projection -> Bool
<= :: Projection -> Projection -> Bool
$c<= :: Projection -> Projection -> Bool
< :: Projection -> Projection -> Bool
$c< :: Projection -> Projection -> Bool
compare :: Projection -> Projection -> Ordering
$ccompare :: Projection -> Projection -> Ordering
Ord, ReadPrec [Projection]
ReadPrec Projection
Int -> ReadS Projection
ReadS [Projection]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Projection]
$creadListPrec :: ReadPrec [Projection]
readPrec :: ReadPrec Projection
$creadPrec :: ReadPrec Projection
readList :: ReadS [Projection]
$creadList :: ReadS [Projection]
readsPrec :: Int -> ReadS Projection
$creadsPrec :: Int -> ReadS Projection
Read, Int -> Projection -> ShowS
[Projection] -> ShowS
Projection -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Projection] -> ShowS
$cshowList :: [Projection] -> ShowS
show :: Projection -> String
$cshow :: Projection -> String
showsPrec :: Int -> Projection -> ShowS
$cshowsPrec :: Int -> Projection -> ShowS
Show)

_Projection :: Name
_Projection = (String -> Name
Name String
"hydra/core.Projection")

_Projection_typeName :: FieldName
_Projection_typeName = (String -> FieldName
FieldName String
"typeName")

_Projection_field :: FieldName
_Projection_field = (String -> FieldName
FieldName String
"field")

-- | A record, or labeled tuple; a map of field names to terms
data Record m = 
  Record {
    forall m. Record m -> Name
recordTypeName :: Name,
    forall m. Record m -> [Field m]
recordFields :: [Field m]}
  deriving (Record m -> Record m -> Bool
forall m. Eq m => Record m -> Record m -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Record m -> Record m -> Bool
$c/= :: forall m. Eq m => Record m -> Record m -> Bool
== :: Record m -> Record m -> Bool
$c== :: forall m. Eq m => Record m -> Record m -> Bool
Eq, Record m -> Record m -> Bool
Record m -> Record m -> Ordering
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
forall {m}. Ord m => Eq (Record m)
forall m. Ord m => Record m -> Record m -> Bool
forall m. Ord m => Record m -> Record m -> Ordering
forall m. Ord m => Record m -> Record m -> Record m
min :: Record m -> Record m -> Record m
$cmin :: forall m. Ord m => Record m -> Record m -> Record m
max :: Record m -> Record m -> Record m
$cmax :: forall m. Ord m => Record m -> Record m -> Record m
>= :: Record m -> Record m -> Bool
$c>= :: forall m. Ord m => Record m -> Record m -> Bool
> :: Record m -> Record m -> Bool
$c> :: forall m. Ord m => Record m -> Record m -> Bool
<= :: Record m -> Record m -> Bool
$c<= :: forall m. Ord m => Record m -> Record m -> Bool
< :: Record m -> Record m -> Bool
$c< :: forall m. Ord m => Record m -> Record m -> Bool
compare :: Record m -> Record m -> Ordering
$ccompare :: forall m. Ord m => Record m -> Record m -> Ordering
Ord, ReadPrec [Record m]
ReadPrec (Record m)
ReadS [Record m]
forall m. (Read m, Ord m) => ReadPrec [Record m]
forall m. (Read m, Ord m) => ReadPrec (Record m)
forall m. (Read m, Ord m) => Int -> ReadS (Record m)
forall m. (Read m, Ord m) => ReadS [Record m]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Record m]
$creadListPrec :: forall m. (Read m, Ord m) => ReadPrec [Record m]
readPrec :: ReadPrec (Record m)
$creadPrec :: forall m. (Read m, Ord m) => ReadPrec (Record m)
readList :: ReadS [Record m]
$creadList :: forall m. (Read m, Ord m) => ReadS [Record m]
readsPrec :: Int -> ReadS (Record m)
$creadsPrec :: forall m. (Read m, Ord m) => Int -> ReadS (Record m)
Read, Int -> Record m -> ShowS
forall m. Show m => Int -> Record m -> ShowS
forall m. Show m => [Record m] -> ShowS
forall m. Show m => Record m -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Record m] -> ShowS
$cshowList :: forall m. Show m => [Record m] -> ShowS
show :: Record m -> String
$cshow :: forall m. Show m => Record m -> String
showsPrec :: Int -> Record m -> ShowS
$cshowsPrec :: forall m. Show m => Int -> Record m -> ShowS
Show)

_Record :: Name
_Record = (String -> Name
Name String
"hydra/core.Record")

_Record_typeName :: FieldName
_Record_typeName = (String -> FieldName
FieldName String
"typeName")

_Record_fields :: FieldName
_Record_fields = (String -> FieldName
FieldName String
"fields")

-- | A labeled record or union type
data RowType m = 
  RowType {
    -- | The name of the row type, which must correspond to the name of a Type element
    forall m. RowType m -> Name
rowTypeTypeName :: Name,
    -- | Optionally, the name of another row type which this one extends. To the extent that field order is preserved, the inherited fields of the extended type precede those of the extension.
    forall m. RowType m -> Maybe Name
rowTypeExtends :: (Maybe Name),
    -- | The fields of this row type, excluding any inherited fields
    forall m. RowType m -> [FieldType m]
rowTypeFields :: [FieldType m]}
  deriving (RowType m -> RowType m -> Bool
forall m. Eq m => RowType m -> RowType m -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RowType m -> RowType m -> Bool
$c/= :: forall m. Eq m => RowType m -> RowType m -> Bool
== :: RowType m -> RowType m -> Bool
$c== :: forall m. Eq m => RowType m -> RowType m -> Bool
Eq, RowType m -> RowType m -> Bool
RowType m -> RowType m -> Ordering
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
forall {m}. Ord m => Eq (RowType m)
forall m. Ord m => RowType m -> RowType m -> Bool
forall m. Ord m => RowType m -> RowType m -> Ordering
forall m. Ord m => RowType m -> RowType m -> RowType m
min :: RowType m -> RowType m -> RowType m
$cmin :: forall m. Ord m => RowType m -> RowType m -> RowType m
max :: RowType m -> RowType m -> RowType m
$cmax :: forall m. Ord m => RowType m -> RowType m -> RowType m
>= :: RowType m -> RowType m -> Bool
$c>= :: forall m. Ord m => RowType m -> RowType m -> Bool
> :: RowType m -> RowType m -> Bool
$c> :: forall m. Ord m => RowType m -> RowType m -> Bool
<= :: RowType m -> RowType m -> Bool
$c<= :: forall m. Ord m => RowType m -> RowType m -> Bool
< :: RowType m -> RowType m -> Bool
$c< :: forall m. Ord m => RowType m -> RowType m -> Bool
compare :: RowType m -> RowType m -> Ordering
$ccompare :: forall m. Ord m => RowType m -> RowType m -> Ordering
Ord, ReadPrec [RowType m]
ReadPrec (RowType m)
ReadS [RowType m]
forall m. Read m => ReadPrec [RowType m]
forall m. Read m => ReadPrec (RowType m)
forall m. Read m => Int -> ReadS (RowType m)
forall m. Read m => ReadS [RowType m]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [RowType m]
$creadListPrec :: forall m. Read m => ReadPrec [RowType m]
readPrec :: ReadPrec (RowType m)
$creadPrec :: forall m. Read m => ReadPrec (RowType m)
readList :: ReadS [RowType m]
$creadList :: forall m. Read m => ReadS [RowType m]
readsPrec :: Int -> ReadS (RowType m)
$creadsPrec :: forall m. Read m => Int -> ReadS (RowType m)
Read, Int -> RowType m -> ShowS
forall m. Show m => Int -> RowType m -> ShowS
forall m. Show m => [RowType m] -> ShowS
forall m. Show m => RowType m -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RowType m] -> ShowS
$cshowList :: forall m. Show m => [RowType m] -> ShowS
show :: RowType m -> String
$cshow :: forall m. Show m => RowType m -> String
showsPrec :: Int -> RowType m -> ShowS
$cshowsPrec :: forall m. Show m => Int -> RowType m -> ShowS
Show)

_RowType :: Name
_RowType = (String -> Name
Name String
"hydra/core.RowType")

_RowType_typeName :: FieldName
_RowType_typeName = (String -> FieldName
FieldName String
"typeName")

_RowType_extends :: FieldName
_RowType_extends = (String -> FieldName
FieldName String
"extends")

_RowType_fields :: FieldName
_RowType_fields = (String -> FieldName
FieldName String
"fields")

-- | An infinite stream of terms
data Stream m = 
  Stream {
    forall m. Stream m -> Term m
streamFirst :: (Term m),
    forall m. Stream m -> Stream m
streamRest :: (Stream m)}
  deriving (Stream m -> Stream m -> Bool
forall m. Eq m => Stream m -> Stream m -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Stream m -> Stream m -> Bool
$c/= :: forall m. Eq m => Stream m -> Stream m -> Bool
== :: Stream m -> Stream m -> Bool
$c== :: forall m. Eq m => Stream m -> Stream m -> Bool
Eq, Stream m -> Stream m -> Bool
Stream m -> Stream m -> Ordering
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
forall {m}. Ord m => Eq (Stream m)
forall m. Ord m => Stream m -> Stream m -> Bool
forall m. Ord m => Stream m -> Stream m -> Ordering
forall m. Ord m => Stream m -> Stream m -> Stream m
min :: Stream m -> Stream m -> Stream m
$cmin :: forall m. Ord m => Stream m -> Stream m -> Stream m
max :: Stream m -> Stream m -> Stream m
$cmax :: forall m. Ord m => Stream m -> Stream m -> Stream m
>= :: Stream m -> Stream m -> Bool
$c>= :: forall m. Ord m => Stream m -> Stream m -> Bool
> :: Stream m -> Stream m -> Bool
$c> :: forall m. Ord m => Stream m -> Stream m -> Bool
<= :: Stream m -> Stream m -> Bool
$c<= :: forall m. Ord m => Stream m -> Stream m -> Bool
< :: Stream m -> Stream m -> Bool
$c< :: forall m. Ord m => Stream m -> Stream m -> Bool
compare :: Stream m -> Stream m -> Ordering
$ccompare :: forall m. Ord m => Stream m -> Stream m -> Ordering
Ord, ReadPrec [Stream m]
ReadPrec (Stream m)
ReadS [Stream m]
forall m. (Read m, Ord m) => ReadPrec [Stream m]
forall m. (Read m, Ord m) => ReadPrec (Stream m)
forall m. (Read m, Ord m) => Int -> ReadS (Stream m)
forall m. (Read m, Ord m) => ReadS [Stream m]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Stream m]
$creadListPrec :: forall m. (Read m, Ord m) => ReadPrec [Stream m]
readPrec :: ReadPrec (Stream m)
$creadPrec :: forall m. (Read m, Ord m) => ReadPrec (Stream m)
readList :: ReadS [Stream m]
$creadList :: forall m. (Read m, Ord m) => ReadS [Stream m]
readsPrec :: Int -> ReadS (Stream m)
$creadsPrec :: forall m. (Read m, Ord m) => Int -> ReadS (Stream m)
Read, Int -> Stream m -> ShowS
forall m. Show m => Int -> Stream m -> ShowS
forall m. Show m => [Stream m] -> ShowS
forall m. Show m => Stream m -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Stream m] -> ShowS
$cshowList :: forall m. Show m => [Stream m] -> ShowS
show :: Stream m -> String
$cshow :: forall m. Show m => Stream m -> String
showsPrec :: Int -> Stream m -> ShowS
$cshowsPrec :: forall m. Show m => Int -> Stream m -> ShowS
Show)

_Stream :: Name
_Stream = (String -> Name
Name String
"hydra/core.Stream")

_Stream_first :: FieldName
_Stream_first = (String -> FieldName
FieldName String
"first")

_Stream_rest :: FieldName
_Stream_rest = (String -> FieldName
FieldName String
"rest")

-- | The unlabeled equivalent of a Union term
data Sum m = 
  Sum {
    forall m. Sum m -> Int
sumIndex :: Int,
    forall m. Sum m -> Int
sumSize :: Int,
    forall m. Sum m -> Term m
sumTerm :: (Term m)}
  deriving (Sum m -> Sum m -> Bool
forall m. Eq m => Sum m -> Sum m -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Sum m -> Sum m -> Bool
$c/= :: forall m. Eq m => Sum m -> Sum m -> Bool
== :: Sum m -> Sum m -> Bool
$c== :: forall m. Eq m => Sum m -> Sum m -> Bool
Eq, Sum m -> Sum m -> Bool
Sum m -> Sum m -> Ordering
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
forall {m}. Ord m => Eq (Sum m)
forall m. Ord m => Sum m -> Sum m -> Bool
forall m. Ord m => Sum m -> Sum m -> Ordering
forall m. Ord m => Sum m -> Sum m -> Sum m
min :: Sum m -> Sum m -> Sum m
$cmin :: forall m. Ord m => Sum m -> Sum m -> Sum m
max :: Sum m -> Sum m -> Sum m
$cmax :: forall m. Ord m => Sum m -> Sum m -> Sum m
>= :: Sum m -> Sum m -> Bool
$c>= :: forall m. Ord m => Sum m -> Sum m -> Bool
> :: Sum m -> Sum m -> Bool
$c> :: forall m. Ord m => Sum m -> Sum m -> Bool
<= :: Sum m -> Sum m -> Bool
$c<= :: forall m. Ord m => Sum m -> Sum m -> Bool
< :: Sum m -> Sum m -> Bool
$c< :: forall m. Ord m => Sum m -> Sum m -> Bool
compare :: Sum m -> Sum m -> Ordering
$ccompare :: forall m. Ord m => Sum m -> Sum m -> Ordering
Ord, ReadPrec [Sum m]
ReadPrec (Sum m)
ReadS [Sum m]
forall m. (Read m, Ord m) => ReadPrec [Sum m]
forall m. (Read m, Ord m) => ReadPrec (Sum m)
forall m. (Read m, Ord m) => Int -> ReadS (Sum m)
forall m. (Read m, Ord m) => ReadS [Sum m]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Sum m]
$creadListPrec :: forall m. (Read m, Ord m) => ReadPrec [Sum m]
readPrec :: ReadPrec (Sum m)
$creadPrec :: forall m. (Read m, Ord m) => ReadPrec (Sum m)
readList :: ReadS [Sum m]
$creadList :: forall m. (Read m, Ord m) => ReadS [Sum m]
readsPrec :: Int -> ReadS (Sum m)
$creadsPrec :: forall m. (Read m, Ord m) => Int -> ReadS (Sum m)
Read, Int -> Sum m -> ShowS
forall m. Show m => Int -> Sum m -> ShowS
forall m. Show m => [Sum m] -> ShowS
forall m. Show m => Sum m -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Sum m] -> ShowS
$cshowList :: forall m. Show m => [Sum m] -> ShowS
show :: Sum m -> String
$cshow :: forall m. Show m => Sum m -> String
showsPrec :: Int -> Sum m -> ShowS
$cshowsPrec :: forall m. Show m => Int -> Sum m -> ShowS
Show)

_Sum :: Name
_Sum = (String -> Name
Name String
"hydra/core.Sum")

_Sum_index :: FieldName
_Sum_index = (String -> FieldName
FieldName String
"index")

_Sum_size :: FieldName
_Sum_size = (String -> FieldName
FieldName String
"size")

_Sum_term :: FieldName
_Sum_term = (String -> FieldName
FieldName String
"term")

-- | A data term
data Term m = 
  -- | A term annotated with metadata
  TermAnnotated (Annotated (Term m) m) |
  -- | A function application
  TermApplication (Application m) |
  -- | An element reference
  TermElement Name |
  -- | A function term
  TermFunction (Function m) |
  TermLet (Let m) |
  -- | A list
  TermList [Term m] |
  -- | A literal value
  TermLiteral Literal |
  -- | A map of keys to values
  TermMap (Map (Term m) (Term m)) |
  TermNominal (Named m) |
  -- | An optional value
  TermOptional (Maybe (Term m)) |
  -- | A tuple
  TermProduct [Term m] |
  -- | A record term
  TermRecord (Record m) |
  -- | A set of values
  TermSet (Set (Term m)) |
  -- | An infinite stream of terms
  TermStream (Stream m) |
  -- | A variant tuple
  TermSum (Sum m) |
  -- | A union term
  TermUnion (Union m) |
  -- | A variable reference
  TermVariable Variable
  deriving (Term m -> Term m -> Bool
forall m. Eq m => Term m -> Term m -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Term m -> Term m -> Bool
$c/= :: forall m. Eq m => Term m -> Term m -> Bool
== :: Term m -> Term m -> Bool
$c== :: forall m. Eq m => Term m -> Term m -> Bool
Eq, Term m -> Term m -> Ordering
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
forall {m}. Ord m => Eq (Term m)
forall m. Ord m => Term m -> Term m -> Bool
forall m. Ord m => Term m -> Term m -> Ordering
forall m. Ord m => Term m -> Term m -> Term m
min :: Term m -> Term m -> Term m
$cmin :: forall m. Ord m => Term m -> Term m -> Term m
max :: Term m -> Term m -> Term m
$cmax :: forall m. Ord m => Term m -> Term m -> Term m
>= :: Term m -> Term m -> Bool
$c>= :: forall m. Ord m => Term m -> Term m -> Bool
> :: Term m -> Term m -> Bool
$c> :: forall m. Ord m => Term m -> Term m -> Bool
<= :: Term m -> Term m -> Bool
$c<= :: forall m. Ord m => Term m -> Term m -> Bool
< :: Term m -> Term m -> Bool
$c< :: forall m. Ord m => Term m -> Term m -> Bool
compare :: Term m -> Term m -> Ordering
$ccompare :: forall m. Ord m => Term m -> Term m -> Ordering
Ord, ReadPrec [Term m]
ReadPrec (Term m)
ReadS [Term m]
forall m. (Read m, Ord m) => ReadPrec [Term m]
forall m. (Read m, Ord m) => ReadPrec (Term m)
forall m. (Read m, Ord m) => Int -> ReadS (Term m)
forall m. (Read m, Ord m) => ReadS [Term m]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Term m]
$creadListPrec :: forall m. (Read m, Ord m) => ReadPrec [Term m]
readPrec :: ReadPrec (Term m)
$creadPrec :: forall m. (Read m, Ord m) => ReadPrec (Term m)
readList :: ReadS [Term m]
$creadList :: forall m. (Read m, Ord m) => ReadS [Term m]
readsPrec :: Int -> ReadS (Term m)
$creadsPrec :: forall m. (Read m, Ord m) => Int -> ReadS (Term m)
Read, Int -> Term m -> ShowS
forall m. Show m => Int -> Term m -> ShowS
forall m. Show m => [Term m] -> ShowS
forall m. Show m => Term m -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Term m] -> ShowS
$cshowList :: forall m. Show m => [Term m] -> ShowS
show :: Term m -> String
$cshow :: forall m. Show m => Term m -> String
showsPrec :: Int -> Term m -> ShowS
$cshowsPrec :: forall m. Show m => Int -> Term m -> ShowS
Show)

_Term :: Name
_Term = (String -> Name
Name String
"hydra/core.Term")

_Term_annotated :: FieldName
_Term_annotated = (String -> FieldName
FieldName String
"annotated")

_Term_application :: FieldName
_Term_application = (String -> FieldName
FieldName String
"application")

_Term_element :: FieldName
_Term_element = (String -> FieldName
FieldName String
"element")

_Term_function :: FieldName
_Term_function = (String -> FieldName
FieldName String
"function")

_Term_let :: FieldName
_Term_let = (String -> FieldName
FieldName String
"let")

_Term_list :: FieldName
_Term_list = (String -> FieldName
FieldName String
"list")

_Term_literal :: FieldName
_Term_literal = (String -> FieldName
FieldName String
"literal")

_Term_map :: FieldName
_Term_map = (String -> FieldName
FieldName String
"map")

_Term_nominal :: FieldName
_Term_nominal = (String -> FieldName
FieldName String
"nominal")

_Term_optional :: FieldName
_Term_optional = (String -> FieldName
FieldName String
"optional")

_Term_product :: FieldName
_Term_product = (String -> FieldName
FieldName String
"product")

_Term_record :: FieldName
_Term_record = (String -> FieldName
FieldName String
"record")

_Term_set :: FieldName
_Term_set = (String -> FieldName
FieldName String
"set")

_Term_stream :: FieldName
_Term_stream = (String -> FieldName
FieldName String
"stream")

_Term_sum :: FieldName
_Term_sum = (String -> FieldName
FieldName String
"sum")

_Term_union :: FieldName
_Term_union = (String -> FieldName
FieldName String
"union")

_Term_variable :: FieldName
_Term_variable = (String -> FieldName
FieldName String
"variable")

-- | A data type
data Type m = 
  -- | A type annotated with metadata
  TypeAnnotated (Annotated (Type m) m) |
  TypeApplication (ApplicationType m) |
  TypeElement (Type m) |
  TypeFunction (FunctionType m) |
  TypeLambda (LambdaType m) |
  TypeList (Type m) |
  TypeLiteral LiteralType |
  TypeMap (MapType m) |
  TypeNominal Name |
  TypeOptional (Type m) |
  TypeProduct [Type m] |
  TypeRecord (RowType m) |
  TypeSet (Type m) |
  TypeStream (Type m) |
  TypeSum [Type m] |
  TypeUnion (RowType m) |
  TypeVariable VariableType
  deriving (Type m -> Type m -> Bool
forall m. Eq m => Type m -> Type m -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Type m -> Type m -> Bool
$c/= :: forall m. Eq m => Type m -> Type m -> Bool
== :: Type m -> Type m -> Bool
$c== :: forall m. Eq m => Type m -> Type m -> Bool
Eq, Type m -> Type m -> Ordering
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
forall {m}. Ord m => Eq (Type m)
forall m. Ord m => Type m -> Type m -> Bool
forall m. Ord m => Type m -> Type m -> Ordering
forall m. Ord m => Type m -> Type m -> Type m
min :: Type m -> Type m -> Type m
$cmin :: forall m. Ord m => Type m -> Type m -> Type m
max :: Type m -> Type m -> Type m
$cmax :: forall m. Ord m => Type m -> Type m -> Type m
>= :: Type m -> Type m -> Bool
$c>= :: forall m. Ord m => Type m -> Type m -> Bool
> :: Type m -> Type m -> Bool
$c> :: forall m. Ord m => Type m -> Type m -> Bool
<= :: Type m -> Type m -> Bool
$c<= :: forall m. Ord m => Type m -> Type m -> Bool
< :: Type m -> Type m -> Bool
$c< :: forall m. Ord m => Type m -> Type m -> Bool
compare :: Type m -> Type m -> Ordering
$ccompare :: forall m. Ord m => Type m -> Type m -> Ordering
Ord, ReadPrec [Type m]
ReadPrec (Type m)
ReadS [Type m]
forall m. Read m => ReadPrec [Type m]
forall m. Read m => ReadPrec (Type m)
forall m. Read m => Int -> ReadS (Type m)
forall m. Read m => ReadS [Type m]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Type m]
$creadListPrec :: forall m. Read m => ReadPrec [Type m]
readPrec :: ReadPrec (Type m)
$creadPrec :: forall m. Read m => ReadPrec (Type m)
readList :: ReadS [Type m]
$creadList :: forall m. Read m => ReadS [Type m]
readsPrec :: Int -> ReadS (Type m)
$creadsPrec :: forall m. Read m => Int -> ReadS (Type m)
Read, Int -> Type m -> ShowS
forall m. Show m => Int -> Type m -> ShowS
forall m. Show m => [Type m] -> ShowS
forall m. Show m => Type m -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Type m] -> ShowS
$cshowList :: forall m. Show m => [Type m] -> ShowS
show :: Type m -> String
$cshow :: forall m. Show m => Type m -> String
showsPrec :: Int -> Type m -> ShowS
$cshowsPrec :: forall m. Show m => Int -> Type m -> ShowS
Show)

_Type :: Name
_Type = (String -> Name
Name String
"hydra/core.Type")

_Type_annotated :: FieldName
_Type_annotated = (String -> FieldName
FieldName String
"annotated")

_Type_application :: FieldName
_Type_application = (String -> FieldName
FieldName String
"application")

_Type_element :: FieldName
_Type_element = (String -> FieldName
FieldName String
"element")

_Type_function :: FieldName
_Type_function = (String -> FieldName
FieldName String
"function")

_Type_lambda :: FieldName
_Type_lambda = (String -> FieldName
FieldName String
"lambda")

_Type_list :: FieldName
_Type_list = (String -> FieldName
FieldName String
"list")

_Type_literal :: FieldName
_Type_literal = (String -> FieldName
FieldName String
"literal")

_Type_map :: FieldName
_Type_map = (String -> FieldName
FieldName String
"map")

_Type_nominal :: FieldName
_Type_nominal = (String -> FieldName
FieldName String
"nominal")

_Type_optional :: FieldName
_Type_optional = (String -> FieldName
FieldName String
"optional")

_Type_product :: FieldName
_Type_product = (String -> FieldName
FieldName String
"product")

_Type_record :: FieldName
_Type_record = (String -> FieldName
FieldName String
"record")

_Type_set :: FieldName
_Type_set = (String -> FieldName
FieldName String
"set")

_Type_stream :: FieldName
_Type_stream = (String -> FieldName
FieldName String
"stream")

_Type_sum :: FieldName
_Type_sum = (String -> FieldName
FieldName String
"sum")

_Type_union :: FieldName
_Type_union = (String -> FieldName
FieldName String
"union")

_Type_variable :: FieldName
_Type_variable = (String -> FieldName
FieldName String
"variable")

-- | A symbol which stands in for a term
newtype Variable = 
  Variable {
    -- | A symbol which stands in for a term
    Variable -> String
unVariable :: String}
  deriving (Variable -> Variable -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Variable -> Variable -> Bool
$c/= :: Variable -> Variable -> Bool
== :: Variable -> Variable -> Bool
$c== :: Variable -> Variable -> Bool
Eq, Eq Variable
Variable -> Variable -> Bool
Variable -> Variable -> Ordering
Variable -> Variable -> Variable
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
min :: Variable -> Variable -> Variable
$cmin :: Variable -> Variable -> Variable
max :: Variable -> Variable -> Variable
$cmax :: Variable -> Variable -> Variable
>= :: Variable -> Variable -> Bool
$c>= :: Variable -> Variable -> Bool
> :: Variable -> Variable -> Bool
$c> :: Variable -> Variable -> Bool
<= :: Variable -> Variable -> Bool
$c<= :: Variable -> Variable -> Bool
< :: Variable -> Variable -> Bool
$c< :: Variable -> Variable -> Bool
compare :: Variable -> Variable -> Ordering
$ccompare :: Variable -> Variable -> Ordering
Ord, ReadPrec [Variable]
ReadPrec Variable
Int -> ReadS Variable
ReadS [Variable]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Variable]
$creadListPrec :: ReadPrec [Variable]
readPrec :: ReadPrec Variable
$creadPrec :: ReadPrec Variable
readList :: ReadS [Variable]
$creadList :: ReadS [Variable]
readsPrec :: Int -> ReadS Variable
$creadsPrec :: Int -> ReadS Variable
Read, Int -> Variable -> ShowS
[Variable] -> ShowS
Variable -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Variable] -> ShowS
$cshowList :: [Variable] -> ShowS
show :: Variable -> String
$cshow :: Variable -> String
showsPrec :: Int -> Variable -> ShowS
$cshowsPrec :: Int -> Variable -> ShowS
Show)

_Variable :: Name
_Variable = (String -> Name
Name String
"hydra/core.Variable")

-- | A symbol which stands in for a type
newtype VariableType = 
  VariableType {
    -- | A symbol which stands in for a type
    VariableType -> String
unVariableType :: String}
  deriving (VariableType -> VariableType -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VariableType -> VariableType -> Bool
$c/= :: VariableType -> VariableType -> Bool
== :: VariableType -> VariableType -> Bool
$c== :: VariableType -> VariableType -> Bool
Eq, Eq VariableType
VariableType -> VariableType -> Bool
VariableType -> VariableType -> Ordering
VariableType -> VariableType -> VariableType
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
min :: VariableType -> VariableType -> VariableType
$cmin :: VariableType -> VariableType -> VariableType
max :: VariableType -> VariableType -> VariableType
$cmax :: VariableType -> VariableType -> VariableType
>= :: VariableType -> VariableType -> Bool
$c>= :: VariableType -> VariableType -> Bool
> :: VariableType -> VariableType -> Bool
$c> :: VariableType -> VariableType -> Bool
<= :: VariableType -> VariableType -> Bool
$c<= :: VariableType -> VariableType -> Bool
< :: VariableType -> VariableType -> Bool
$c< :: VariableType -> VariableType -> Bool
compare :: VariableType -> VariableType -> Ordering
$ccompare :: VariableType -> VariableType -> Ordering
Ord, ReadPrec [VariableType]
ReadPrec VariableType
Int -> ReadS VariableType
ReadS [VariableType]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [VariableType]
$creadListPrec :: ReadPrec [VariableType]
readPrec :: ReadPrec VariableType
$creadPrec :: ReadPrec VariableType
readList :: ReadS [VariableType]
$creadList :: ReadS [VariableType]
readsPrec :: Int -> ReadS VariableType
$creadsPrec :: Int -> ReadS VariableType
Read, Int -> VariableType -> ShowS
[VariableType] -> ShowS
VariableType -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [VariableType] -> ShowS
$cshowList :: [VariableType] -> ShowS
show :: VariableType -> String
$cshow :: VariableType -> String
showsPrec :: Int -> VariableType -> ShowS
$cshowsPrec :: Int -> VariableType -> ShowS
Show)

_VariableType :: Name
_VariableType = (String -> Name
Name String
"hydra/core.VariableType")

-- | An instance of a union type; i.e. a string-indexed generalization of inl() or inr()
data Union m = 
  Union {
    forall m. Union m -> Name
unionTypeName :: Name,
    forall m. Union m -> Field m
unionField :: (Field m)}
  deriving (Union m -> Union m -> Bool
forall m. Eq m => Union m -> Union m -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Union m -> Union m -> Bool
$c/= :: forall m. Eq m => Union m -> Union m -> Bool
== :: Union m -> Union m -> Bool
$c== :: forall m. Eq m => Union m -> Union m -> Bool
Eq, Union m -> Union m -> Bool
Union m -> Union m -> Ordering
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
forall {m}. Ord m => Eq (Union m)
forall m. Ord m => Union m -> Union m -> Bool
forall m. Ord m => Union m -> Union m -> Ordering
forall m. Ord m => Union m -> Union m -> Union m
min :: Union m -> Union m -> Union m
$cmin :: forall m. Ord m => Union m -> Union m -> Union m
max :: Union m -> Union m -> Union m
$cmax :: forall m. Ord m => Union m -> Union m -> Union m
>= :: Union m -> Union m -> Bool
$c>= :: forall m. Ord m => Union m -> Union m -> Bool
> :: Union m -> Union m -> Bool
$c> :: forall m. Ord m => Union m -> Union m -> Bool
<= :: Union m -> Union m -> Bool
$c<= :: forall m. Ord m => Union m -> Union m -> Bool
< :: Union m -> Union m -> Bool
$c< :: forall m. Ord m => Union m -> Union m -> Bool
compare :: Union m -> Union m -> Ordering
$ccompare :: forall m. Ord m => Union m -> Union m -> Ordering
Ord, ReadPrec [Union m]
ReadPrec (Union m)
ReadS [Union m]
forall m. (Read m, Ord m) => ReadPrec [Union m]
forall m. (Read m, Ord m) => ReadPrec (Union m)
forall m. (Read m, Ord m) => Int -> ReadS (Union m)
forall m. (Read m, Ord m) => ReadS [Union m]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Union m]
$creadListPrec :: forall m. (Read m, Ord m) => ReadPrec [Union m]
readPrec :: ReadPrec (Union m)
$creadPrec :: forall m. (Read m, Ord m) => ReadPrec (Union m)
readList :: ReadS [Union m]
$creadList :: forall m. (Read m, Ord m) => ReadS [Union m]
readsPrec :: Int -> ReadS (Union m)
$creadsPrec :: forall m. (Read m, Ord m) => Int -> ReadS (Union m)
Read, Int -> Union m -> ShowS
forall m. Show m => Int -> Union m -> ShowS
forall m. Show m => [Union m] -> ShowS
forall m. Show m => Union m -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Union m] -> ShowS
$cshowList :: forall m. Show m => [Union m] -> ShowS
show :: Union m -> String
$cshow :: forall m. Show m => Union m -> String
showsPrec :: Int -> Union m -> ShowS
$cshowsPrec :: forall m. Show m => Int -> Union m -> ShowS
Show)

_Union :: Name
_Union = (String -> Name
Name String
"hydra/core.Union")

_Union_typeName :: FieldName
_Union_typeName = (String -> FieldName
FieldName String
"typeName")

_Union_field :: FieldName
_Union_field = (String -> FieldName
FieldName String
"field")

-- | An empty record type as a canonical unit type
data UnitType = 
  UnitType {}
  deriving (UnitType -> UnitType -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UnitType -> UnitType -> Bool
$c/= :: UnitType -> UnitType -> Bool
== :: UnitType -> UnitType -> Bool
$c== :: UnitType -> UnitType -> Bool
Eq, Eq UnitType
UnitType -> UnitType -> Bool
UnitType -> UnitType -> Ordering
UnitType -> UnitType -> UnitType
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
min :: UnitType -> UnitType -> UnitType
$cmin :: UnitType -> UnitType -> UnitType
max :: UnitType -> UnitType -> UnitType
$cmax :: UnitType -> UnitType -> UnitType
>= :: UnitType -> UnitType -> Bool
$c>= :: UnitType -> UnitType -> Bool
> :: UnitType -> UnitType -> Bool
$c> :: UnitType -> UnitType -> Bool
<= :: UnitType -> UnitType -> Bool
$c<= :: UnitType -> UnitType -> Bool
< :: UnitType -> UnitType -> Bool
$c< :: UnitType -> UnitType -> Bool
compare :: UnitType -> UnitType -> Ordering
$ccompare :: UnitType -> UnitType -> Ordering
Ord, ReadPrec [UnitType]
ReadPrec UnitType
Int -> ReadS UnitType
ReadS [UnitType]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [UnitType]
$creadListPrec :: ReadPrec [UnitType]
readPrec :: ReadPrec UnitType
$creadPrec :: ReadPrec UnitType
readList :: ReadS [UnitType]
$creadList :: ReadS [UnitType]
readsPrec :: Int -> ReadS UnitType
$creadsPrec :: Int -> ReadS UnitType
Read, Int -> UnitType -> ShowS
[UnitType] -> ShowS
UnitType -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [UnitType] -> ShowS
$cshowList :: [UnitType] -> ShowS
show :: UnitType -> String
$cshow :: UnitType -> String
showsPrec :: Int -> UnitType -> ShowS
$cshowsPrec :: Int -> UnitType -> ShowS
Show)

_UnitType :: Name
_UnitType = (String -> Name
Name String
"hydra/core.UnitType")