{-# LANGUAGE OverloadedStrings #-}

module Hydra.Sources.Tier2.Tier2 where

-- Standard Tier-2 imports
import           Prelude hiding ((++))
import qualified Data.List                 as L
import qualified Data.Map                  as M
import qualified Data.Set                  as S
import qualified Data.Maybe                as Y
import           Hydra.Dsl.Base            as Base
import qualified Hydra.Dsl.Core            as Core
import qualified Hydra.Dsl.Graph           as Graph
import qualified Hydra.Dsl.Lib.Equality    as Equality
import qualified Hydra.Dsl.Lib.Flows       as Flows
import qualified Hydra.Dsl.Lib.Io          as Io
import qualified Hydra.Dsl.Lib.Lists       as Lists
import qualified Hydra.Dsl.Lib.Literals    as Literals
import qualified Hydra.Dsl.Lib.Logic       as Logic
import qualified Hydra.Dsl.Lib.Maps        as Maps
import qualified Hydra.Dsl.Lib.Math        as Math
import qualified Hydra.Dsl.Lib.Optionals   as Optionals
import qualified Hydra.Dsl.Lib.Sets        as Sets
import           Hydra.Dsl.Lib.Strings     as Strings
import qualified Hydra.Dsl.Module          as Module
import qualified Hydra.Dsl.Terms           as Terms
import qualified Hydra.Dsl.Types           as Types
import           Hydra.Sources.Tier1.All


tier2Definition :: String -> Datum a -> Definition a
tier2Definition :: forall a. String -> Datum a -> Definition a
tier2Definition = Module -> String -> Datum a -> Definition a
forall a. Module -> String -> Datum a -> Definition a
definitionInModule Module
hydraTier2Module

hydraTier2Module :: Module
hydraTier2Module :: Module
hydraTier2Module = Namespace
-> [Element] -> [Module] -> [Module] -> Maybe String -> Module
Module (String -> Namespace
Namespace String
"hydra/tier2") [Element]
elements
   [Module
hydraGraphModule, Module
hydraMantleModule, Module
hydraComputeModule, Module
hydraStripModule] [Module]
tier0Modules (Maybe String -> Module) -> Maybe String -> Module
forall a b. (a -> b) -> a -> b
$
    String -> Maybe String
forall a. a -> Maybe a
Just (String
"A module for miscellaneous tier-2 functions and constants.")
  where
   elements :: [Element]
elements = [
     Definition (Flow Any Any) -> Element
forall a. Definition a -> Element
el Definition (Flow Any Any)
forall s. Definition (Flow s s)
getStateDef,
     Definition (Term -> Flow Graph (Maybe Type)) -> Element
forall a. Definition a -> Element
el Definition (Term -> Flow Graph (Maybe Type))
getTermTypeDef,
     Definition (Any -> Flow Any ()) -> Element
forall a. Definition a -> Element
el Definition (Any -> Flow Any ())
forall s. Definition (s -> Flow s ())
putStateDef,
     Definition (Element -> Flow Graph Type) -> Element
forall a. Definition a -> Element
el Definition (Element -> Flow Graph Type)
requireElementTypeDef,
     Definition (Term -> Flow Graph Type) -> Element
forall a. Definition a -> Element
el Definition (Term -> Flow Graph Type)
requireTermTypeDef,
     Definition (String -> String -> Flow Any Any) -> Element
forall a. Definition a -> Element
el Definition (String -> String -> Flow Any Any)
forall s x. Definition (String -> String -> Flow s x)
unexpectedDef
     ]

getStateDef :: Definition (Flow s s)
getStateDef :: forall s. Definition (Flow s s)
getStateDef = String -> Datum (Flow s s) -> Definition (Flow s s)
forall a. String -> Datum a -> Definition a
tier2Definition String
"getState" (Datum (Flow s s) -> Definition (Flow s s))
-> Datum (Flow s s) -> Definition (Flow s s)
forall a b. (a -> b) -> a -> b
$
  String -> Datum (Flow s s) -> Datum (Flow s s)
forall a. String -> Datum a -> Datum a
doc String
"Get the state of the current flow" (Datum (Flow s s) -> Datum (Flow s s))
-> Datum (Flow s s) -> Datum (Flow s s)
forall a b. (a -> b) -> a -> b
$
  Type -> Datum (Flow s s) -> Datum (Flow s s)
forall a. Type -> Datum a -> Datum a
typed Type
flowSST (Datum (Flow s s) -> Datum (Flow s s))
-> Datum (Flow s s) -> Datum (Flow s s)
forall a b. (a -> b) -> a -> b
$
  Name -> Datum (Any -> Any) -> Datum (Flow s s)
forall a b. Name -> Datum a -> Datum b
wrap Name
_Flow (String -> Datum (Any -> Any) -> Datum (Any -> Any)
forall x a b. String -> Datum x -> Datum (a -> b)
lambda String
"s0" (Datum (Any -> Any) -> Datum (Any -> Any))
-> Datum (Any -> Any) -> Datum (Any -> Any)
forall a b. (a -> b) -> a -> b
$ String -> Datum Any -> Datum (Any -> Any)
forall x a b. String -> Datum x -> Datum (a -> b)
lambda String
"t0" (Datum Any -> Datum (Any -> Any))
-> Datum Any -> Datum (Any -> Any)
forall a b. (a -> b) -> a -> b
$ (
    (String
-> Datum (Any -> Any) -> Datum (Maybe Any -> Any -> Trace -> Any)
forall x a b. String -> Datum x -> Datum (a -> b)
lambda String
"v" (Datum (Any -> Any) -> Datum (Maybe Any -> Any -> Trace -> Any))
-> Datum (Any -> Any) -> Datum (Maybe Any -> Any -> Trace -> Any)
forall a b. (a -> b) -> a -> b
$ String -> Datum (Any -> Any) -> Datum (Any -> Any)
forall x a b. String -> Datum x -> Datum (a -> b)
lambda String
"s" (Datum (Any -> Any) -> Datum (Any -> Any))
-> Datum (Any -> Any) -> Datum (Any -> Any)
forall a b. (a -> b) -> a -> b
$ String -> Datum (FlowState Any Any) -> Datum (Any -> Any)
forall x a b. String -> Datum x -> Datum (a -> b)
lambda String
"t" (Datum (FlowState Any Any) -> Datum (Any -> Any))
-> Datum (FlowState Any Any) -> Datum (Any -> Any)
forall a b. (a -> b) -> a -> b
$ (
      (Datum (FlowState Any Any)
-> Datum (Any -> FlowState Any Any)
-> Datum (Maybe Any -> FlowState Any Any)
forall b a. Datum b -> Datum (a -> b) -> Datum (Maybe a -> b)
matchOpt
        (Datum (Maybe Any)
-> Datum Any -> Datum Trace -> Datum (FlowState Any Any)
forall x s.
Datum (Maybe x) -> Datum s -> Datum Trace -> Datum (FlowState s x)
Flows.flowState Datum (Maybe Any)
forall x. Datum x
nothing (String -> Datum Any
forall a. String -> Datum a
var String
"s") (String -> Datum Trace
forall a. String -> Datum a
var String
"t"))
        (Datum (FlowState Any Any) -> Datum (Any -> FlowState Any Any)
forall a b. Datum a -> Datum (b -> a)
constant (Datum (Maybe Any)
-> Datum Any -> Datum Trace -> Datum (FlowState Any Any)
forall x s.
Datum (Maybe x) -> Datum s -> Datum Trace -> Datum (FlowState s x)
Flows.flowState (Datum Any -> Datum (Maybe Any)
forall x. Datum x -> Datum (Maybe x)
just (Datum Any -> Datum (Maybe Any)) -> Datum Any -> Datum (Maybe Any)
forall a b. (a -> b) -> a -> b
$ String -> Datum Any
forall a. String -> Datum a
var String
"s") (String -> Datum Any
forall a. String -> Datum a
var String
"s") (String -> Datum Trace
forall a. String -> Datum a
var String
"t"))))
       Datum (Maybe Any -> FlowState Any Any)
-> Datum (Maybe Any) -> Datum (FlowState Any Any)
forall a b. Datum (a -> b) -> Datum a -> Datum b
@@ String -> Datum (Maybe Any)
forall a. String -> Datum a
var String
"v"))
    Datum (Maybe Any -> Any -> Trace -> Any)
-> Datum (Maybe Any) -> Datum (Any -> Trace -> Any)
forall a b. Datum (a -> b) -> Datum a -> Datum b
@@ (Datum (FlowState Any Any -> Maybe Any)
forall s x. Datum (FlowState s x -> Maybe x)
Flows.flowStateValue Datum (FlowState Any Any -> Maybe Any)
-> Datum (FlowState Any Any) -> Datum (Maybe Any)
forall a b. Datum (a -> b) -> Datum a -> Datum b
@@ String -> Datum (FlowState Any Any)
forall a. String -> Datum a
var String
"fs1") Datum (Any -> Trace -> Any) -> Datum Any -> Datum (Trace -> Any)
forall a b. Datum (a -> b) -> Datum a -> Datum b
@@ (Datum (FlowState Any Any -> Any)
forall s x. Datum (FlowState s x -> s)
Flows.flowStateState Datum (FlowState Any Any -> Any)
-> Datum (FlowState Any Any) -> Datum Any
forall a b. Datum (a -> b) -> Datum a -> Datum b
@@ String -> Datum (FlowState Any Any)
forall a. String -> Datum a
var String
"fs1") Datum (Trace -> Any) -> Datum Trace -> Datum Any
forall a b. Datum (a -> b) -> Datum a -> Datum b
@@ (Datum (FlowState Any Any -> Trace)
forall s x. Datum (FlowState s x -> Trace)
Flows.flowStateTrace Datum (FlowState Any Any -> Trace)
-> Datum (FlowState Any Any) -> Datum Trace
forall a b. Datum (a -> b) -> Datum a -> Datum b
@@ String -> Datum (FlowState Any Any)
forall a. String -> Datum a
var String
"fs1"))
  Datum Any -> [Field] -> Datum Any
forall a. Datum a -> [Field] -> Datum a
`with` [
    String
"fs1"String -> Datum (FlowState Any Any) -> Field
forall a. String -> Datum a -> Field
>:
      Type -> Datum (FlowState Any Any) -> Datum (FlowState Any Any)
forall a. Type -> Datum a -> Datum a
typed (Type -> Type -> Type
Types.apply (Type -> Type -> Type
Types.apply (Name -> Type
TypeVariable Name
_FlowState) Type
sT) Type
unitT) (Datum (FlowState Any Any) -> Datum (FlowState Any Any))
-> Datum (FlowState Any Any) -> Datum (FlowState Any Any)
forall a b. (a -> b) -> a -> b
$
      Datum (Flow Any Any -> Any -> Trace -> FlowState Any Any)
forall s x. Datum (Flow s x -> s -> Trace -> FlowState s x)
Flows.unFlow Datum (Flow Any Any -> Any -> Trace -> FlowState Any Any)
-> Datum (Flow Any Any)
-> Datum (Any -> Trace -> FlowState Any Any)
forall a b. Datum (a -> b) -> Datum a -> Datum b
@@ (Datum (Any -> Flow Any Any)
forall x s. Datum (x -> Flow s x)
Flows.pure Datum (Any -> Flow Any Any) -> Datum Any -> Datum (Flow Any Any)
forall a b. Datum (a -> b) -> Datum a -> Datum b
@@ Datum Any
forall x. Datum x
unit) Datum (Any -> Trace -> FlowState Any Any)
-> Datum Any -> Datum (Trace -> FlowState Any Any)
forall a b. Datum (a -> b) -> Datum a -> Datum b
@@ String -> Datum Any
forall a. String -> Datum a
var String
"s0" Datum (Trace -> FlowState Any Any)
-> Datum Trace -> Datum (FlowState Any Any)
forall a b. Datum (a -> b) -> Datum a -> Datum b
@@ String -> Datum Trace
forall a. String -> Datum a
var String
"t0"])

getTermTypeDef :: Definition (Term -> Flow Graph (Maybe Type))
getTermTypeDef :: Definition (Term -> Flow Graph (Maybe Type))
getTermTypeDef = String
-> Datum (Term -> Flow Graph (Maybe Type))
-> Definition (Term -> Flow Graph (Maybe Type))
forall a. String -> Datum a -> Definition a
tier2Definition String
"getTermType" (Datum (Term -> Flow Graph (Maybe Type))
 -> Definition (Term -> Flow Graph (Maybe Type)))
-> Datum (Term -> Flow Graph (Maybe Type))
-> Definition (Term -> Flow Graph (Maybe Type))
forall a b. (a -> b) -> a -> b
$
  String
-> Datum (Term -> Flow Graph (Maybe Type))
-> Datum (Term -> Flow Graph (Maybe Type))
forall a. String -> Datum a -> Datum a
doc String
"Get the annotated type of a given term, if any" (Datum (Term -> Flow Graph (Maybe Type))
 -> Datum (Term -> Flow Graph (Maybe Type)))
-> Datum (Term -> Flow Graph (Maybe Type))
-> Datum (Term -> Flow Graph (Maybe Type))
forall a b. (a -> b) -> a -> b
$
  Type
-> Type
-> Datum (Term -> Flow Graph (Maybe Type))
-> Datum (Term -> Flow Graph (Maybe Type))
forall a. Type -> Type -> Datum a -> Datum a
function Type
termT (Type -> Type
optionalT Type
typeT) (Datum (Term -> Flow Graph (Maybe Type))
 -> Datum (Term -> Flow Graph (Maybe Type)))
-> Datum (Term -> Flow Graph (Maybe Type))
-> Datum (Term -> Flow Graph (Maybe Type))
forall a b. (a -> b) -> a -> b
$
  Name
-> Maybe (Datum (Flow Graph (Maybe Type)))
-> [Field]
-> Datum (Term -> Flow Graph (Maybe Type))
forall b u. Name -> Maybe (Datum b) -> [Field] -> Datum (u -> b)
match Name
_Term (Datum (Flow Graph (Maybe Type))
-> Maybe (Datum (Flow Graph (Maybe Type)))
forall a. a -> Maybe a
Just Datum (Flow Graph (Maybe Type))
forall x. Datum x
nothing) [
    String
"annotated"String -> Datum (Any -> Flow Graph (Maybe Type)) -> Field
forall a. String -> Datum a -> Field
>: Definition (Term -> Flow Graph (Maybe Type))
-> Datum (Term -> Flow Graph (Maybe Type))
forall a. Definition a -> Datum a
ref Definition (Term -> Flow Graph (Maybe Type))
getTermTypeDef Datum (Term -> Flow Graph (Maybe Type))
-> Datum (Any -> Term) -> Datum (Any -> Flow Graph (Maybe Type))
forall b c a. Datum (b -> c) -> Datum (a -> b) -> Datum (a -> c)
<.> Name -> Name -> Datum (Any -> Term)
forall a b. Name -> Name -> Datum (a -> b)
project Name
_AnnotatedTerm Name
_AnnotatedTerm_subject,
    String
"typed"String -> Datum (Any -> Any) -> Field
forall a. String -> Datum a -> Field
>: String -> Datum (Maybe Any) -> Datum (Any -> Any)
forall x a b. String -> Datum x -> Datum (a -> b)
lambda String
"tt" (Datum (Maybe Any) -> Datum (Any -> Any))
-> Datum (Maybe Any) -> Datum (Any -> Any)
forall a b. (a -> b) -> a -> b
$ Datum Any -> Datum (Maybe Any)
forall x. Datum x -> Datum (Maybe x)
just (Name -> Name -> Datum (Any -> Any)
forall a b. Name -> Name -> Datum (a -> b)
project Name
_TypedTerm Name
_TypedTerm_type Datum (Any -> Any) -> Datum Any -> Datum Any
forall a b. Datum (a -> b) -> Datum a -> Datum b
@@ String -> Datum Any
forall a. String -> Datum a
var String
"tt")]

putStateDef :: Definition (s -> Flow s ())
putStateDef :: forall s. Definition (s -> Flow s ())
putStateDef = String -> Datum (s -> Flow s ()) -> Definition (s -> Flow s ())
forall a. String -> Datum a -> Definition a
tier2Definition String
"putState" (Datum (s -> Flow s ()) -> Definition (s -> Flow s ()))
-> Datum (s -> Flow s ()) -> Definition (s -> Flow s ())
forall a b. (a -> b) -> a -> b
$
  String -> Datum (s -> Flow s ()) -> Datum (s -> Flow s ())
forall a. String -> Datum a -> Datum a
doc String
"Set the state of a flow" (Datum (s -> Flow s ()) -> Datum (s -> Flow s ()))
-> Datum (s -> Flow s ()) -> Datum (s -> Flow s ())
forall a b. (a -> b) -> a -> b
$
  Type -> Type -> Datum (s -> Flow s ()) -> Datum (s -> Flow s ())
forall a. Type -> Type -> Datum a -> Datum a
function Type
sT (Type -> Type -> Type
flowT Type
sT Type
unitT) (Datum (s -> Flow s ()) -> Datum (s -> Flow s ()))
-> Datum (s -> Flow s ()) -> Datum (s -> Flow s ())
forall a b. (a -> b) -> a -> b
$
  String -> Datum Any -> Datum (s -> Flow s ())
forall x a b. String -> Datum x -> Datum (a -> b)
lambda String
"cx" (Datum Any -> Datum (s -> Flow s ()))
-> Datum Any -> Datum (s -> Flow s ())
forall a b. (a -> b) -> a -> b
$ Name -> Datum (Any -> Any) -> Datum Any
forall a b. Name -> Datum a -> Datum b
wrap Name
_Flow (Datum (Any -> Any) -> Datum Any)
-> Datum (Any -> Any) -> Datum Any
forall a b. (a -> b) -> a -> b
$ String -> Datum (Any -> Any) -> Datum (Any -> Any)
forall x a b. String -> Datum x -> Datum (a -> b)
lambda String
"s0" (Datum (Any -> Any) -> Datum (Any -> Any))
-> Datum (Any -> Any) -> Datum (Any -> Any)
forall a b. (a -> b) -> a -> b
$ String -> Datum (FlowState Any Any) -> Datum (Any -> Any)
forall x a b. String -> Datum x -> Datum (a -> b)
lambda String
"t0" (
    (Datum (Maybe Any)
-> Datum Any -> Datum Trace -> Datum (FlowState Any Any)
forall x s.
Datum (Maybe x) -> Datum s -> Datum Trace -> Datum (FlowState s x)
Flows.flowState
      (Datum (FlowState Any Any -> Maybe Any)
forall s x. Datum (FlowState s x -> Maybe x)
Flows.flowStateValue Datum (FlowState Any Any -> Maybe Any)
-> Datum (FlowState Any Any) -> Datum (Maybe Any)
forall a b. Datum (a -> b) -> Datum a -> Datum b
@@ String -> Datum (FlowState Any Any)
forall a. String -> Datum a
var String
"f1")
      (String -> Datum Any
forall a. String -> Datum a
var String
"cx")
      (Datum (FlowState Any Any -> Trace)
forall s x. Datum (FlowState s x -> Trace)
Flows.flowStateTrace Datum (FlowState Any Any -> Trace)
-> Datum (FlowState Any Any) -> Datum Trace
forall a b. Datum (a -> b) -> Datum a -> Datum b
@@ String -> Datum (FlowState Any Any)
forall a. String -> Datum a
var String
"f1"))
    Datum (FlowState Any Any) -> [Field] -> Datum (FlowState Any Any)
forall a. Datum a -> [Field] -> Datum a
`with` [
      String
"f1"String -> Datum (FlowState Any Any) -> Field
forall a. String -> Datum a -> Field
>: Datum (Flow Any Any -> Any -> Trace -> FlowState Any Any)
forall s x. Datum (Flow s x -> s -> Trace -> FlowState s x)
Flows.unFlow Datum (Flow Any Any -> Any -> Trace -> FlowState Any Any)
-> Datum (Flow Any Any)
-> Datum (Any -> Trace -> FlowState Any Any)
forall a b. Datum (a -> b) -> Datum a -> Datum b
@@ (Datum (Any -> Flow Any Any)
forall x s. Datum (x -> Flow s x)
Flows.pure Datum (Any -> Flow Any Any) -> Datum Any -> Datum (Flow Any Any)
forall a b. Datum (a -> b) -> Datum a -> Datum b
@@ Datum Any
forall x. Datum x
unit) Datum (Any -> Trace -> FlowState Any Any)
-> Datum Any -> Datum (Trace -> FlowState Any Any)
forall a b. Datum (a -> b) -> Datum a -> Datum b
@@ String -> Datum Any
forall a. String -> Datum a
var String
"s0" Datum (Trace -> FlowState Any Any)
-> Datum Trace -> Datum (FlowState Any Any)
forall a b. Datum (a -> b) -> Datum a -> Datum b
@@ String -> Datum Trace
forall a. String -> Datum a
var String
"t0"])

requireElementTypeDef :: Definition (Element -> Flow Graph Type)
requireElementTypeDef :: Definition (Element -> Flow Graph Type)
requireElementTypeDef = String
-> Datum (Element -> Flow Graph Type)
-> Definition (Element -> Flow Graph Type)
forall a. String -> Datum a -> Definition a
tier2Definition String
"requireElementType" (Datum (Element -> Flow Graph Type)
 -> Definition (Element -> Flow Graph Type))
-> Datum (Element -> Flow Graph Type)
-> Definition (Element -> Flow Graph Type)
forall a b. (a -> b) -> a -> b
$
  String
-> Datum (Element -> Flow Graph Type)
-> Datum (Element -> Flow Graph Type)
forall a. String -> Datum a -> Datum a
doc String
"Get the annotated type of a given element, or fail if it is missing" (Datum (Element -> Flow Graph Type)
 -> Datum (Element -> Flow Graph Type))
-> Datum (Element -> Flow Graph Type)
-> Datum (Element -> Flow Graph Type)
forall a b. (a -> b) -> a -> b
$
  Type
-> Type
-> Datum (Element -> Flow Graph Type)
-> Datum (Element -> Flow Graph Type)
forall a. Type -> Type -> Datum a -> Datum a
function Type
elementT (Type -> Type -> Type
flowT Type
graphT Type
typeT) (Datum (Element -> Flow Graph Type)
 -> Datum (Element -> Flow Graph Type))
-> Datum (Element -> Flow Graph Type)
-> Datum (Element -> Flow Graph Type)
forall a b. (a -> b) -> a -> b
$
  String -> Datum Any -> Datum (Element -> Flow Graph Type)
forall x a b. String -> Datum x -> Datum (a -> b)
lambda String
"el" (Datum Any -> Datum (Element -> Flow Graph Type))
-> Datum Any -> Datum (Element -> Flow Graph Type)
forall a b. (a -> b) -> a -> b
$ ((String -> Datum (Flow Graph (Maybe Type) -> Any)
forall a. String -> Datum a
var String
"withType" Datum (Flow Graph (Maybe Type) -> Any)
-> Datum (Flow Graph (Maybe Type)) -> Datum Any
forall a b. Datum (a -> b) -> Datum a -> Datum b
@@ (Definition (Term -> Flow Graph (Maybe Type))
-> Datum (Term -> Flow Graph (Maybe Type))
forall a. Definition a -> Datum a
ref Definition (Term -> Flow Graph (Maybe Type))
getTermTypeDef Datum (Term -> Flow Graph (Maybe Type))
-> Datum Term -> Datum (Flow Graph (Maybe Type))
forall a b. Datum (a -> b) -> Datum a -> Datum b
@@ (Name -> Name -> Datum (Any -> Term)
forall a b. Name -> Name -> Datum (a -> b)
project Name
_Element Name
_Element_data Datum (Any -> Term) -> Datum Any -> Datum Term
forall a b. Datum (a -> b) -> Datum a -> Datum b
@@ String -> Datum Any
forall a. String -> Datum a
var String
"el")))
    Datum Any -> [Field] -> Datum Any
forall a. Datum a -> [Field] -> Datum a
`with` [
      String
"withType"String -> Datum (Maybe Any -> Flow Any Any) -> Field
forall a. String -> Datum a -> Field
>: Datum (Flow Any Any)
-> Datum (Any -> Flow Any Any) -> Datum (Maybe Any -> Flow Any Any)
forall b a. Datum b -> Datum (a -> b) -> Datum (Maybe a -> b)
matchOpt
       (Datum (String -> Flow Any Any)
forall s x. Datum (String -> Flow s x)
Flows.fail Datum (String -> Flow Any Any)
-> Datum String -> Datum (Flow Any Any)
forall a b. Datum (a -> b) -> Datum a -> Datum b
@@ (Datum String
"missing type annotation for element " Datum String -> Datum String -> Datum String
++ (Name -> Datum (Any -> String)
forall a b. Name -> Datum (a -> b)
unwrap Name
_Name Datum (Any -> String) -> Datum Any -> Datum String
forall a b. Datum (a -> b) -> Datum a -> Datum b
@@ (Name -> Name -> Datum (Any -> Any)
forall a b. Name -> Name -> Datum (a -> b)
project Name
_Element Name
_Element_name Datum (Any -> Any) -> Datum Any -> Datum Any
forall a b. Datum (a -> b) -> Datum a -> Datum b
@@ String -> Datum Any
forall a. String -> Datum a
var String
"el"))))
       Datum (Any -> Flow Any Any)
forall x s. Datum (x -> Flow s x)
Flows.pure])

requireTermTypeDef :: Definition (Term -> Flow Graph Type)
requireTermTypeDef :: Definition (Term -> Flow Graph Type)
requireTermTypeDef = String
-> Datum (Term -> Flow Graph Type)
-> Definition (Term -> Flow Graph Type)
forall a. String -> Datum a -> Definition a
tier2Definition String
"requireTermType" (Datum (Term -> Flow Graph Type)
 -> Definition (Term -> Flow Graph Type))
-> Datum (Term -> Flow Graph Type)
-> Definition (Term -> Flow Graph Type)
forall a b. (a -> b) -> a -> b
$
  String
-> Datum (Term -> Flow Graph Type)
-> Datum (Term -> Flow Graph Type)
forall a. String -> Datum a -> Datum a
doc String
"Get the annotated type of a given term, or fail if it is missing" (Datum (Term -> Flow Graph Type)
 -> Datum (Term -> Flow Graph Type))
-> Datum (Term -> Flow Graph Type)
-> Datum (Term -> Flow Graph Type)
forall a b. (a -> b) -> a -> b
$
  Type
-> Type
-> Datum (Term -> Flow Graph Type)
-> Datum (Term -> Flow Graph Type)
forall a. Type -> Type -> Datum a -> Datum a
function Type
termT (Type -> Type -> Type
flowT Type
graphT Type
typeT) (Datum (Term -> Flow Graph Type)
 -> Datum (Term -> Flow Graph Type))
-> Datum (Term -> Flow Graph Type)
-> Datum (Term -> Flow Graph Type)
forall a b. (a -> b) -> a -> b
$
  (String -> Datum (Flow Graph (Maybe Type) -> Flow Graph Type)
forall a. String -> Datum a
var String
"withType" Datum (Flow Graph (Maybe Type) -> Flow Graph Type)
-> Datum (Term -> Flow Graph (Maybe Type))
-> Datum (Term -> Flow Graph Type)
forall b c a. Datum (b -> c) -> Datum (a -> b) -> Datum (a -> c)
<.> Definition (Term -> Flow Graph (Maybe Type))
-> Datum (Term -> Flow Graph (Maybe Type))
forall a. Definition a -> Datum a
ref Definition (Term -> Flow Graph (Maybe Type))
getTermTypeDef)
    Datum (Term -> Flow Graph Type)
-> [Field] -> Datum (Term -> Flow Graph Type)
forall a. Datum a -> [Field] -> Datum a
`with` [
      String
"withType"String -> Datum (Maybe Any -> Flow Any Any) -> Field
forall a. String -> Datum a -> Field
>: Datum (Flow Any Any)
-> Datum (Any -> Flow Any Any) -> Datum (Maybe Any -> Flow Any Any)
forall b a. Datum b -> Datum (a -> b) -> Datum (Maybe a -> b)
matchOpt
       (Datum (String -> Flow Any Any)
forall s x. Datum (String -> Flow s x)
Flows.fail Datum (String -> Flow Any Any)
-> Datum String -> Datum (Flow Any Any)
forall a b. Datum (a -> b) -> Datum a -> Datum b
@@ Datum String
"missing type annotation")
       Datum (Any -> Flow Any Any)
forall x s. Datum (x -> Flow s x)
Flows.pure]

unexpectedDef :: Definition (String -> String -> Flow s x)
unexpectedDef :: forall s x. Definition (String -> String -> Flow s x)
unexpectedDef = String
-> Datum (String -> String -> Flow s x)
-> Definition (String -> String -> Flow s x)
forall a. String -> Datum a -> Definition a
tier2Definition String
"unexpected" (Datum (String -> String -> Flow s x)
 -> Definition (String -> String -> Flow s x))
-> Datum (String -> String -> Flow s x)
-> Definition (String -> String -> Flow s x)
forall a b. (a -> b) -> a -> b
$
  String
-> Datum (String -> String -> Flow s x)
-> Datum (String -> String -> Flow s x)
forall a. String -> Datum a -> Datum a
doc String
"Fail if an actual value does not match an expected value" (Datum (String -> String -> Flow s x)
 -> Datum (String -> String -> Flow s x))
-> Datum (String -> String -> Flow s x)
-> Datum (String -> String -> Flow s x)
forall a b. (a -> b) -> a -> b
$
  Type
-> Type
-> Datum (String -> String -> Flow s x)
-> Datum (String -> String -> Flow s x)
forall a. Type -> Type -> Datum a -> Datum a
function Type
stringT (Type -> Type -> Type
funT Type
stringT (Type -> Type -> Type
flowT Type
sT Type
xT)) (Datum (String -> String -> Flow s x)
 -> Datum (String -> String -> Flow s x))
-> Datum (String -> String -> Flow s x)
-> Datum (String -> String -> Flow s x)
forall a b. (a -> b) -> a -> b
$
  String
-> Datum (Any -> Any) -> Datum (String -> String -> Flow s x)
forall x a b. String -> Datum x -> Datum (a -> b)
lambda String
"expected" (Datum (Any -> Any) -> Datum (String -> String -> Flow s x))
-> Datum (Any -> Any) -> Datum (String -> String -> Flow s x)
forall a b. (a -> b) -> a -> b
$ String -> Datum (Flow Any Any) -> Datum (Any -> Any)
forall x a b. String -> Datum x -> Datum (a -> b)
lambda String
"actual" (Datum (Flow Any Any) -> Datum (Any -> Any))
-> Datum (Flow Any Any) -> Datum (Any -> Any)
forall a b. (a -> b) -> a -> b
$ Datum (String -> Flow Any Any)
forall s x. Datum (String -> Flow s x)
Flows.fail Datum (String -> Flow Any Any)
-> Datum String -> Datum (Flow Any Any)
forall a b. Datum (a -> b) -> Datum a -> Datum b
@@ (Datum String
"expected " Datum String -> Datum String -> Datum String
++ String -> Datum String
forall a. String -> Datum a
var String
"expected" Datum String -> Datum String -> Datum String
++ Datum String
" but found: " Datum String -> Datum String -> Datum String
++ String -> Datum String
forall a. String -> Datum a
var String
"actual")