module Hydra.Sources.Tier1.Decode where

-- Standard Tier-1 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.Tier0.All

import Hydra.Sources.Tier1.Strip

import qualified Data.Map as M
import qualified Data.Set as S


decodeDefinition :: String -> TTerm a -> TElement a
decodeDefinition :: forall a. String -> TTerm a -> TElement a
decodeDefinition = Module -> String -> TTerm a -> TElement a
forall a. Module -> String -> TTerm a -> TElement a
definitionInModule Module
decodeModule

decodeFunctionDefinition :: String -> Type -> Type -> TTerm a -> TElement a
decodeFunctionDefinition :: forall a. String -> Type -> Type -> TTerm a -> TElement a
decodeFunctionDefinition String
name Type
dom Type
cod TTerm a
term = String -> TTerm a -> TElement a
forall a. String -> TTerm a -> TElement a
decodeDefinition String
name (TTerm a -> TElement a) -> TTerm a -> TElement a
forall a b. (a -> b) -> a -> b
$
  Type -> Type -> TTerm a -> TTerm a
forall a. Type -> Type -> TTerm a -> TTerm a
function Type
dom (Type -> Type
optionalT Type
cod) TTerm a
term

decodeNominalFunctionDefinition :: String -> Type -> TTerm a -> TElement a
decodeNominalFunctionDefinition :: forall a. String -> Type -> TTerm a -> TElement a
decodeNominalFunctionDefinition String
name Type
cod TTerm a
term = String -> TTerm a -> TElement a
forall a. String -> TTerm a -> TElement a
decodeDefinition String
name (TTerm a -> TElement a) -> TTerm a -> TElement a
forall a b. (a -> b) -> a -> b
$
  Type -> Type -> TTerm a -> TTerm a
forall a. Type -> Type -> TTerm a -> TTerm a
function Type
nameT (Type -> Type -> Type
funT Type
termT (Type -> Type) -> Type -> Type
forall a b. (a -> b) -> a -> b
$ Type -> Type
optionalT Type
cod) TTerm a
term

decodeModule :: Module
decodeModule :: Module
decodeModule = Namespace
-> [Element] -> [Module] -> [Module] -> Maybe String -> Module
Module (String -> Namespace
Namespace String
"hydra/decode") [Element]
elements [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 decoding terms to native objects"
  where
   elements :: [Element]
elements = [
    TElement (Term -> Maybe Float) -> Element
forall a. TElement a -> Element
el TElement (Term -> Maybe Float)
bigfloatDef,
    TElement (FloatValue -> Maybe Float) -> Element
forall a. TElement a -> Element
el TElement (FloatValue -> Maybe Float)
bigfloatValueDef,
    TElement (Term -> Maybe Int) -> Element
forall a. TElement a -> Element
el TElement (Term -> Maybe Int)
bigintDef,
    TElement (IntegerValue -> Maybe Int) -> Element
forall a. TElement a -> Element
el TElement (IntegerValue -> Maybe Int)
bigintValueDef,
    TElement (Term -> Maybe String) -> Element
forall a. TElement a -> Element
el TElement (Term -> Maybe String)
binaryDef,
    TElement (Literal -> Maybe String) -> Element
forall a. TElement a -> Element
el TElement (Literal -> Maybe String)
binaryLiteralDef,
    TElement (Term -> Maybe Bool) -> Element
forall a. TElement a -> Element
el TElement (Term -> Maybe Bool)
booleanDef,
    TElement (Literal -> Maybe Bool) -> Element
forall a. TElement a -> Element
el TElement (Literal -> Maybe Bool)
booleanLiteralDef,
    TElement (Name -> Name -> Term -> Maybe Term) -> Element
forall a. TElement a -> Element
el TElement (Name -> Name -> Term -> Maybe Term)
casesCaseDef,
    TElement (Name -> Term -> Maybe [Field]) -> Element
forall a. TElement a -> Element
el TElement (Name -> Term -> Maybe [Field])
casesDef,
    TElement (Name -> [Field] -> Maybe Term) -> Element
forall a. TElement a -> Element
el TElement (Name -> [Field] -> Maybe Term)
fieldDef,
    TElement (Term -> Maybe Float) -> Element
forall a. TElement a -> Element
el TElement (Term -> Maybe Float)
float32Def,
    TElement (FloatValue -> Maybe Float) -> Element
forall a. TElement a -> Element
el TElement (FloatValue -> Maybe Float)
float32ValueDef,
    TElement (Term -> Maybe Float) -> Element
forall a. TElement a -> Element
el TElement (Term -> Maybe Float)
float64Def,
    TElement (FloatValue -> Maybe Float) -> Element
forall a. TElement a -> Element
el TElement (FloatValue -> Maybe Float)
float64ValueDef,
    TElement (Any -> Maybe Any) -> Element
forall a. TElement a -> Element
el TElement (Any -> Maybe Any)
forall {a} {b}. TElement (a -> Maybe b)
floatLiteralDef,
    TElement (Term -> Maybe Int) -> Element
forall a. TElement a -> Element
el TElement (Term -> Maybe Int)
int16Def,
    TElement (IntegerValue -> Maybe Int) -> Element
forall a. TElement a -> Element
el TElement (IntegerValue -> Maybe Int)
int16ValueDef,
    TElement (Term -> Maybe Int) -> Element
forall a. TElement a -> Element
el TElement (Term -> Maybe Int)
int32Def,
    TElement (IntegerValue -> Maybe Int) -> Element
forall a. TElement a -> Element
el TElement (IntegerValue -> Maybe Int)
int32ValueDef,
    TElement (Term -> Maybe Int) -> Element
forall a. TElement a -> Element
el TElement (Term -> Maybe Int)
int64Def,
    TElement (IntegerValue -> Maybe Int) -> Element
forall a. TElement a -> Element
el TElement (IntegerValue -> Maybe Int)
int64ValueDef,
    TElement (Term -> Maybe Int) -> Element
forall a. TElement a -> Element
el TElement (Term -> Maybe Int)
int8Def,
    TElement (IntegerValue -> Maybe Int) -> Element
forall a. TElement a -> Element
el TElement (IntegerValue -> Maybe Int)
int8ValueDef,
    TElement (Literal -> Maybe IntegerValue) -> Element
forall a. TElement a -> Element
el TElement (Literal -> Maybe IntegerValue)
integerLiteralDef,
    TElement (Term -> Maybe Lambda) -> Element
forall a. TElement a -> Element
el TElement (Term -> Maybe Lambda)
lambdaDef,
    TElement (Name -> Term -> Maybe LetBinding) -> Element
forall a. TElement a -> Element
el TElement (Name -> Term -> Maybe LetBinding)
letBindingDef,
    TElement (Name -> [LetBinding] -> Maybe LetBinding) -> Element
forall a. TElement a -> Element
el TElement (Name -> [LetBinding] -> Maybe LetBinding)
letBindingWithKeyDef,
    TElement (Term -> Maybe Let) -> Element
forall a. TElement a -> Element
el TElement (Term -> Maybe Let)
letTermDef,
    TElement (Term -> Maybe [Term]) -> Element
forall a. TElement a -> Element
el TElement (Term -> Maybe [Term])
listDef,
    TElement (Term -> Maybe Literal) -> Element
forall a. TElement a -> Element
el TElement (Term -> Maybe Literal)
literalDef,
    TElement (Term -> Maybe (Map Term Term)) -> Element
forall a. TElement a -> Element
el TElement (Term -> Maybe (Map Term Term))
mapDef,
    TElement (Term -> Name) -> Element
forall a. TElement a -> Element
el TElement (Term -> Name)
nameDef,
    TElement
  ((Any -> Name)
   -> (Any -> Any) -> (Any -> Maybe Any) -> Name -> Any -> Maybe Any)
-> Element
forall a. TElement a -> Element
el TElement
  ((Any -> Name)
   -> (Any -> Any) -> (Any -> Maybe Any) -> Name -> Any -> Maybe Any)
forall a b c.
TElement
  ((a -> Name) -> (a -> b) -> (c -> Maybe a) -> Name -> c -> Maybe b)
nominalDef,
    TElement (Term -> Maybe OptionalCases) -> Element
forall a. TElement a -> Element
el TElement (Term -> Maybe OptionalCases)
optCasesDef,
    TElement (Term -> Maybe Term) -> Element
forall a. TElement a -> Element
el TElement (Term -> Maybe Term)
optCasesJustDef,
    TElement (Term -> Maybe Term) -> Element
forall a. TElement a -> Element
el TElement (Term -> Maybe Term)
optCasesNothingDef,
    TElement (Term -> Maybe (Maybe Term)) -> Element
forall a. TElement a -> Element
el TElement (Term -> Maybe (Maybe Term))
optionalDef,
    TElement (Term -> Maybe (Term, Term)) -> Element
forall a. TElement a -> Element
el TElement (Term -> Maybe (Term, Term))
pairDef,
    TElement (Name -> Term -> Maybe [Field]) -> Element
forall a. TElement a -> Element
el TElement (Name -> Term -> Maybe [Field])
recordDef,
    TElement (Term -> Maybe (Set Term)) -> Element
forall a. TElement a -> Element
el TElement (Term -> Maybe (Set Term))
setDef,
    TElement (Term -> Maybe String) -> Element
forall a. TElement a -> Element
el TElement (Term -> Maybe String)
stringDef,
    TElement (Literal -> Maybe String) -> Element
forall a. TElement a -> Element
el TElement (Literal -> Maybe String)
stringLiteralDef,
    TElement (Term -> Maybe Int) -> Element
forall a. TElement a -> Element
el TElement (Term -> Maybe Int)
uint16Def,
    TElement (IntegerValue -> Maybe Int) -> Element
forall a. TElement a -> Element
el TElement (IntegerValue -> Maybe Int)
uint16ValueDef,
    TElement (Term -> Maybe Int) -> Element
forall a. TElement a -> Element
el TElement (Term -> Maybe Int)
uint32Def,
    TElement (IntegerValue -> Maybe Int) -> Element
forall a. TElement a -> Element
el TElement (IntegerValue -> Maybe Int)
uint32ValueDef,
    TElement (Term -> Maybe Int) -> Element
forall a. TElement a -> Element
el TElement (Term -> Maybe Int)
uint64Def,
    TElement (IntegerValue -> Maybe Int) -> Element
forall a. TElement a -> Element
el TElement (IntegerValue -> Maybe Int)
uint64ValueDef,
    TElement (Term -> Maybe Int) -> Element
forall a. TElement a -> Element
el TElement (Term -> Maybe Int)
uint8Def,
    TElement (IntegerValue -> Maybe Int) -> Element
forall a. TElement a -> Element
el TElement (IntegerValue -> Maybe Int)
uint8ValueDef,
    TElement (Term -> Maybe ()) -> Element
forall a. TElement a -> Element
el TElement (Term -> Maybe ())
unitDef,
    TElement (Name -> Term -> Maybe Name) -> Element
forall a. TElement a -> Element
el TElement (Name -> Term -> Maybe Name)
unitVariantDef,
    TElement (Term -> Maybe Name) -> Element
forall a. TElement a -> Element
el TElement (Term -> Maybe Name)
variableDef,
    TElement (Name -> Term -> Maybe Field) -> Element
forall a. TElement a -> Element
el TElement (Name -> Term -> Maybe Field)
variantDef,
    TElement (Name -> Term -> Maybe Term) -> Element
forall a. TElement a -> Element
el TElement (Name -> Term -> Maybe Term)
wrapDef]

bigfloatDef :: TElement (Term -> Maybe Float)
bigfloatDef :: TElement (Term -> Maybe Float)
bigfloatDef = String
-> Type
-> Type
-> TTerm (Term -> Maybe Float)
-> TElement (Term -> Maybe Float)
forall a. String -> Type -> Type -> TTerm a -> TElement a
decodeFunctionDefinition String
"bigfloat" Type
termT Type
bigfloatT (TTerm (Term -> Maybe Float) -> TElement (Term -> Maybe Float))
-> TTerm (Term -> Maybe Float) -> TElement (Term -> Maybe Float)
forall a b. (a -> b) -> a -> b
$
  TTerm (Term -> Maybe Literal)
-> TTerm (Literal -> Maybe FloatValue)
-> TTerm (FloatValue -> Maybe Float)
-> TTerm (Term -> Maybe Float)
forall a b c d.
TTerm (a -> Maybe b)
-> TTerm (b -> Maybe c)
-> TTerm (c -> Maybe d)
-> TTerm (a -> Maybe d)
compose3 (TElement (Term -> Maybe Literal) -> TTerm (Term -> Maybe Literal)
forall a. TElement a -> TTerm a
ref TElement (Term -> Maybe Literal)
literalDef) (TElement (Literal -> Maybe FloatValue)
-> TTerm (Literal -> Maybe FloatValue)
forall a. TElement a -> TTerm a
ref TElement (Literal -> Maybe FloatValue)
forall {a} {b}. TElement (a -> Maybe b)
floatLiteralDef) (TElement (FloatValue -> Maybe Float)
-> TTerm (FloatValue -> Maybe Float)
forall a. TElement a -> TTerm a
ref TElement (FloatValue -> Maybe Float)
bigfloatValueDef)

bigfloatValueDef :: TElement (FloatValue -> Maybe Float)
bigfloatValueDef :: TElement (FloatValue -> Maybe Float)
bigfloatValueDef = String
-> Type
-> Type
-> TTerm (FloatValue -> Maybe Float)
-> TElement (FloatValue -> Maybe Float)
forall a. String -> Type -> Type -> TTerm a -> TElement a
decodeFunctionDefinition String
"bigfloatValue" Type
floatValueT Type
bigfloatT (TTerm (FloatValue -> Maybe Float)
 -> TElement (FloatValue -> Maybe Float))
-> TTerm (FloatValue -> Maybe Float)
-> TElement (FloatValue -> Maybe Float)
forall a b. (a -> b) -> a -> b
$
  Name -> Name -> TTerm (FloatValue -> Maybe Float)
forall a b. Name -> Name -> TTerm (a -> Maybe b)
matchVariant Name
_FloatValue Name
_FloatValue_bigfloat

bigintDef :: TElement (Term -> Maybe Int)
bigintDef :: TElement (Term -> Maybe Int)
bigintDef = String
-> Type
-> Type
-> TTerm (Term -> Maybe Int)
-> TElement (Term -> Maybe Int)
forall a. String -> Type -> Type -> TTerm a -> TElement a
decodeFunctionDefinition String
"bigint" Type
termT Type
bigintT (TTerm (Term -> Maybe Int) -> TElement (Term -> Maybe Int))
-> TTerm (Term -> Maybe Int) -> TElement (Term -> Maybe Int)
forall a b. (a -> b) -> a -> b
$
  TTerm (Term -> Maybe Literal)
-> TTerm (Literal -> Maybe IntegerValue)
-> TTerm (IntegerValue -> Maybe Int)
-> TTerm (Term -> Maybe Int)
forall a b c d.
TTerm (a -> Maybe b)
-> TTerm (b -> Maybe c)
-> TTerm (c -> Maybe d)
-> TTerm (a -> Maybe d)
compose3 (TElement (Term -> Maybe Literal) -> TTerm (Term -> Maybe Literal)
forall a. TElement a -> TTerm a
ref TElement (Term -> Maybe Literal)
literalDef) (TElement (Literal -> Maybe IntegerValue)
-> TTerm (Literal -> Maybe IntegerValue)
forall a. TElement a -> TTerm a
ref TElement (Literal -> Maybe IntegerValue)
integerLiteralDef) (TElement (IntegerValue -> Maybe Int)
-> TTerm (IntegerValue -> Maybe Int)
forall a. TElement a -> TTerm a
ref TElement (IntegerValue -> Maybe Int)
bigintValueDef)

bigintValueDef :: TElement (IntegerValue -> Maybe Int)
bigintValueDef :: TElement (IntegerValue -> Maybe Int)
bigintValueDef = String
-> Type
-> Type
-> TTerm (IntegerValue -> Maybe Int)
-> TElement (IntegerValue -> Maybe Int)
forall a. String -> Type -> Type -> TTerm a -> TElement a
decodeFunctionDefinition String
"bigintValue" Type
integerValueT Type
bigintT (TTerm (IntegerValue -> Maybe Int)
 -> TElement (IntegerValue -> Maybe Int))
-> TTerm (IntegerValue -> Maybe Int)
-> TElement (IntegerValue -> Maybe Int)
forall a b. (a -> b) -> a -> b
$
  Name -> Name -> TTerm (IntegerValue -> Maybe Int)
forall a b. Name -> Name -> TTerm (a -> Maybe b)
matchVariant Name
_IntegerValue Name
_IntegerValue_bigint

binaryDef :: TElement (Term -> Maybe String)
binaryDef :: TElement (Term -> Maybe String)
binaryDef = String
-> Type
-> Type
-> TTerm (Term -> Maybe String)
-> TElement (Term -> Maybe String)
forall a. String -> Type -> Type -> TTerm a -> TElement a
decodeFunctionDefinition String
"binary" Type
termT Type
binaryT (TTerm (Term -> Maybe String) -> TElement (Term -> Maybe String))
-> TTerm (Term -> Maybe String) -> TElement (Term -> Maybe String)
forall a b. (a -> b) -> a -> b
$
  TTerm (Term -> Maybe Literal)
-> TTerm (Literal -> Maybe String) -> TTerm (Term -> Maybe String)
forall a b c.
TTerm (a -> Maybe b)
-> TTerm (b -> Maybe c) -> TTerm (a -> Maybe c)
compose2 (TElement (Term -> Maybe Literal) -> TTerm (Term -> Maybe Literal)
forall a. TElement a -> TTerm a
ref TElement (Term -> Maybe Literal)
literalDef) (TElement (Literal -> Maybe String)
-> TTerm (Literal -> Maybe String)
forall a. TElement a -> TTerm a
ref TElement (Literal -> Maybe String)
binaryLiteralDef)

binaryLiteralDef :: TElement (Literal -> Maybe String)
binaryLiteralDef :: TElement (Literal -> Maybe String)
binaryLiteralDef = String
-> Type
-> Type
-> TTerm (Literal -> Maybe String)
-> TElement (Literal -> Maybe String)
forall a. String -> Type -> Type -> TTerm a -> TElement a
decodeFunctionDefinition String
"binaryLiteral" Type
literalT Type
binaryT (TTerm (Literal -> Maybe String)
 -> TElement (Literal -> Maybe String))
-> TTerm (Literal -> Maybe String)
-> TElement (Literal -> Maybe String)
forall a b. (a -> b) -> a -> b
$
  Name -> Name -> TTerm (Literal -> Maybe String)
forall a b. Name -> Name -> TTerm (a -> Maybe b)
matchVariant Name
_Literal Name
_Literal_binary

booleanDef :: TElement (Term -> Maybe Bool)
booleanDef :: TElement (Term -> Maybe Bool)
booleanDef = String
-> Type
-> Type
-> TTerm (Term -> Maybe Bool)
-> TElement (Term -> Maybe Bool)
forall a. String -> Type -> Type -> TTerm a -> TElement a
decodeFunctionDefinition String
"boolean" Type
termT Type
booleanT (TTerm (Term -> Maybe Bool) -> TElement (Term -> Maybe Bool))
-> TTerm (Term -> Maybe Bool) -> TElement (Term -> Maybe Bool)
forall a b. (a -> b) -> a -> b
$
  TTerm (Term -> Maybe Literal)
-> TTerm (Literal -> Maybe Bool) -> TTerm (Term -> Maybe Bool)
forall a b c.
TTerm (a -> Maybe b)
-> TTerm (b -> Maybe c) -> TTerm (a -> Maybe c)
compose2 (TElement (Term -> Maybe Literal) -> TTerm (Term -> Maybe Literal)
forall a. TElement a -> TTerm a
ref TElement (Term -> Maybe Literal)
literalDef) (TElement (Literal -> Maybe Bool) -> TTerm (Literal -> Maybe Bool)
forall a. TElement a -> TTerm a
ref TElement (Literal -> Maybe Bool)
booleanLiteralDef)

booleanLiteralDef :: TElement (Literal -> Maybe Bool)
booleanLiteralDef :: TElement (Literal -> Maybe Bool)
booleanLiteralDef = String
-> Type
-> Type
-> TTerm (Literal -> Maybe Bool)
-> TElement (Literal -> Maybe Bool)
forall a. String -> Type -> Type -> TTerm a -> TElement a
decodeFunctionDefinition String
"booleanLiteral" Type
literalT Type
booleanT (TTerm (Literal -> Maybe Bool) -> TElement (Literal -> Maybe Bool))
-> TTerm (Literal -> Maybe Bool)
-> TElement (Literal -> Maybe Bool)
forall a b. (a -> b) -> a -> b
$
  Name -> Name -> TTerm (Literal -> Maybe Bool)
forall a b. Name -> Name -> TTerm (a -> Maybe b)
matchVariant Name
_Literal Name
_Literal_boolean

casesDef :: TElement (Name -> Term -> Maybe [Field])
casesDef :: TElement (Name -> Term -> Maybe [Field])
casesDef = String
-> Type
-> TTerm (Name -> Term -> Maybe [Field])
-> TElement (Name -> Term -> Maybe [Field])
forall a. String -> Type -> TTerm a -> TElement a
decodeNominalFunctionDefinition String
"cases" (Type -> Type
listT Type
fieldT) (TTerm (Name -> Term -> Maybe [Field])
 -> TElement (Name -> Term -> Maybe [Field]))
-> TTerm (Name -> Term -> Maybe [Field])
-> TElement (Name -> Term -> Maybe [Field])
forall a b. (a -> b) -> a -> b
$
  TElement
  ((CaseStatement -> Name)
   -> (CaseStatement -> [Field])
   -> (Term -> Maybe CaseStatement)
   -> Name
   -> Term
   -> Maybe [Field])
-> TTerm
     ((CaseStatement -> Name)
      -> (CaseStatement -> [Field])
      -> (Term -> Maybe CaseStatement)
      -> Name
      -> Term
      -> Maybe [Field])
forall a. TElement a -> TTerm a
ref TElement
  ((CaseStatement -> Name)
   -> (CaseStatement -> [Field])
   -> (Term -> Maybe CaseStatement)
   -> Name
   -> Term
   -> Maybe [Field])
forall a b c.
TElement
  ((a -> Name) -> (a -> b) -> (c -> Maybe a) -> Name -> c -> Maybe b)
nominalDef
    TTerm
  ((CaseStatement -> Name)
   -> (CaseStatement -> [Field])
   -> (Term -> Maybe CaseStatement)
   -> Name
   -> Term
   -> Maybe [Field])
-> TTerm (CaseStatement -> Name)
-> TTerm
     ((CaseStatement -> [Field])
      -> (Term -> Maybe CaseStatement) -> Name -> Term -> Maybe [Field])
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ TTerm (CaseStatement -> Name)
Core.caseStatementTypeName
    TTerm
  ((CaseStatement -> [Field])
   -> (Term -> Maybe CaseStatement) -> Name -> Term -> Maybe [Field])
-> TTerm (CaseStatement -> [Field])
-> TTerm
     ((Term -> Maybe CaseStatement) -> Name -> Term -> Maybe [Field])
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ TTerm (CaseStatement -> [Field])
Core.caseStatementCases
    TTerm
  ((Term -> Maybe CaseStatement) -> Name -> Term -> Maybe [Field])
-> TTerm (Term -> Maybe CaseStatement)
-> TTerm (Name -> Term -> Maybe [Field])
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ TTerm (Term -> Maybe Any)
-> TTerm (Any -> Maybe Any)
-> TTerm (Any -> Maybe CaseStatement)
-> TTerm (Term -> Maybe CaseStatement)
forall a b c d.
TTerm (a -> Maybe b)
-> TTerm (b -> Maybe c)
-> TTerm (c -> Maybe d)
-> TTerm (a -> Maybe d)
compose3
      (Name -> TTerm (Term -> Maybe Any)
forall a. Name -> TTerm (Term -> Maybe a)
matchTermVariant Name
_Term_function)
      (Name -> Name -> TTerm (Any -> Maybe Any)
forall a b. Name -> Name -> TTerm (a -> Maybe b)
matchVariant Name
_Function Name
_Function_elimination)
      (Name -> Name -> TTerm (Any -> Maybe CaseStatement)
forall a b. Name -> Name -> TTerm (a -> Maybe b)
matchVariant Name
_Elimination Name
_Elimination_union)

casesCaseDef :: TElement (Name -> Name -> Term -> Y.Maybe Term)
casesCaseDef :: TElement (Name -> Name -> Term -> Maybe Term)
casesCaseDef = String
-> TTerm (Name -> Name -> Term -> Maybe Term)
-> TElement (Name -> Name -> Term -> Maybe Term)
forall a. String -> TTerm a -> TElement a
decodeDefinition String
"casesCase" (TTerm (Name -> Name -> Term -> Maybe Term)
 -> TElement (Name -> Name -> Term -> Maybe Term))
-> TTerm (Name -> Name -> Term -> Maybe Term)
-> TElement (Name -> Name -> Term -> Maybe Term)
forall a b. (a -> b) -> a -> b
$
 [Type]
-> TTerm (Name -> Name -> Term -> Maybe Term)
-> TTerm (Name -> Name -> Term -> Maybe Term)
forall a. [Type] -> TTerm a -> TTerm a
functionN [Type
nameT, Type
nameT, Type
termT, Type -> Type
optionalT Type
termT] (TTerm (Name -> Name -> Term -> Maybe Term)
 -> TTerm (Name -> Name -> Term -> Maybe Term))
-> TTerm (Name -> Name -> Term -> Maybe Term)
-> TTerm (Name -> Name -> Term -> Maybe Term)
forall a b. (a -> b) -> a -> b
$
 String
-> TTerm (Any -> Any) -> TTerm (Name -> Name -> Term -> Maybe Term)
forall x a b. String -> TTerm x -> TTerm (a -> b)
lambda String
"tname" (TTerm (Any -> Any) -> TTerm (Name -> Name -> Term -> Maybe Term))
-> TTerm (Any -> Any) -> TTerm (Name -> Name -> Term -> Maybe Term)
forall a b. (a -> b) -> a -> b
$ String -> TTerm (Term -> Maybe Term) -> TTerm (Any -> Any)
forall x a b. String -> TTerm x -> TTerm (a -> b)
lambda String
"fname" (TTerm (Term -> Maybe Term) -> TTerm (Any -> Any))
-> TTerm (Term -> Maybe Term) -> TTerm (Any -> Any)
forall a b. (a -> b) -> a -> b
$
   TTerm (Term -> Maybe [Field])
-> TTerm ([Field] -> Maybe Term) -> TTerm (Term -> Maybe Term)
forall a b c.
TTerm (a -> Maybe b)
-> TTerm (b -> Maybe c) -> TTerm (a -> Maybe c)
compose2
     (TElement (Name -> Term -> Maybe [Field])
-> TTerm (Name -> Term -> Maybe [Field])
forall a. TElement a -> TTerm a
ref TElement (Name -> Term -> Maybe [Field])
casesDef TTerm (Name -> Term -> Maybe [Field])
-> TTerm Name -> TTerm (Term -> Maybe [Field])
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ String -> TTerm Name
forall a. String -> TTerm a
var String
"tname" )
     (TElement (Name -> [Field] -> Maybe Term)
-> TTerm (Name -> [Field] -> Maybe Term)
forall a. TElement a -> TTerm a
ref TElement (Name -> [Field] -> Maybe Term)
fieldDef TTerm (Name -> [Field] -> Maybe Term)
-> TTerm Name -> TTerm ([Field] -> Maybe Term)
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ String -> TTerm Name
forall a. String -> TTerm a
var String
"fname")

fieldDef :: TElement (Name -> [Field] -> Maybe Term)
fieldDef :: TElement (Name -> [Field] -> Maybe Term)
fieldDef = String
-> TTerm (Name -> [Field] -> Maybe Term)
-> TElement (Name -> [Field] -> Maybe Term)
forall a. String -> TTerm a -> TElement a
decodeDefinition String
"field" (TTerm (Name -> [Field] -> Maybe Term)
 -> TElement (Name -> [Field] -> Maybe Term))
-> TTerm (Name -> [Field] -> Maybe Term)
-> TElement (Name -> [Field] -> Maybe Term)
forall a b. (a -> b) -> a -> b
$
  [Type]
-> TTerm (Name -> [Field] -> Maybe Term)
-> TTerm (Name -> [Field] -> Maybe Term)
forall a. [Type] -> TTerm a -> TTerm a
functionN [Type
nameT, Type -> Type
listT Type
fieldT, Type -> Type
optionalT Type
termT] (TTerm (Name -> [Field] -> Maybe Term)
 -> TTerm (Name -> [Field] -> Maybe Term))
-> TTerm (Name -> [Field] -> Maybe Term)
-> TTerm (Name -> [Field] -> Maybe Term)
forall a b. (a -> b) -> a -> b
$
  String
-> TTerm (Any -> Any) -> TTerm (Name -> [Field] -> Maybe Term)
forall x a b. String -> TTerm x -> TTerm (a -> b)
lambda String
"fname" (TTerm (Any -> Any) -> TTerm (Name -> [Field] -> Maybe Term))
-> TTerm (Any -> Any) -> TTerm (Name -> [Field] -> Maybe Term)
forall a b. (a -> b) -> a -> b
$ String -> TTerm (Maybe Term) -> TTerm (Any -> Any)
forall x a b. String -> TTerm x -> TTerm (a -> b)
lambda String
"fields" ((TTerm (Maybe Term -> Maybe Term -> Bool -> Maybe Term)
forall a. TTerm (a -> a -> Bool -> a)
Logic.ifElse
        TTerm (Maybe Term -> Maybe Term -> Bool -> Maybe Term)
-> TTerm (Maybe Term) -> TTerm (Maybe Term -> Bool -> Maybe Term)
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ TTerm Term -> TTerm (Maybe Term)
forall x. TTerm x -> TTerm (Maybe x)
just (TTerm (Field -> Term)
Core.fieldTerm TTerm (Field -> Term) -> TTerm Field -> TTerm Term
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (TTerm ([Field] -> Field)
forall a. TTerm ([a] -> a)
Lists.head TTerm ([Field] -> Field) -> TTerm [Field] -> TTerm Field
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ String -> TTerm [Field]
forall a. String -> TTerm a
var String
"matches"))
        TTerm (Maybe Term -> Bool -> Maybe Term)
-> TTerm (Maybe Term) -> TTerm (Bool -> Maybe Term)
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ TTerm (Maybe Term)
forall a. TTerm a
nothing
        TTerm (Bool -> Maybe Term) -> TTerm Bool -> TTerm (Maybe Term)
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (TTerm (Int -> Int -> Bool)
forall a. TTerm (a -> a -> Bool)
Equality.equal TTerm (Int -> Int -> Bool) -> TTerm Int -> TTerm (Int -> Bool)
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ Int -> TTerm Int
int32 Int
1 TTerm (Int -> Bool) -> TTerm Int -> TTerm Bool
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (TTerm ([Any] -> Int)
forall a. TTerm ([a] -> Int)
Lists.length TTerm ([Any] -> Int) -> TTerm [Any] -> TTerm Int
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ String -> TTerm [Any]
forall a. String -> TTerm a
var String
"matches"))
    ) TTerm (Maybe Term) -> [Field] -> TTerm (Maybe Term)
forall a. TTerm a -> [Field] -> TTerm a
`with` [
      String
"matches"String -> TTerm [Any] -> Field
forall a. String -> TTerm a -> Field
>: TTerm ((Any -> Bool) -> [Any] -> [Any])
forall a. TTerm ((a -> Bool) -> [a] -> [a])
Lists.filter TTerm ((Any -> Bool) -> [Any] -> [Any])
-> TTerm (Any -> Bool) -> TTerm ([Any] -> [Any])
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (String -> TTerm Bool -> TTerm (Any -> Bool)
forall x a b. String -> TTerm x -> TTerm (a -> b)
lambda String
"f" (TTerm Bool -> TTerm (Any -> Bool))
-> TTerm Bool -> TTerm (Any -> Bool)
forall a b. (a -> b) -> a -> b
$ TTerm (Name -> Name -> Bool)
forall a. TTerm (a -> a -> Bool)
Equality.equal TTerm (Name -> Name -> Bool) -> TTerm Name -> TTerm (Name -> Bool)
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (TTerm (Field -> Name)
Core.fieldName TTerm (Field -> Name) -> TTerm Field -> TTerm Name
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ String -> TTerm Field
forall a. String -> TTerm a
var String
"f") TTerm (Name -> Bool) -> TTerm Name -> TTerm Bool
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ String -> TTerm Name
forall a. String -> TTerm a
var String
"fname") TTerm ([Any] -> [Any]) -> TTerm [Any] -> TTerm [Any]
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ String -> TTerm [Any]
forall a. String -> TTerm a
var String
"fields"])

float32Def :: TElement (Term -> Maybe Float)
float32Def :: TElement (Term -> Maybe Float)
float32Def = String
-> Type
-> Type
-> TTerm (Term -> Maybe Float)
-> TElement (Term -> Maybe Float)
forall a. String -> Type -> Type -> TTerm a -> TElement a
decodeFunctionDefinition String
"float32" Type
termT Type
float32T (TTerm (Term -> Maybe Float) -> TElement (Term -> Maybe Float))
-> TTerm (Term -> Maybe Float) -> TElement (Term -> Maybe Float)
forall a b. (a -> b) -> a -> b
$
  TTerm (Term -> Maybe Literal)
-> TTerm (Literal -> Maybe FloatValue)
-> TTerm (FloatValue -> Maybe Float)
-> TTerm (Term -> Maybe Float)
forall a b c d.
TTerm (a -> Maybe b)
-> TTerm (b -> Maybe c)
-> TTerm (c -> Maybe d)
-> TTerm (a -> Maybe d)
compose3
    (TElement (Term -> Maybe Literal) -> TTerm (Term -> Maybe Literal)
forall a. TElement a -> TTerm a
ref TElement (Term -> Maybe Literal)
literalDef)
    (TElement (Literal -> Maybe FloatValue)
-> TTerm (Literal -> Maybe FloatValue)
forall a. TElement a -> TTerm a
ref TElement (Literal -> Maybe FloatValue)
forall {a} {b}. TElement (a -> Maybe b)
floatLiteralDef)
    (TElement (FloatValue -> Maybe Float)
-> TTerm (FloatValue -> Maybe Float)
forall a. TElement a -> TTerm a
ref TElement (FloatValue -> Maybe Float)
float32ValueDef)

float32ValueDef :: TElement (FloatValue -> Maybe Float)
float32ValueDef :: TElement (FloatValue -> Maybe Float)
float32ValueDef = String
-> Type
-> Type
-> TTerm (FloatValue -> Maybe Float)
-> TElement (FloatValue -> Maybe Float)
forall a. String -> Type -> Type -> TTerm a -> TElement a
decodeFunctionDefinition String
"float32Value" Type
floatValueT Type
float32T (TTerm (FloatValue -> Maybe Float)
 -> TElement (FloatValue -> Maybe Float))
-> TTerm (FloatValue -> Maybe Float)
-> TElement (FloatValue -> Maybe Float)
forall a b. (a -> b) -> a -> b
$
  Name -> Name -> TTerm (FloatValue -> Maybe Float)
forall a b. Name -> Name -> TTerm (a -> Maybe b)
matchVariant Name
_FloatValue Name
_FloatValue_float32

float64Def :: TElement (Term -> Maybe Float)
float64Def :: TElement (Term -> Maybe Float)
float64Def = String
-> Type
-> Type
-> TTerm (Term -> Maybe Float)
-> TElement (Term -> Maybe Float)
forall a. String -> Type -> Type -> TTerm a -> TElement a
decodeFunctionDefinition String
"float64" Type
termT Type
float64T (TTerm (Term -> Maybe Float) -> TElement (Term -> Maybe Float))
-> TTerm (Term -> Maybe Float) -> TElement (Term -> Maybe Float)
forall a b. (a -> b) -> a -> b
$
  TTerm (Term -> Maybe Literal)
-> TTerm (Literal -> Maybe FloatValue)
-> TTerm (FloatValue -> Maybe Float)
-> TTerm (Term -> Maybe Float)
forall a b c d.
TTerm (a -> Maybe b)
-> TTerm (b -> Maybe c)
-> TTerm (c -> Maybe d)
-> TTerm (a -> Maybe d)
compose3
    (TElement (Term -> Maybe Literal) -> TTerm (Term -> Maybe Literal)
forall a. TElement a -> TTerm a
ref TElement (Term -> Maybe Literal)
literalDef)
    (TElement (Literal -> Maybe FloatValue)
-> TTerm (Literal -> Maybe FloatValue)
forall a. TElement a -> TTerm a
ref TElement (Literal -> Maybe FloatValue)
forall {a} {b}. TElement (a -> Maybe b)
floatLiteralDef)
    (TElement (FloatValue -> Maybe Float)
-> TTerm (FloatValue -> Maybe Float)
forall a. TElement a -> TTerm a
ref TElement (FloatValue -> Maybe Float)
float64ValueDef)

float64ValueDef :: TElement (FloatValue -> Maybe Float)
float64ValueDef :: TElement (FloatValue -> Maybe Float)
float64ValueDef = String
-> Type
-> Type
-> TTerm (FloatValue -> Maybe Float)
-> TElement (FloatValue -> Maybe Float)
forall a. String -> Type -> Type -> TTerm a -> TElement a
decodeFunctionDefinition String
"float64Value" Type
floatValueT Type
float64T (TTerm (FloatValue -> Maybe Float)
 -> TElement (FloatValue -> Maybe Float))
-> TTerm (FloatValue -> Maybe Float)
-> TElement (FloatValue -> Maybe Float)
forall a b. (a -> b) -> a -> b
$
  Name -> Name -> TTerm (FloatValue -> Maybe Float)
forall a b. Name -> Name -> TTerm (a -> Maybe b)
matchVariant Name
_FloatValue Name
_FloatValue_float64

floatLiteralDef :: TElement (a -> Maybe b)
floatLiteralDef = String
-> Type -> Type -> TTerm (a -> Maybe b) -> TElement (a -> Maybe b)
forall a. String -> Type -> Type -> TTerm a -> TElement a
decodeFunctionDefinition String
"floatLiteral" Type
literalT Type
floatValueT (TTerm (a -> Maybe b) -> TElement (a -> Maybe b))
-> TTerm (a -> Maybe b) -> TElement (a -> Maybe b)
forall a b. (a -> b) -> a -> b
$
  Name -> Name -> TTerm (a -> Maybe b)
forall a b. Name -> Name -> TTerm (a -> Maybe b)
matchVariant Name
_Literal Name
_Literal_float

int8Def :: TElement (Term -> Maybe Int)
int8Def :: TElement (Term -> Maybe Int)
int8Def = String
-> Type
-> Type
-> TTerm (Term -> Maybe Int)
-> TElement (Term -> Maybe Int)
forall a. String -> Type -> Type -> TTerm a -> TElement a
decodeFunctionDefinition String
"int8" Type
termT Type
int8T (TTerm (Term -> Maybe Int) -> TElement (Term -> Maybe Int))
-> TTerm (Term -> Maybe Int) -> TElement (Term -> Maybe Int)
forall a b. (a -> b) -> a -> b
$
  TTerm (Term -> Maybe Literal)
-> TTerm (Literal -> Maybe IntegerValue)
-> TTerm (IntegerValue -> Maybe Int)
-> TTerm (Term -> Maybe Int)
forall a b c d.
TTerm (a -> Maybe b)
-> TTerm (b -> Maybe c)
-> TTerm (c -> Maybe d)
-> TTerm (a -> Maybe d)
compose3
    (TElement (Term -> Maybe Literal) -> TTerm (Term -> Maybe Literal)
forall a. TElement a -> TTerm a
ref TElement (Term -> Maybe Literal)
literalDef)
    (TElement (Literal -> Maybe IntegerValue)
-> TTerm (Literal -> Maybe IntegerValue)
forall a. TElement a -> TTerm a
ref TElement (Literal -> Maybe IntegerValue)
integerLiteralDef)
    (TElement (IntegerValue -> Maybe Int)
-> TTerm (IntegerValue -> Maybe Int)
forall a. TElement a -> TTerm a
ref TElement (IntegerValue -> Maybe Int)
int8ValueDef)

int8ValueDef :: TElement (IntegerValue -> Maybe Int)
int8ValueDef :: TElement (IntegerValue -> Maybe Int)
int8ValueDef = String
-> Type
-> Type
-> TTerm (IntegerValue -> Maybe Int)
-> TElement (IntegerValue -> Maybe Int)
forall a. String -> Type -> Type -> TTerm a -> TElement a
decodeFunctionDefinition String
"int8Value" Type
integerValueT Type
int8T (TTerm (IntegerValue -> Maybe Int)
 -> TElement (IntegerValue -> Maybe Int))
-> TTerm (IntegerValue -> Maybe Int)
-> TElement (IntegerValue -> Maybe Int)
forall a b. (a -> b) -> a -> b
$
  Name -> Name -> TTerm (IntegerValue -> Maybe Int)
forall a b. Name -> Name -> TTerm (a -> Maybe b)
matchVariant Name
_IntegerValue Name
_IntegerValue_int8

int16Def :: TElement (Term -> Maybe Int)
int16Def :: TElement (Term -> Maybe Int)
int16Def = String
-> Type
-> Type
-> TTerm (Term -> Maybe Int)
-> TElement (Term -> Maybe Int)
forall a. String -> Type -> Type -> TTerm a -> TElement a
decodeFunctionDefinition String
"int16" Type
termT Type
int16T (TTerm (Term -> Maybe Int) -> TElement (Term -> Maybe Int))
-> TTerm (Term -> Maybe Int) -> TElement (Term -> Maybe Int)
forall a b. (a -> b) -> a -> b
$
  TTerm (Term -> Maybe Literal)
-> TTerm (Literal -> Maybe IntegerValue)
-> TTerm (IntegerValue -> Maybe Int)
-> TTerm (Term -> Maybe Int)
forall a b c d.
TTerm (a -> Maybe b)
-> TTerm (b -> Maybe c)
-> TTerm (c -> Maybe d)
-> TTerm (a -> Maybe d)
compose3
    (TElement (Term -> Maybe Literal) -> TTerm (Term -> Maybe Literal)
forall a. TElement a -> TTerm a
ref TElement (Term -> Maybe Literal)
literalDef)
    (TElement (Literal -> Maybe IntegerValue)
-> TTerm (Literal -> Maybe IntegerValue)
forall a. TElement a -> TTerm a
ref TElement (Literal -> Maybe IntegerValue)
integerLiteralDef)
    (TElement (IntegerValue -> Maybe Int)
-> TTerm (IntegerValue -> Maybe Int)
forall a. TElement a -> TTerm a
ref TElement (IntegerValue -> Maybe Int)
int16ValueDef)

int16ValueDef :: TElement (IntegerValue -> Maybe Int)
int16ValueDef :: TElement (IntegerValue -> Maybe Int)
int16ValueDef = String
-> Type
-> Type
-> TTerm (IntegerValue -> Maybe Int)
-> TElement (IntegerValue -> Maybe Int)
forall a. String -> Type -> Type -> TTerm a -> TElement a
decodeFunctionDefinition String
"int16Value" Type
integerValueT Type
int16T (TTerm (IntegerValue -> Maybe Int)
 -> TElement (IntegerValue -> Maybe Int))
-> TTerm (IntegerValue -> Maybe Int)
-> TElement (IntegerValue -> Maybe Int)
forall a b. (a -> b) -> a -> b
$
  Name -> Name -> TTerm (IntegerValue -> Maybe Int)
forall a b. Name -> Name -> TTerm (a -> Maybe b)
matchVariant Name
_IntegerValue Name
_IntegerValue_int16

int32Def :: TElement (Term -> Maybe Int)
int32Def :: TElement (Term -> Maybe Int)
int32Def = String
-> Type
-> Type
-> TTerm (Term -> Maybe Int)
-> TElement (Term -> Maybe Int)
forall a. String -> Type -> Type -> TTerm a -> TElement a
decodeFunctionDefinition String
"int32" Type
termT Type
int32T (TTerm (Term -> Maybe Int) -> TElement (Term -> Maybe Int))
-> TTerm (Term -> Maybe Int) -> TElement (Term -> Maybe Int)
forall a b. (a -> b) -> a -> b
$
  TTerm (Term -> Maybe Literal)
-> TTerm (Literal -> Maybe IntegerValue)
-> TTerm (IntegerValue -> Maybe Int)
-> TTerm (Term -> Maybe Int)
forall a b c d.
TTerm (a -> Maybe b)
-> TTerm (b -> Maybe c)
-> TTerm (c -> Maybe d)
-> TTerm (a -> Maybe d)
compose3
    (TElement (Term -> Maybe Literal) -> TTerm (Term -> Maybe Literal)
forall a. TElement a -> TTerm a
ref TElement (Term -> Maybe Literal)
literalDef)
    (TElement (Literal -> Maybe IntegerValue)
-> TTerm (Literal -> Maybe IntegerValue)
forall a. TElement a -> TTerm a
ref TElement (Literal -> Maybe IntegerValue)
integerLiteralDef)
    (TElement (IntegerValue -> Maybe Int)
-> TTerm (IntegerValue -> Maybe Int)
forall a. TElement a -> TTerm a
ref TElement (IntegerValue -> Maybe Int)
int32ValueDef)

int32ValueDef :: TElement (IntegerValue -> Maybe Int)
int32ValueDef :: TElement (IntegerValue -> Maybe Int)
int32ValueDef = String
-> Type
-> Type
-> TTerm (IntegerValue -> Maybe Int)
-> TElement (IntegerValue -> Maybe Int)
forall a. String -> Type -> Type -> TTerm a -> TElement a
decodeFunctionDefinition String
"int32Value" Type
integerValueT Type
int32T (TTerm (IntegerValue -> Maybe Int)
 -> TElement (IntegerValue -> Maybe Int))
-> TTerm (IntegerValue -> Maybe Int)
-> TElement (IntegerValue -> Maybe Int)
forall a b. (a -> b) -> a -> b
$
  Name -> Name -> TTerm (IntegerValue -> Maybe Int)
forall a b. Name -> Name -> TTerm (a -> Maybe b)
matchVariant Name
_IntegerValue Name
_IntegerValue_int32

int64Def :: TElement (Term -> Maybe Int)
int64Def :: TElement (Term -> Maybe Int)
int64Def = String
-> Type
-> Type
-> TTerm (Term -> Maybe Int)
-> TElement (Term -> Maybe Int)
forall a. String -> Type -> Type -> TTerm a -> TElement a
decodeFunctionDefinition String
"int64" Type
termT Type
int64T (TTerm (Term -> Maybe Int) -> TElement (Term -> Maybe Int))
-> TTerm (Term -> Maybe Int) -> TElement (Term -> Maybe Int)
forall a b. (a -> b) -> a -> b
$
  TTerm (Term -> Maybe Literal)
-> TTerm (Literal -> Maybe IntegerValue)
-> TTerm (IntegerValue -> Maybe Int)
-> TTerm (Term -> Maybe Int)
forall a b c d.
TTerm (a -> Maybe b)
-> TTerm (b -> Maybe c)
-> TTerm (c -> Maybe d)
-> TTerm (a -> Maybe d)
compose3
    (TElement (Term -> Maybe Literal) -> TTerm (Term -> Maybe Literal)
forall a. TElement a -> TTerm a
ref TElement (Term -> Maybe Literal)
literalDef)
    (TElement (Literal -> Maybe IntegerValue)
-> TTerm (Literal -> Maybe IntegerValue)
forall a. TElement a -> TTerm a
ref TElement (Literal -> Maybe IntegerValue)
integerLiteralDef)
    (TElement (IntegerValue -> Maybe Int)
-> TTerm (IntegerValue -> Maybe Int)
forall a. TElement a -> TTerm a
ref TElement (IntegerValue -> Maybe Int)
int64ValueDef)

int64ValueDef :: TElement (IntegerValue -> Maybe Int)
int64ValueDef :: TElement (IntegerValue -> Maybe Int)
int64ValueDef = String
-> Type
-> Type
-> TTerm (IntegerValue -> Maybe Int)
-> TElement (IntegerValue -> Maybe Int)
forall a. String -> Type -> Type -> TTerm a -> TElement a
decodeFunctionDefinition String
"int64Value" Type
integerValueT Type
int64T (TTerm (IntegerValue -> Maybe Int)
 -> TElement (IntegerValue -> Maybe Int))
-> TTerm (IntegerValue -> Maybe Int)
-> TElement (IntegerValue -> Maybe Int)
forall a b. (a -> b) -> a -> b
$
  Name -> Name -> TTerm (IntegerValue -> Maybe Int)
forall a b. Name -> Name -> TTerm (a -> Maybe b)
matchVariant Name
_IntegerValue Name
_IntegerValue_int64

integerLiteralDef :: TElement (Literal -> Maybe IntegerValue)
integerLiteralDef :: TElement (Literal -> Maybe IntegerValue)
integerLiteralDef = String
-> Type
-> Type
-> TTerm (Literal -> Maybe IntegerValue)
-> TElement (Literal -> Maybe IntegerValue)
forall a. String -> Type -> Type -> TTerm a -> TElement a
decodeFunctionDefinition String
"integerLiteral" Type
literalT Type
integerValueT (TTerm (Literal -> Maybe IntegerValue)
 -> TElement (Literal -> Maybe IntegerValue))
-> TTerm (Literal -> Maybe IntegerValue)
-> TElement (Literal -> Maybe IntegerValue)
forall a b. (a -> b) -> a -> b
$
  Name -> Name -> TTerm (Literal -> Maybe IntegerValue)
forall a b. Name -> Name -> TTerm (a -> Maybe b)
matchVariant Name
_Literal Name
_Literal_integer

lambdaDef :: TElement (Term -> Maybe Lambda)
lambdaDef :: TElement (Term -> Maybe Lambda)
lambdaDef = String
-> Type
-> Type
-> TTerm (Term -> Maybe Lambda)
-> TElement (Term -> Maybe Lambda)
forall a. String -> Type -> Type -> TTerm a -> TElement a
decodeFunctionDefinition String
"lambda" Type
termT Type
lambdaT (TTerm (Term -> Maybe Lambda) -> TElement (Term -> Maybe Lambda))
-> TTerm (Term -> Maybe Lambda) -> TElement (Term -> Maybe Lambda)
forall a b. (a -> b) -> a -> b
$
  TTerm (Term -> Maybe Any)
-> TTerm (Any -> Maybe Lambda) -> TTerm (Term -> Maybe Lambda)
forall a b c.
TTerm (a -> Maybe b)
-> TTerm (b -> Maybe c) -> TTerm (a -> Maybe c)
compose2
    (Name -> TTerm (Term -> Maybe Any)
forall a. Name -> TTerm (Term -> Maybe a)
matchTermVariant Name
_Term_function)
    (Name -> Name -> TTerm (Any -> Maybe Lambda)
forall a b. Name -> Name -> TTerm (a -> Maybe b)
matchVariant Name
_Function Name
_Function_lambda)

letBindingDef :: TElement (Name -> Term -> Maybe LetBinding)
letBindingDef :: TElement (Name -> Term -> Maybe LetBinding)
letBindingDef = String
-> TTerm (Name -> Term -> Maybe LetBinding)
-> TElement (Name -> Term -> Maybe LetBinding)
forall a. String -> TTerm a -> TElement a
decodeDefinition String
"letBinding" (TTerm (Name -> Term -> Maybe LetBinding)
 -> TElement (Name -> Term -> Maybe LetBinding))
-> TTerm (Name -> Term -> Maybe LetBinding)
-> TElement (Name -> Term -> Maybe LetBinding)
forall a b. (a -> b) -> a -> b
$
  [Type]
-> TTerm (Name -> Term -> Maybe LetBinding)
-> TTerm (Name -> Term -> Maybe LetBinding)
forall a. [Type] -> TTerm a -> TTerm a
functionN [Type
nameT, Type
termT, Type -> Type
optionalT Type
letBindingT] (TTerm (Name -> Term -> Maybe LetBinding)
 -> TTerm (Name -> Term -> Maybe LetBinding))
-> TTerm (Name -> Term -> Maybe LetBinding)
-> TTerm (Name -> Term -> Maybe LetBinding)
forall a b. (a -> b) -> a -> b
$
  String
-> TTerm (Any -> Any) -> TTerm (Name -> Term -> Maybe LetBinding)
forall x a b. String -> TTerm x -> TTerm (a -> b)
lambda String
"fname" (TTerm (Any -> Any) -> TTerm (Name -> Term -> Maybe LetBinding))
-> TTerm (Any -> Any) -> TTerm (Name -> Term -> Maybe LetBinding)
forall a b. (a -> b) -> a -> b
$ String -> TTerm (Maybe LetBinding) -> TTerm (Any -> Any)
forall x a b. String -> TTerm x -> TTerm (a -> b)
lambda String
"term" (TTerm (Maybe LetBinding) -> TTerm (Any -> Any))
-> TTerm (Maybe LetBinding) -> TTerm (Any -> Any)
forall a b. (a -> b) -> a -> b
$ TTerm
  (Maybe [LetBinding]
   -> ([LetBinding] -> Maybe LetBinding) -> Maybe LetBinding)
forall a b. TTerm (Maybe a -> (a -> Maybe b) -> Maybe b)
Optionals.bind
    TTerm
  (Maybe [LetBinding]
   -> ([LetBinding] -> Maybe LetBinding) -> Maybe LetBinding)
-> TTerm (Maybe [LetBinding])
-> TTerm (([LetBinding] -> Maybe LetBinding) -> Maybe LetBinding)
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (TTerm ((Let -> [LetBinding]) -> Maybe Let -> Maybe [LetBinding])
forall a b. TTerm ((a -> b) -> Maybe a -> Maybe b)
Optionals.map
      TTerm ((Let -> [LetBinding]) -> Maybe Let -> Maybe [LetBinding])
-> TTerm (Let -> [LetBinding])
-> TTerm (Maybe Let -> Maybe [LetBinding])
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ TTerm (Let -> [LetBinding])
Core.letBindings
      TTerm (Maybe Let -> Maybe [LetBinding])
-> TTerm (Maybe Let) -> TTerm (Maybe [LetBinding])
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (TElement (Term -> Maybe Let) -> TTerm (Term -> Maybe Let)
forall a. TElement a -> TTerm a
ref TElement (Term -> Maybe Let)
letTermDef TTerm (Term -> Maybe Let) -> TTerm Term -> TTerm (Maybe Let)
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ String -> TTerm Term
forall a. String -> TTerm a
var String
"term"))
    TTerm (([LetBinding] -> Maybe LetBinding) -> Maybe LetBinding)
-> TTerm ([LetBinding] -> Maybe LetBinding)
-> TTerm (Maybe LetBinding)
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (TElement (Name -> [LetBinding] -> Maybe LetBinding)
-> TTerm (Name -> [LetBinding] -> Maybe LetBinding)
forall a. TElement a -> TTerm a
ref TElement (Name -> [LetBinding] -> Maybe LetBinding)
letBindingWithKeyDef TTerm (Name -> [LetBinding] -> Maybe LetBinding)
-> TTerm Name -> TTerm ([LetBinding] -> Maybe LetBinding)
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ String -> TTerm Name
forall a. String -> TTerm a
var String
"fname")

letBindingWithKeyDef :: TElement (Name -> [LetBinding] -> Maybe LetBinding)
letBindingWithKeyDef :: TElement (Name -> [LetBinding] -> Maybe LetBinding)
letBindingWithKeyDef = String
-> TTerm (Name -> [LetBinding] -> Maybe LetBinding)
-> TElement (Name -> [LetBinding] -> Maybe LetBinding)
forall a. String -> TTerm a -> TElement a
decodeDefinition String
"letBindingWithKey" (TTerm (Name -> [LetBinding] -> Maybe LetBinding)
 -> TElement (Name -> [LetBinding] -> Maybe LetBinding))
-> TTerm (Name -> [LetBinding] -> Maybe LetBinding)
-> TElement (Name -> [LetBinding] -> Maybe LetBinding)
forall a b. (a -> b) -> a -> b
$
  [Type]
-> TTerm (Name -> [LetBinding] -> Maybe LetBinding)
-> TTerm (Name -> [LetBinding] -> Maybe LetBinding)
forall a. [Type] -> TTerm a -> TTerm a
functionN [Type
nameT, Type -> Type
listT Type
letBindingT, Type -> Type
optionalT Type
letBindingT] (TTerm (Name -> [LetBinding] -> Maybe LetBinding)
 -> TTerm (Name -> [LetBinding] -> Maybe LetBinding))
-> TTerm (Name -> [LetBinding] -> Maybe LetBinding)
-> TTerm (Name -> [LetBinding] -> Maybe LetBinding)
forall a b. (a -> b) -> a -> b
$
  String
-> TTerm (Any -> Any)
-> TTerm (Name -> [LetBinding] -> Maybe LetBinding)
forall x a b. String -> TTerm x -> TTerm (a -> b)
lambda String
"fname" (TTerm (Any -> Any)
 -> TTerm (Name -> [LetBinding] -> Maybe LetBinding))
-> TTerm (Any -> Any)
-> TTerm (Name -> [LetBinding] -> Maybe LetBinding)
forall a b. (a -> b) -> a -> b
$ String -> TTerm (Maybe Any) -> TTerm (Any -> Any)
forall x a b. String -> TTerm x -> TTerm (a -> b)
lambda String
"bindings" ((TTerm (Maybe Any -> Maybe Any -> Bool -> Maybe Any)
forall a. TTerm (a -> a -> Bool -> a)
Logic.ifElse
        TTerm (Maybe Any -> Maybe Any -> Bool -> Maybe Any)
-> TTerm (Maybe Any) -> TTerm (Maybe Any -> Bool -> Maybe Any)
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ TTerm Any -> TTerm (Maybe Any)
forall x. TTerm x -> TTerm (Maybe x)
just (TTerm ([Any] -> Any)
forall a. TTerm ([a] -> a)
Lists.head TTerm ([Any] -> Any) -> TTerm [Any] -> TTerm Any
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ String -> TTerm [Any]
forall a. String -> TTerm a
var String
"matches")
        TTerm (Maybe Any -> Bool -> Maybe Any)
-> TTerm (Maybe Any) -> TTerm (Bool -> Maybe Any)
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ TTerm (Maybe Any)
forall a. TTerm a
nothing
        TTerm (Bool -> Maybe Any) -> TTerm Bool -> TTerm (Maybe Any)
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (TTerm (Int -> Int -> Bool)
forall a. TTerm (a -> a -> Bool)
Equality.equal TTerm (Int -> Int -> Bool) -> TTerm Int -> TTerm (Int -> Bool)
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ Int -> TTerm Int
int32 Int
1 TTerm (Int -> Bool) -> TTerm Int -> TTerm Bool
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (TTerm ([Any] -> Int)
forall a. TTerm ([a] -> Int)
Lists.length TTerm ([Any] -> Int) -> TTerm [Any] -> TTerm Int
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ String -> TTerm [Any]
forall a. String -> TTerm a
var String
"matches"))
    ) TTerm (Maybe Any) -> [Field] -> TTerm (Maybe Any)
forall a. TTerm a -> [Field] -> TTerm a
`with` [
      String
"matches"String -> TTerm [Any] -> Field
forall a. String -> TTerm a -> Field
>: TTerm ((Any -> Bool) -> [Any] -> [Any])
forall a. TTerm ((a -> Bool) -> [a] -> [a])
Lists.filter TTerm ((Any -> Bool) -> [Any] -> [Any])
-> TTerm (Any -> Bool) -> TTerm ([Any] -> [Any])
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (String -> TTerm Bool -> TTerm (Any -> Bool)
forall x a b. String -> TTerm x -> TTerm (a -> b)
lambda String
"b" (TTerm Bool -> TTerm (Any -> Bool))
-> TTerm Bool -> TTerm (Any -> Bool)
forall a b. (a -> b) -> a -> b
$ TTerm (Name -> Name -> Bool)
forall a. TTerm (a -> a -> Bool)
Equality.equal TTerm (Name -> Name -> Bool) -> TTerm Name -> TTerm (Name -> Bool)
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (TTerm (LetBinding -> Name)
Core.letBindingName TTerm (LetBinding -> Name) -> TTerm LetBinding -> TTerm Name
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ String -> TTerm LetBinding
forall a. String -> TTerm a
var String
"b") TTerm (Name -> Bool) -> TTerm Name -> TTerm Bool
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ String -> TTerm Name
forall a. String -> TTerm a
var String
"fname") TTerm ([Any] -> [Any]) -> TTerm [Any] -> TTerm [Any]
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ String -> TTerm [Any]
forall a. String -> TTerm a
var String
"bindings"])

letTermDef :: TElement (Term -> Maybe Let)
letTermDef :: TElement (Term -> Maybe Let)
letTermDef = String
-> Type
-> Type
-> TTerm (Term -> Maybe Let)
-> TElement (Term -> Maybe Let)
forall a. String -> Type -> Type -> TTerm a -> TElement a
decodeFunctionDefinition String
"letTerm" Type
termT Type
letT (TTerm (Term -> Maybe Let) -> TElement (Term -> Maybe Let))
-> TTerm (Term -> Maybe Let) -> TElement (Term -> Maybe Let)
forall a b. (a -> b) -> a -> b
$
  Name -> TTerm (Term -> Maybe Let)
forall a. Name -> TTerm (Term -> Maybe a)
matchTermVariant Name
_Term_let

listDef :: TElement (Term -> Maybe [Term])
listDef :: TElement (Term -> Maybe [Term])
listDef = String
-> Type
-> Type
-> TTerm (Term -> Maybe [Term])
-> TElement (Term -> Maybe [Term])
forall a. String -> Type -> Type -> TTerm a -> TElement a
decodeFunctionDefinition String
"list" Type
termT (Type -> Type
listT Type
termT) (TTerm (Term -> Maybe [Term]) -> TElement (Term -> Maybe [Term]))
-> TTerm (Term -> Maybe [Term]) -> TElement (Term -> Maybe [Term])
forall a b. (a -> b) -> a -> b
$
  Name -> TTerm (Term -> Maybe [Term])
forall a. Name -> TTerm (Term -> Maybe a)
matchTermVariant Name
_Term_list

literalDef :: TElement (Term -> Maybe Literal)
literalDef :: TElement (Term -> Maybe Literal)
literalDef = String
-> Type
-> Type
-> TTerm (Term -> Maybe Literal)
-> TElement (Term -> Maybe Literal)
forall a. String -> Type -> Type -> TTerm a -> TElement a
decodeFunctionDefinition String
"literal" Type
termT Type
literalT (TTerm (Term -> Maybe Literal) -> TElement (Term -> Maybe Literal))
-> TTerm (Term -> Maybe Literal)
-> TElement (Term -> Maybe Literal)
forall a b. (a -> b) -> a -> b
$
  Name -> TTerm (Term -> Maybe Literal)
forall a. Name -> TTerm (Term -> Maybe a)
matchTermVariant Name
_Term_literal

mapDef :: TElement (Term -> Maybe (M.Map Term Term))
mapDef :: TElement (Term -> Maybe (Map Term Term))
mapDef = String
-> Type
-> Type
-> TTerm (Term -> Maybe (Map Term Term))
-> TElement (Term -> Maybe (Map Term Term))
forall a. String -> Type -> Type -> TTerm a -> TElement a
decodeFunctionDefinition String
"map" Type
termT (Type -> Type -> Type
mapT Type
termT Type
termT) (TTerm (Term -> Maybe (Map Term Term))
 -> TElement (Term -> Maybe (Map Term Term)))
-> TTerm (Term -> Maybe (Map Term Term))
-> TElement (Term -> Maybe (Map Term Term))
forall a b. (a -> b) -> a -> b
$
  Name -> TTerm (Term -> Maybe (Map Term Term))
forall a. Name -> TTerm (Term -> Maybe a)
matchTermVariant Name
_Term_map

nameDef :: TElement (Term -> Name)
nameDef :: TElement (Term -> Name)
nameDef = String
-> Type -> Type -> TTerm (Term -> Name) -> TElement (Term -> Name)
forall a. String -> Type -> Type -> TTerm a -> TElement a
decodeFunctionDefinition String
"name" Type
termT Type
nameT (TTerm (Term -> Name) -> TElement (Term -> Name))
-> TTerm (Term -> Name) -> TElement (Term -> Name)
forall a b. (a -> b) -> a -> b
$
  String -> TTerm (Maybe Name) -> TTerm (Term -> Name)
forall x a b. String -> TTerm x -> TTerm (a -> b)
lambda String
"term" (TTerm (Maybe Name) -> TTerm (Term -> Name))
-> TTerm (Maybe Name) -> TTerm (Term -> Name)
forall a b. (a -> b) -> a -> b
$ TTerm ((String -> Name) -> Maybe String -> Maybe Name)
forall a b. TTerm ((a -> b) -> Maybe a -> Maybe b)
Optionals.map
    TTerm ((String -> Name) -> Maybe String -> Maybe Name)
-> TTerm (String -> Name) -> TTerm (Maybe String -> Maybe Name)
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ TTerm (String -> Name)
nm
    TTerm (Maybe String -> Maybe Name)
-> TTerm (Maybe String) -> TTerm (Maybe Name)
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (TTerm (Maybe Term -> (Term -> Maybe String) -> Maybe String)
forall a b. TTerm (Maybe a -> (a -> Maybe b) -> Maybe b)
Optionals.bind
      TTerm (Maybe Term -> (Term -> Maybe String) -> Maybe String)
-> TTerm (Maybe Term)
-> TTerm ((Term -> Maybe String) -> Maybe String)
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (TElement (Name -> Term -> Maybe Term)
-> TTerm (Name -> Term -> Maybe Term)
forall a. TElement a -> TTerm a
ref TElement (Name -> Term -> Maybe Term)
wrapDef TTerm (Name -> Term -> Maybe Term)
-> TTerm Name -> TTerm (Term -> Maybe Term)
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ Name -> TTerm Name
Core.name Name
_Name TTerm (Term -> Maybe Term) -> TTerm Term -> TTerm (Maybe Term)
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ String -> TTerm Term
forall a. String -> TTerm a
var String
"term")
      TTerm ((Term -> Maybe String) -> Maybe String)
-> TTerm (Term -> Maybe String) -> TTerm (Maybe String)
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ TElement (Term -> Maybe String) -> TTerm (Term -> Maybe String)
forall a. TElement a -> TTerm a
ref TElement (Term -> Maybe String)
stringDef)
  where
    nm :: TTerm (String -> Name)
    nm :: TTerm (String -> Name)
nm = Term -> TTerm (String -> Name)
forall a. Term -> TTerm a
TTerm (Term -> TTerm (String -> Name)) -> Term -> TTerm (String -> Name)
forall a b. (a -> b) -> a -> b
$ String -> Term -> Term
Terms.lambda String
"s" (Term -> Term) -> Term -> Term
forall a b. (a -> b) -> a -> b
$ WrappedTerm -> Term
TermWrap (WrappedTerm -> Term) -> WrappedTerm -> Term
forall a b. (a -> b) -> a -> b
$ Name -> Term -> WrappedTerm
WrappedTerm Name
_Name (Term -> WrappedTerm) -> Term -> WrappedTerm
forall a b. (a -> b) -> a -> b
$ String -> Term
Terms.var String
"s"

nominalDef :: TElement ((a -> Name) -> (a -> b) -> (c -> Maybe a) -> Name -> c -> Maybe b)
nominalDef :: forall a b c.
TElement
  ((a -> Name) -> (a -> b) -> (c -> Maybe a) -> Name -> c -> Maybe b)
nominalDef = String
-> TTerm
     ((a -> Name) -> (a -> b) -> (c -> Maybe a) -> Name -> c -> Maybe b)
-> TElement
     ((a -> Name) -> (a -> b) -> (c -> Maybe a) -> Name -> c -> Maybe b)
forall a. String -> TTerm a -> TElement a
decodeDefinition String
"nominal" (TTerm
   ((a -> Name) -> (a -> b) -> (c -> Maybe a) -> Name -> c -> Maybe b)
 -> TElement
      ((a -> Name)
       -> (a -> b) -> (c -> Maybe a) -> Name -> c -> Maybe b))
-> TTerm
     ((a -> Name) -> (a -> b) -> (c -> Maybe a) -> Name -> c -> Maybe b)
-> TElement
     ((a -> Name) -> (a -> b) -> (c -> Maybe a) -> Name -> c -> Maybe b)
forall a b. (a -> b) -> a -> b
$
    [Type]
-> TTerm
     ((a -> Name) -> (a -> b) -> (c -> Maybe a) -> Name -> c -> Maybe b)
-> TTerm
     ((a -> Name) -> (a -> b) -> (c -> Maybe a) -> Name -> c -> Maybe b)
forall a. [Type] -> TTerm a -> TTerm a
functionN [Type -> Type -> Type
funT Type
aT Type
nameT, Type -> Type -> Type
funT Type
aT Type
bT, Type -> Type -> Type
funT Type
cT (Type -> Type
optionalT Type
aT), Type
nameT, Type
cT, Type -> Type
optionalT Type
bT] (TTerm
   ((a -> Name) -> (a -> b) -> (c -> Maybe a) -> Name -> c -> Maybe b)
 -> TTerm
      ((a -> Name)
       -> (a -> b) -> (c -> Maybe a) -> Name -> c -> Maybe b))
-> TTerm
     ((a -> Name) -> (a -> b) -> (c -> Maybe a) -> Name -> c -> Maybe b)
-> TTerm
     ((a -> Name) -> (a -> b) -> (c -> Maybe a) -> Name -> c -> Maybe b)
forall a b. (a -> b) -> a -> b
$
    String
-> TTerm (Any -> Any)
-> TTerm
     ((a -> Name) -> (a -> b) -> (c -> Maybe a) -> Name -> c -> Maybe b)
forall x a b. String -> TTerm x -> TTerm (a -> b)
lambda String
"getName" (TTerm (Any -> Any)
 -> TTerm
      ((a -> Name)
       -> (a -> b) -> (c -> Maybe a) -> Name -> c -> Maybe b))
-> TTerm (Any -> Any)
-> TTerm
     ((a -> Name) -> (a -> b) -> (c -> Maybe a) -> Name -> c -> Maybe b)
forall a b. (a -> b) -> a -> b
$ String -> TTerm (Any -> Any) -> TTerm (Any -> Any)
forall x a b. String -> TTerm x -> TTerm (a -> b)
lambda String
"getB" (TTerm (Any -> Any) -> TTerm (Any -> Any))
-> TTerm (Any -> Any) -> TTerm (Any -> Any)
forall a b. (a -> b) -> a -> b
$ String -> TTerm (Any -> Any) -> TTerm (Any -> Any)
forall x a b. String -> TTerm x -> TTerm (a -> b)
lambda String
"getA" (TTerm (Any -> Any) -> TTerm (Any -> Any))
-> TTerm (Any -> Any) -> TTerm (Any -> Any)
forall a b. (a -> b) -> a -> b
$ String -> TTerm (Any -> Maybe Any) -> TTerm (Any -> Any)
forall x a b. String -> TTerm x -> TTerm (a -> b)
lambda String
"expected" (TTerm (Any -> Maybe Any) -> TTerm (Any -> Any))
-> TTerm (Any -> Maybe Any) -> TTerm (Any -> Any)
forall a b. (a -> b) -> a -> b
$
    TTerm (Any -> Maybe Any)
-> TTerm (Any -> Maybe Any) -> TTerm (Any -> Maybe Any)
forall a b c.
TTerm (a -> Maybe b)
-> TTerm (b -> Maybe c) -> TTerm (a -> Maybe c)
compose2
      (String -> TTerm (Any -> Maybe Any)
forall a. String -> TTerm a
var String
"getA")
      (String -> TTerm (Maybe Any) -> TTerm (Any -> Maybe Any)
forall x a b. String -> TTerm x -> TTerm (a -> b)
lambda String
"a" (TTerm (Maybe Any) -> TTerm (Any -> Maybe Any))
-> TTerm (Maybe Any) -> TTerm (Any -> Maybe Any)
forall a b. (a -> b) -> a -> b
$ (TTerm (Maybe Any -> Maybe Any -> Bool -> Maybe Any)
forall a. TTerm (a -> a -> Bool -> a)
Logic.ifElse
        TTerm (Maybe Any -> Maybe Any -> Bool -> Maybe Any)
-> TTerm (Maybe Any) -> TTerm (Maybe Any -> Bool -> Maybe Any)
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (TTerm Any -> TTerm (Maybe Any)
forall x. TTerm x -> TTerm (Maybe x)
just (String -> TTerm (Any -> Any)
forall a. String -> TTerm a
var String
"getB" TTerm (Any -> Any) -> TTerm Any -> TTerm Any
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ String -> TTerm Any
forall a. String -> TTerm a
var String
"a"))
        TTerm (Maybe Any -> Bool -> Maybe Any)
-> TTerm (Maybe Any) -> TTerm (Bool -> Maybe Any)
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ TTerm (Maybe Any)
forall a. TTerm a
nothing
        TTerm (Bool -> Maybe Any) -> TTerm Bool -> TTerm (Maybe Any)
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (TTerm (Any -> Any -> Bool)
forall a. TTerm (a -> a -> Bool)
Equality.equal TTerm (Any -> Any -> Bool) -> TTerm Any -> TTerm (Any -> Bool)
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (String -> TTerm (Any -> Any)
forall a. String -> TTerm a
var String
"getName" TTerm (Any -> Any) -> TTerm Any -> TTerm Any
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ String -> TTerm Any
forall a. String -> TTerm a
var String
"a") TTerm (Any -> Bool) -> TTerm Any -> TTerm Bool
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ String -> TTerm Any
forall a. String -> TTerm a
var String
"expected")))

optCasesDef :: TElement (Term -> Maybe OptionalCases)
optCasesDef :: TElement (Term -> Maybe OptionalCases)
optCasesDef = String
-> Type
-> Type
-> TTerm (Term -> Maybe OptionalCases)
-> TElement (Term -> Maybe OptionalCases)
forall a. String -> Type -> Type -> TTerm a -> TElement a
decodeFunctionDefinition String
"optCases" Type
termT Type
optionalCasesT (TTerm (Term -> Maybe OptionalCases)
 -> TElement (Term -> Maybe OptionalCases))
-> TTerm (Term -> Maybe OptionalCases)
-> TElement (Term -> Maybe OptionalCases)
forall a b. (a -> b) -> a -> b
$
  TTerm (Term -> Maybe Any)
-> TTerm (Any -> Maybe Any)
-> TTerm (Any -> Maybe OptionalCases)
-> TTerm (Term -> Maybe OptionalCases)
forall a b c d.
TTerm (a -> Maybe b)
-> TTerm (b -> Maybe c)
-> TTerm (c -> Maybe d)
-> TTerm (a -> Maybe d)
compose3
    (Name -> TTerm (Term -> Maybe Any)
forall a. Name -> TTerm (Term -> Maybe a)
matchTermVariant Name
_Term_function)
    (Name -> Name -> TTerm (Any -> Maybe Any)
forall a b. Name -> Name -> TTerm (a -> Maybe b)
matchVariant Name
_Function Name
_Function_elimination)
    (Name -> Name -> TTerm (Any -> Maybe OptionalCases)
forall a b. Name -> Name -> TTerm (a -> Maybe b)
matchVariant Name
_Elimination Name
_Elimination_optional)

optCasesJustDef :: TElement (Term -> Maybe Term)
optCasesJustDef :: TElement (Term -> Maybe Term)
optCasesJustDef = String
-> Type
-> Type
-> TTerm (Term -> Maybe Term)
-> TElement (Term -> Maybe Term)
forall a. String -> Type -> Type -> TTerm a -> TElement a
decodeFunctionDefinition String
"optCasesJust" Type
termT Type
termT (TTerm (Term -> Maybe Term) -> TElement (Term -> Maybe Term))
-> TTerm (Term -> Maybe Term) -> TElement (Term -> Maybe Term)
forall a b. (a -> b) -> a -> b
$
  String -> TTerm (Maybe Term) -> TTerm (Term -> Maybe Term)
forall x a b. String -> TTerm x -> TTerm (a -> b)
lambda String
"term" (TTerm (Maybe Term) -> TTerm (Term -> Maybe Term))
-> TTerm (Maybe Term) -> TTerm (Term -> Maybe Term)
forall a b. (a -> b) -> a -> b
$ TTerm
  ((OptionalCases -> Term) -> Maybe OptionalCases -> Maybe Term)
forall a b. TTerm ((a -> b) -> Maybe a -> Maybe b)
Optionals.map TTerm
  ((OptionalCases -> Term) -> Maybe OptionalCases -> Maybe Term)
-> TTerm (OptionalCases -> Term)
-> TTerm (Maybe OptionalCases -> Maybe Term)
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ TTerm (OptionalCases -> Term)
Core.optionalCasesJust TTerm (Maybe OptionalCases -> Maybe Term)
-> TTerm (Maybe OptionalCases) -> TTerm (Maybe Term)
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (TElement (Term -> Maybe OptionalCases)
-> TTerm (Term -> Maybe OptionalCases)
forall a. TElement a -> TTerm a
ref TElement (Term -> Maybe OptionalCases)
optCasesDef TTerm (Term -> Maybe OptionalCases)
-> TTerm Term -> TTerm (Maybe OptionalCases)
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ String -> TTerm Term
forall a. String -> TTerm a
var String
"term")

optCasesNothingDef :: TElement (Term -> Maybe Term)
optCasesNothingDef :: TElement (Term -> Maybe Term)
optCasesNothingDef = String
-> Type
-> Type
-> TTerm (Term -> Maybe Term)
-> TElement (Term -> Maybe Term)
forall a. String -> Type -> Type -> TTerm a -> TElement a
decodeFunctionDefinition String
"optCasesNothing" Type
termT Type
termT (TTerm (Term -> Maybe Term) -> TElement (Term -> Maybe Term))
-> TTerm (Term -> Maybe Term) -> TElement (Term -> Maybe Term)
forall a b. (a -> b) -> a -> b
$
  String -> TTerm (Maybe Term) -> TTerm (Term -> Maybe Term)
forall x a b. String -> TTerm x -> TTerm (a -> b)
lambda String
"term" (TTerm (Maybe Term) -> TTerm (Term -> Maybe Term))
-> TTerm (Maybe Term) -> TTerm (Term -> Maybe Term)
forall a b. (a -> b) -> a -> b
$ TTerm
  ((OptionalCases -> Term) -> Maybe OptionalCases -> Maybe Term)
forall a b. TTerm ((a -> b) -> Maybe a -> Maybe b)
Optionals.map TTerm
  ((OptionalCases -> Term) -> Maybe OptionalCases -> Maybe Term)
-> TTerm (OptionalCases -> Term)
-> TTerm (Maybe OptionalCases -> Maybe Term)
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ TTerm (OptionalCases -> Term)
Core.optionalCasesNothing TTerm (Maybe OptionalCases -> Maybe Term)
-> TTerm (Maybe OptionalCases) -> TTerm (Maybe Term)
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (TElement (Term -> Maybe OptionalCases)
-> TTerm (Term -> Maybe OptionalCases)
forall a. TElement a -> TTerm a
ref TElement (Term -> Maybe OptionalCases)
optCasesDef TTerm (Term -> Maybe OptionalCases)
-> TTerm Term -> TTerm (Maybe OptionalCases)
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ String -> TTerm Term
forall a. String -> TTerm a
var String
"term")

optionalDef :: TElement (Term -> Maybe (Maybe Term))
optionalDef :: TElement (Term -> Maybe (Maybe Term))
optionalDef = String
-> Type
-> Type
-> TTerm (Term -> Maybe (Maybe Term))
-> TElement (Term -> Maybe (Maybe Term))
forall a. String -> Type -> Type -> TTerm a -> TElement a
decodeFunctionDefinition String
"optional" Type
termT (Type -> Type
optionalT Type
termT) (TTerm (Term -> Maybe (Maybe Term))
 -> TElement (Term -> Maybe (Maybe Term)))
-> TTerm (Term -> Maybe (Maybe Term))
-> TElement (Term -> Maybe (Maybe Term))
forall a b. (a -> b) -> a -> b
$
  Name -> TTerm (Term -> Maybe (Maybe Term))
forall a. Name -> TTerm (Term -> Maybe a)
matchTermVariant Name
_Term_optional

pairDef :: TElement (Term -> Maybe (Term, Term))
pairDef :: TElement (Term -> Maybe (Term, Term))
pairDef = String
-> Type
-> Type
-> TTerm (Term -> Maybe (Term, Term))
-> TElement (Term -> Maybe (Term, Term))
forall a. String -> Type -> Type -> TTerm a -> TElement a
decodeFunctionDefinition String
"pair" Type
termT (Type -> Type -> Type
pairT Type
termT Type
termT) (TTerm (Term -> Maybe (Term, Term))
 -> TElement (Term -> Maybe (Term, Term)))
-> TTerm (Term -> Maybe (Term, Term))
-> TElement (Term -> Maybe (Term, Term))
forall a b. (a -> b) -> a -> b
$
  TTerm (Term -> Maybe Any)
-> TTerm (Any -> Maybe (Term, Term))
-> TTerm (Term -> Maybe (Term, Term))
forall a b c.
TTerm (a -> Maybe b)
-> TTerm (b -> Maybe c) -> TTerm (a -> Maybe c)
compose2
    (Name -> TTerm (Term -> Maybe Any)
forall a. Name -> TTerm (Term -> Maybe a)
matchTermVariant Name
_Term_product)
    (String
-> TTerm (Maybe (Any, Any)) -> TTerm (Any -> Maybe (Term, Term))
forall x a b. String -> TTerm x -> TTerm (a -> b)
lambda String
"l" (TTerm (Maybe (Any, Any)) -> TTerm (Any -> Maybe (Term, Term)))
-> TTerm (Maybe (Any, Any)) -> TTerm (Any -> Maybe (Term, Term))
forall a b. (a -> b) -> a -> b
$ TTerm
  (Maybe (Any, Any) -> Maybe (Any, Any) -> Bool -> Maybe (Any, Any))
forall a. TTerm (a -> a -> Bool -> a)
Logic.ifElse
      TTerm
  (Maybe (Any, Any) -> Maybe (Any, Any) -> Bool -> Maybe (Any, Any))
-> TTerm (Maybe (Any, Any))
-> TTerm (Maybe (Any, Any) -> Bool -> Maybe (Any, Any))
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (TTerm (Any, Any) -> TTerm (Maybe (Any, Any))
forall x. TTerm x -> TTerm (Maybe x)
just (TTerm (Any, Any) -> TTerm (Maybe (Any, Any)))
-> TTerm (Any, Any) -> TTerm (Maybe (Any, Any))
forall a b. (a -> b) -> a -> b
$ TTerm Any -> TTerm Any -> TTerm (Any, Any)
forall a b. TTerm a -> TTerm b -> TTerm (a, b)
pair (TTerm (Int -> [Any] -> Any)
forall a. TTerm (Int -> [a] -> a)
Lists.at TTerm (Int -> [Any] -> Any) -> TTerm Int -> TTerm ([Any] -> Any)
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ Int -> TTerm Int
int32 Int
0 TTerm ([Any] -> Any) -> TTerm [Any] -> TTerm Any
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ String -> TTerm [Any]
forall a. String -> TTerm a
var String
"l") (TTerm (Int -> [Any] -> Any)
forall a. TTerm (Int -> [a] -> a)
Lists.at TTerm (Int -> [Any] -> Any) -> TTerm Int -> TTerm ([Any] -> Any)
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ Int -> TTerm Int
int32 Int
1 TTerm ([Any] -> Any) -> TTerm [Any] -> TTerm Any
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ String -> TTerm [Any]
forall a. String -> TTerm a
var String
"l"))
      TTerm (Maybe (Any, Any) -> Bool -> Maybe (Any, Any))
-> TTerm (Maybe (Any, Any)) -> TTerm (Bool -> Maybe (Any, Any))
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ TTerm (Maybe (Any, Any))
forall a. TTerm a
nothing
      TTerm (Bool -> Maybe (Any, Any))
-> TTerm Bool -> TTerm (Maybe (Any, Any))
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (TTerm (Int -> Int -> Bool)
forall a. TTerm (a -> a -> Bool)
Equality.equal TTerm (Int -> Int -> Bool) -> TTerm Int -> TTerm (Int -> Bool)
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ Int -> TTerm Int
int32 Int
2 TTerm (Int -> Bool) -> TTerm Int -> TTerm Bool
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (TTerm ([Any] -> Int)
forall a. TTerm ([a] -> Int)
Lists.length TTerm ([Any] -> Int) -> TTerm [Any] -> TTerm Int
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ String -> TTerm [Any]
forall a. String -> TTerm a
var String
"l")))

recordDef :: TElement (Name -> Term -> Maybe [Field])
recordDef :: TElement (Name -> Term -> Maybe [Field])
recordDef = String
-> Type
-> TTerm (Name -> Term -> Maybe [Field])
-> TElement (Name -> Term -> Maybe [Field])
forall a. String -> Type -> TTerm a -> TElement a
decodeNominalFunctionDefinition String
"record" (Type -> Type
listT Type
fieldT) (TTerm (Name -> Term -> Maybe [Field])
 -> TElement (Name -> Term -> Maybe [Field]))
-> TTerm (Name -> Term -> Maybe [Field])
-> TElement (Name -> Term -> Maybe [Field])
forall a b. (a -> b) -> a -> b
$
  Name
-> TTerm (Record -> Name)
-> TTerm (Record -> [Field])
-> TTerm (Name -> Term -> Maybe [Field])
forall a b.
Name
-> TTerm (a -> Name)
-> TTerm (a -> b)
-> TTerm (Name -> Term -> Maybe b)
matchNominal Name
_Term_record TTerm (Record -> Name)
Core.recordTypeName TTerm (Record -> [Field])
Core.recordFields

setDef :: TElement (Term -> Maybe (S.Set Term))
setDef :: TElement (Term -> Maybe (Set Term))
setDef = String
-> Type
-> Type
-> TTerm (Term -> Maybe (Set Term))
-> TElement (Term -> Maybe (Set Term))
forall a. String -> Type -> Type -> TTerm a -> TElement a
decodeFunctionDefinition String
"set" Type
termT (Type -> Type
setT Type
termT) (TTerm (Term -> Maybe (Set Term))
 -> TElement (Term -> Maybe (Set Term)))
-> TTerm (Term -> Maybe (Set Term))
-> TElement (Term -> Maybe (Set Term))
forall a b. (a -> b) -> a -> b
$
  Name -> TTerm (Term -> Maybe (Set Term))
forall a. Name -> TTerm (Term -> Maybe a)
matchTermVariant Name
_Term_set

stringDef :: TElement (Term -> Maybe String)
stringDef :: TElement (Term -> Maybe String)
stringDef = String
-> Type
-> Type
-> TTerm (Term -> Maybe String)
-> TElement (Term -> Maybe String)
forall a. String -> Type -> Type -> TTerm a -> TElement a
decodeFunctionDefinition String
"string" Type
termT Type
stringT (TTerm (Term -> Maybe String) -> TElement (Term -> Maybe String))
-> TTerm (Term -> Maybe String) -> TElement (Term -> Maybe String)
forall a b. (a -> b) -> a -> b
$
  TTerm (Term -> Maybe Literal)
-> TTerm (Literal -> Maybe String) -> TTerm (Term -> Maybe String)
forall a b c.
TTerm (a -> Maybe b)
-> TTerm (b -> Maybe c) -> TTerm (a -> Maybe c)
compose2 (TElement (Term -> Maybe Literal) -> TTerm (Term -> Maybe Literal)
forall a. TElement a -> TTerm a
ref TElement (Term -> Maybe Literal)
literalDef) (TElement (Literal -> Maybe String)
-> TTerm (Literal -> Maybe String)
forall a. TElement a -> TTerm a
ref TElement (Literal -> Maybe String)
stringLiteralDef)

stringLiteralDef :: TElement (Literal -> Maybe String)
stringLiteralDef :: TElement (Literal -> Maybe String)
stringLiteralDef = String
-> Type
-> Type
-> TTerm (Literal -> Maybe String)
-> TElement (Literal -> Maybe String)
forall a. String -> Type -> Type -> TTerm a -> TElement a
decodeFunctionDefinition String
"stringLiteral" Type
literalT Type
stringT (TTerm (Literal -> Maybe String)
 -> TElement (Literal -> Maybe String))
-> TTerm (Literal -> Maybe String)
-> TElement (Literal -> Maybe String)
forall a b. (a -> b) -> a -> b
$
  Name -> Name -> TTerm (Literal -> Maybe String)
forall a b. Name -> Name -> TTerm (a -> Maybe b)
matchVariant Name
_Literal Name
_Literal_string

uint8Def :: TElement (Term -> Maybe Int)
uint8Def :: TElement (Term -> Maybe Int)
uint8Def = String
-> Type
-> Type
-> TTerm (Term -> Maybe Int)
-> TElement (Term -> Maybe Int)
forall a. String -> Type -> Type -> TTerm a -> TElement a
decodeFunctionDefinition String
"uint8" Type
termT Type
uint8T (TTerm (Term -> Maybe Int) -> TElement (Term -> Maybe Int))
-> TTerm (Term -> Maybe Int) -> TElement (Term -> Maybe Int)
forall a b. (a -> b) -> a -> b
$
  TTerm (Term -> Maybe Literal)
-> TTerm (Literal -> Maybe IntegerValue)
-> TTerm (IntegerValue -> Maybe Int)
-> TTerm (Term -> Maybe Int)
forall a b c d.
TTerm (a -> Maybe b)
-> TTerm (b -> Maybe c)
-> TTerm (c -> Maybe d)
-> TTerm (a -> Maybe d)
compose3 (TElement (Term -> Maybe Literal) -> TTerm (Term -> Maybe Literal)
forall a. TElement a -> TTerm a
ref TElement (Term -> Maybe Literal)
literalDef) (TElement (Literal -> Maybe IntegerValue)
-> TTerm (Literal -> Maybe IntegerValue)
forall a. TElement a -> TTerm a
ref TElement (Literal -> Maybe IntegerValue)
integerLiteralDef) (TElement (IntegerValue -> Maybe Int)
-> TTerm (IntegerValue -> Maybe Int)
forall a. TElement a -> TTerm a
ref TElement (IntegerValue -> Maybe Int)
uint8ValueDef)

uint8ValueDef :: TElement (IntegerValue -> Maybe Int)
uint8ValueDef :: TElement (IntegerValue -> Maybe Int)
uint8ValueDef = String
-> Type
-> Type
-> TTerm (IntegerValue -> Maybe Int)
-> TElement (IntegerValue -> Maybe Int)
forall a. String -> Type -> Type -> TTerm a -> TElement a
decodeFunctionDefinition String
"uint8Value" Type
integerValueT Type
uint8T (TTerm (IntegerValue -> Maybe Int)
 -> TElement (IntegerValue -> Maybe Int))
-> TTerm (IntegerValue -> Maybe Int)
-> TElement (IntegerValue -> Maybe Int)
forall a b. (a -> b) -> a -> b
$
  Name -> Name -> TTerm (IntegerValue -> Maybe Int)
forall a b. Name -> Name -> TTerm (a -> Maybe b)
matchVariant Name
_IntegerValue Name
_IntegerValue_uint8

uint16Def :: TElement (Term -> Maybe Int)
uint16Def :: TElement (Term -> Maybe Int)
uint16Def = String
-> Type
-> Type
-> TTerm (Term -> Maybe Int)
-> TElement (Term -> Maybe Int)
forall a. String -> Type -> Type -> TTerm a -> TElement a
decodeFunctionDefinition String
"uint16" Type
termT Type
uint16T (TTerm (Term -> Maybe Int) -> TElement (Term -> Maybe Int))
-> TTerm (Term -> Maybe Int) -> TElement (Term -> Maybe Int)
forall a b. (a -> b) -> a -> b
$
  TTerm (Term -> Maybe Literal)
-> TTerm (Literal -> Maybe IntegerValue)
-> TTerm (IntegerValue -> Maybe Int)
-> TTerm (Term -> Maybe Int)
forall a b c d.
TTerm (a -> Maybe b)
-> TTerm (b -> Maybe c)
-> TTerm (c -> Maybe d)
-> TTerm (a -> Maybe d)
compose3 (TElement (Term -> Maybe Literal) -> TTerm (Term -> Maybe Literal)
forall a. TElement a -> TTerm a
ref TElement (Term -> Maybe Literal)
literalDef) (TElement (Literal -> Maybe IntegerValue)
-> TTerm (Literal -> Maybe IntegerValue)
forall a. TElement a -> TTerm a
ref TElement (Literal -> Maybe IntegerValue)
integerLiteralDef) (TElement (IntegerValue -> Maybe Int)
-> TTerm (IntegerValue -> Maybe Int)
forall a. TElement a -> TTerm a
ref TElement (IntegerValue -> Maybe Int)
uint16ValueDef)

uint16ValueDef :: TElement (IntegerValue -> Maybe Int)
uint16ValueDef :: TElement (IntegerValue -> Maybe Int)
uint16ValueDef = String
-> Type
-> Type
-> TTerm (IntegerValue -> Maybe Int)
-> TElement (IntegerValue -> Maybe Int)
forall a. String -> Type -> Type -> TTerm a -> TElement a
decodeFunctionDefinition String
"uint16Value" Type
integerValueT Type
uint16T (TTerm (IntegerValue -> Maybe Int)
 -> TElement (IntegerValue -> Maybe Int))
-> TTerm (IntegerValue -> Maybe Int)
-> TElement (IntegerValue -> Maybe Int)
forall a b. (a -> b) -> a -> b
$
  Name -> Name -> TTerm (IntegerValue -> Maybe Int)
forall a b. Name -> Name -> TTerm (a -> Maybe b)
matchVariant Name
_IntegerValue Name
_IntegerValue_uint16

uint32Def :: TElement (Term -> Maybe Int)
uint32Def :: TElement (Term -> Maybe Int)
uint32Def = String
-> Type
-> Type
-> TTerm (Term -> Maybe Int)
-> TElement (Term -> Maybe Int)
forall a. String -> Type -> Type -> TTerm a -> TElement a
decodeFunctionDefinition String
"uint32" Type
termT Type
uint32T (TTerm (Term -> Maybe Int) -> TElement (Term -> Maybe Int))
-> TTerm (Term -> Maybe Int) -> TElement (Term -> Maybe Int)
forall a b. (a -> b) -> a -> b
$
  TTerm (Term -> Maybe Literal)
-> TTerm (Literal -> Maybe IntegerValue)
-> TTerm (IntegerValue -> Maybe Int)
-> TTerm (Term -> Maybe Int)
forall a b c d.
TTerm (a -> Maybe b)
-> TTerm (b -> Maybe c)
-> TTerm (c -> Maybe d)
-> TTerm (a -> Maybe d)
compose3 (TElement (Term -> Maybe Literal) -> TTerm (Term -> Maybe Literal)
forall a. TElement a -> TTerm a
ref TElement (Term -> Maybe Literal)
literalDef) (TElement (Literal -> Maybe IntegerValue)
-> TTerm (Literal -> Maybe IntegerValue)
forall a. TElement a -> TTerm a
ref TElement (Literal -> Maybe IntegerValue)
integerLiteralDef) (TElement (IntegerValue -> Maybe Int)
-> TTerm (IntegerValue -> Maybe Int)
forall a. TElement a -> TTerm a
ref TElement (IntegerValue -> Maybe Int)
uint32ValueDef)

uint32ValueDef :: TElement (IntegerValue -> Maybe Int)
uint32ValueDef :: TElement (IntegerValue -> Maybe Int)
uint32ValueDef = String
-> Type
-> Type
-> TTerm (IntegerValue -> Maybe Int)
-> TElement (IntegerValue -> Maybe Int)
forall a. String -> Type -> Type -> TTerm a -> TElement a
decodeFunctionDefinition String
"uint32Value" Type
integerValueT Type
uint32T (TTerm (IntegerValue -> Maybe Int)
 -> TElement (IntegerValue -> Maybe Int))
-> TTerm (IntegerValue -> Maybe Int)
-> TElement (IntegerValue -> Maybe Int)
forall a b. (a -> b) -> a -> b
$
  Name -> Name -> TTerm (IntegerValue -> Maybe Int)
forall a b. Name -> Name -> TTerm (a -> Maybe b)
matchVariant Name
_IntegerValue Name
_IntegerValue_uint32

uint64Def :: TElement (Term -> Maybe Int)
uint64Def :: TElement (Term -> Maybe Int)
uint64Def = String
-> Type
-> Type
-> TTerm (Term -> Maybe Int)
-> TElement (Term -> Maybe Int)
forall a. String -> Type -> Type -> TTerm a -> TElement a
decodeFunctionDefinition String
"uint64" Type
termT Type
uint64T (TTerm (Term -> Maybe Int) -> TElement (Term -> Maybe Int))
-> TTerm (Term -> Maybe Int) -> TElement (Term -> Maybe Int)
forall a b. (a -> b) -> a -> b
$
  TTerm (Term -> Maybe Literal)
-> TTerm (Literal -> Maybe IntegerValue)
-> TTerm (IntegerValue -> Maybe Int)
-> TTerm (Term -> Maybe Int)
forall a b c d.
TTerm (a -> Maybe b)
-> TTerm (b -> Maybe c)
-> TTerm (c -> Maybe d)
-> TTerm (a -> Maybe d)
compose3 (TElement (Term -> Maybe Literal) -> TTerm (Term -> Maybe Literal)
forall a. TElement a -> TTerm a
ref TElement (Term -> Maybe Literal)
literalDef) (TElement (Literal -> Maybe IntegerValue)
-> TTerm (Literal -> Maybe IntegerValue)
forall a. TElement a -> TTerm a
ref TElement (Literal -> Maybe IntegerValue)
integerLiteralDef) (TElement (IntegerValue -> Maybe Int)
-> TTerm (IntegerValue -> Maybe Int)
forall a. TElement a -> TTerm a
ref TElement (IntegerValue -> Maybe Int)
uint64ValueDef)

uint64ValueDef :: TElement (IntegerValue -> Maybe Int)
uint64ValueDef :: TElement (IntegerValue -> Maybe Int)
uint64ValueDef = String
-> Type
-> Type
-> TTerm (IntegerValue -> Maybe Int)
-> TElement (IntegerValue -> Maybe Int)
forall a. String -> Type -> Type -> TTerm a -> TElement a
decodeFunctionDefinition String
"uint64Value" Type
integerValueT Type
uint64T (TTerm (IntegerValue -> Maybe Int)
 -> TElement (IntegerValue -> Maybe Int))
-> TTerm (IntegerValue -> Maybe Int)
-> TElement (IntegerValue -> Maybe Int)
forall a b. (a -> b) -> a -> b
$
  Name -> Name -> TTerm (IntegerValue -> Maybe Int)
forall a b. Name -> Name -> TTerm (a -> Maybe b)
matchVariant Name
_IntegerValue Name
_IntegerValue_uint64

unitDef :: TElement (Term -> Maybe ())
unitDef :: TElement (Term -> Maybe ())
unitDef = String
-> Type
-> Type
-> TTerm (Term -> Maybe ())
-> TElement (Term -> Maybe ())
forall a. String -> Type -> Type -> TTerm a -> TElement a
decodeFunctionDefinition String
"unit" Type
termT Type
unitT (TTerm (Term -> Maybe ()) -> TElement (Term -> Maybe ()))
-> TTerm (Term -> Maybe ()) -> TElement (Term -> Maybe ())
forall a b. (a -> b) -> a -> b
$
  String -> TTerm (Maybe Any) -> TTerm (Term -> Maybe ())
forall x a b. String -> TTerm x -> TTerm (a -> b)
lambda String
"term" (TTerm (Maybe Any) -> TTerm (Term -> Maybe ()))
-> TTerm (Maybe Any) -> TTerm (Term -> Maybe ())
forall a b. (a -> b) -> a -> b
$ TTerm (([Field] -> Any) -> Maybe [Field] -> Maybe Any)
forall a b. TTerm ((a -> b) -> Maybe a -> Maybe b)
Optionals.map
    TTerm (([Field] -> Any) -> Maybe [Field] -> Maybe Any)
-> TTerm ([Field] -> Any) -> TTerm (Maybe [Field] -> Maybe Any)
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (TTerm Any -> TTerm ([Field] -> Any)
forall a b. TTerm a -> TTerm (b -> a)
constant TTerm Any
forall a. TTerm a
unit)
    TTerm (Maybe [Field] -> Maybe Any)
-> TTerm (Maybe [Field]) -> TTerm (Maybe Any)
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (TElement (Name -> Term -> Maybe [Field])
-> TTerm (Name -> Term -> Maybe [Field])
forall a. TElement a -> TTerm a
ref TElement (Name -> Term -> Maybe [Field])
recordDef TTerm (Name -> Term -> Maybe [Field])
-> TTerm Name -> TTerm (Term -> Maybe [Field])
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ Name -> TTerm Name
Core.name Name
_Unit TTerm (Term -> Maybe [Field])
-> TTerm Term -> TTerm (Maybe [Field])
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ String -> TTerm Term
forall a. String -> TTerm a
var String
"term")

unitVariantDef :: TElement (Name -> Term -> Maybe Name)
unitVariantDef :: TElement (Name -> Term -> Maybe Name)
unitVariantDef = String
-> TTerm (Name -> Term -> Maybe Name)
-> TElement (Name -> Term -> Maybe Name)
forall a. String -> TTerm a -> TElement a
decodeDefinition String
"unitVariant" (TTerm (Name -> Term -> Maybe Name)
 -> TElement (Name -> Term -> Maybe Name))
-> TTerm (Name -> Term -> Maybe Name)
-> TElement (Name -> Term -> Maybe Name)
forall a b. (a -> b) -> a -> b
$
  [Type]
-> TTerm (Name -> Term -> Maybe Name)
-> TTerm (Name -> Term -> Maybe Name)
forall a. [Type] -> TTerm a -> TTerm a
functionN [Type
nameT, Type
termT, Type -> Type
optionalT Type
nameT] (TTerm (Name -> Term -> Maybe Name)
 -> TTerm (Name -> Term -> Maybe Name))
-> TTerm (Name -> Term -> Maybe Name)
-> TTerm (Name -> Term -> Maybe Name)
forall a b. (a -> b) -> a -> b
$
  String -> TTerm (Any -> Any) -> TTerm (Name -> Term -> Maybe Name)
forall x a b. String -> TTerm x -> TTerm (a -> b)
lambda String
"tname" (TTerm (Any -> Any) -> TTerm (Name -> Term -> Maybe Name))
-> TTerm (Any -> Any) -> TTerm (Name -> Term -> Maybe Name)
forall a b. (a -> b) -> a -> b
$ String -> TTerm (Maybe Name) -> TTerm (Any -> Any)
forall x a b. String -> TTerm x -> TTerm (a -> b)
lambda String
"term" (TTerm (Maybe Name) -> TTerm (Any -> Any))
-> TTerm (Maybe Name) -> TTerm (Any -> Any)
forall a b. (a -> b) -> a -> b
$ TTerm ((Field -> Name) -> Maybe Field -> Maybe Name)
forall a b. TTerm ((a -> b) -> Maybe a -> Maybe b)
Optionals.map
    TTerm ((Field -> Name) -> Maybe Field -> Maybe Name)
-> TTerm (Field -> Name) -> TTerm (Maybe Field -> Maybe Name)
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ TTerm (Field -> Name)
Core.fieldName
    TTerm (Maybe Field -> Maybe Name)
-> TTerm (Maybe Field) -> TTerm (Maybe Name)
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (TElement (Name -> Term -> Maybe Field)
-> TTerm (Name -> Term -> Maybe Field)
forall a. TElement a -> TTerm a
ref TElement (Name -> Term -> Maybe Field)
variantDef TTerm (Name -> Term -> Maybe Field)
-> TTerm Name -> TTerm (Term -> Maybe Field)
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ String -> TTerm Name
forall a. String -> TTerm a
var String
"tname" TTerm (Term -> Maybe Field) -> TTerm Term -> TTerm (Maybe Field)
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ String -> TTerm Term
forall a. String -> TTerm a
var String
"term")

variableDef :: TElement (Term -> Y.Maybe Name)
variableDef :: TElement (Term -> Maybe Name)
variableDef = String
-> Type
-> Type
-> TTerm (Term -> Maybe Name)
-> TElement (Term -> Maybe Name)
forall a. String -> Type -> Type -> TTerm a -> TElement a
decodeFunctionDefinition String
"variable" Type
termT Type
nameT (TTerm (Term -> Maybe Name) -> TElement (Term -> Maybe Name))
-> TTerm (Term -> Maybe Name) -> TElement (Term -> Maybe Name)
forall a b. (a -> b) -> a -> b
$
  Name -> TTerm (Term -> Maybe Name)
forall a. Name -> TTerm (Term -> Maybe a)
matchTermVariant Name
_Term_variable TTerm (Term -> Maybe Name)
-> TTerm (Term -> Term) -> TTerm (Term -> Maybe Name)
forall b c a. TTerm (b -> c) -> TTerm (a -> b) -> TTerm (a -> c)
<.> TElement (Term -> Term) -> TTerm (Term -> Term)
forall a. TElement a -> TTerm a
ref TElement (Term -> Term)
fullyStripTermDef

variantDef :: TElement (Name -> Term -> Maybe Field)
variantDef :: TElement (Name -> Term -> Maybe Field)
variantDef = String
-> Type
-> TTerm (Name -> Term -> Maybe Field)
-> TElement (Name -> Term -> Maybe Field)
forall a. String -> Type -> TTerm a -> TElement a
decodeNominalFunctionDefinition String
"variant" Type
fieldT (TTerm (Name -> Term -> Maybe Field)
 -> TElement (Name -> Term -> Maybe Field))
-> TTerm (Name -> Term -> Maybe Field)
-> TElement (Name -> Term -> Maybe Field)
forall a b. (a -> b) -> a -> b
$
  Name
-> TTerm (Injection -> Name)
-> TTerm (Injection -> Field)
-> TTerm (Name -> Term -> Maybe Field)
forall a b.
Name
-> TTerm (a -> Name)
-> TTerm (a -> b)
-> TTerm (Name -> Term -> Maybe b)
matchNominal Name
_Term_union TTerm (Injection -> Name)
Core.injectionTypeName TTerm (Injection -> Field)
Core.injectionField

wrapDef :: TElement (Name -> Term -> Maybe Term)
wrapDef :: TElement (Name -> Term -> Maybe Term)
wrapDef = String
-> Type
-> TTerm (Name -> Term -> Maybe Term)
-> TElement (Name -> Term -> Maybe Term)
forall a. String -> Type -> TTerm a -> TElement a
decodeNominalFunctionDefinition String
"wrap" Type
termT (TTerm (Name -> Term -> Maybe Term)
 -> TElement (Name -> Term -> Maybe Term))
-> TTerm (Name -> Term -> Maybe Term)
-> TElement (Name -> Term -> Maybe Term)
forall a b. (a -> b) -> a -> b
$
  Name
-> TTerm (WrappedTerm -> Name)
-> TTerm (WrappedTerm -> Term)
-> TTerm (Name -> Term -> Maybe Term)
forall a b.
Name
-> TTerm (a -> Name)
-> TTerm (a -> b)
-> TTerm (Name -> Term -> Maybe b)
matchNominal Name
_Term_wrap TTerm (WrappedTerm -> Name)
Core.wrappedTermTypeName TTerm (WrappedTerm -> Term)
Core.wrappedTermObject

--

compose2 :: TTerm (a -> Maybe b) -> TTerm (b -> Maybe c) -> TTerm (a -> Maybe c)
compose2 :: forall a b c.
TTerm (a -> Maybe b)
-> TTerm (b -> Maybe c) -> TTerm (a -> Maybe c)
compose2 TTerm (a -> Maybe b)
f TTerm (b -> Maybe c)
g = TTerm ((a -> Maybe b) -> (b -> Maybe c) -> a -> Maybe c)
forall a b c.
TTerm ((a -> Maybe b) -> (b -> Maybe c) -> a -> Maybe c)
Optionals.compose TTerm ((a -> Maybe b) -> (b -> Maybe c) -> a -> Maybe c)
-> TTerm (a -> Maybe b) -> TTerm ((b -> Maybe c) -> a -> Maybe c)
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ TTerm (a -> Maybe b)
f TTerm ((b -> Maybe c) -> a -> Maybe c)
-> TTerm (b -> Maybe c) -> TTerm (a -> Maybe c)
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ TTerm (b -> Maybe c)
g

compose3 :: TTerm (a -> Maybe b) -> TTerm (b -> Maybe c) -> TTerm (c -> Maybe d) -> TTerm (a -> Maybe d)
compose3 :: forall a b c d.
TTerm (a -> Maybe b)
-> TTerm (b -> Maybe c)
-> TTerm (c -> Maybe d)
-> TTerm (a -> Maybe d)
compose3 TTerm (a -> Maybe b)
f TTerm (b -> Maybe c)
g TTerm (c -> Maybe d)
h = TTerm ((a -> Maybe c) -> (c -> Maybe d) -> a -> Maybe d)
forall a b c.
TTerm ((a -> Maybe b) -> (b -> Maybe c) -> a -> Maybe c)
Optionals.compose TTerm ((a -> Maybe c) -> (c -> Maybe d) -> a -> Maybe d)
-> TTerm (a -> Maybe c) -> TTerm ((c -> Maybe d) -> a -> Maybe d)
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (TTerm ((a -> Maybe b) -> (b -> Maybe c) -> a -> Maybe c)
forall a b c.
TTerm ((a -> Maybe b) -> (b -> Maybe c) -> a -> Maybe c)
Optionals.compose TTerm ((a -> Maybe b) -> (b -> Maybe c) -> a -> Maybe c)
-> TTerm (a -> Maybe b) -> TTerm ((b -> Maybe c) -> a -> Maybe c)
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ TTerm (a -> Maybe b)
f TTerm ((b -> Maybe c) -> a -> Maybe c)
-> TTerm (b -> Maybe c) -> TTerm (a -> Maybe c)
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ TTerm (b -> Maybe c)
g) TTerm ((c -> Maybe d) -> a -> Maybe d)
-> TTerm (c -> Maybe d) -> TTerm (a -> Maybe d)
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ TTerm (c -> Maybe d)
h

matchNominal :: Name -> TTerm (a -> Name) -> TTerm (a -> b) -> TTerm (Name -> Term -> Maybe b)
matchNominal :: forall a b.
Name
-> TTerm (a -> Name)
-> TTerm (a -> b)
-> TTerm (Name -> Term -> Maybe b)
matchNominal Name
fname TTerm (a -> Name)
getName TTerm (a -> b)
getB = TElement
  ((a -> Name)
   -> (a -> b) -> (Term -> Maybe a) -> Name -> Term -> Maybe b)
-> TTerm
     ((a -> Name)
      -> (a -> b) -> (Term -> Maybe a) -> Name -> Term -> Maybe b)
forall a. TElement a -> TTerm a
ref TElement
  ((a -> Name)
   -> (a -> b) -> (Term -> Maybe a) -> Name -> Term -> Maybe b)
forall a b c.
TElement
  ((a -> Name) -> (a -> b) -> (c -> Maybe a) -> Name -> c -> Maybe b)
nominalDef TTerm
  ((a -> Name)
   -> (a -> b) -> (Term -> Maybe a) -> Name -> Term -> Maybe b)
-> TTerm (a -> Name)
-> TTerm ((a -> b) -> (Term -> Maybe a) -> Name -> Term -> Maybe b)
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ TTerm (a -> Name)
getName TTerm ((a -> b) -> (Term -> Maybe a) -> Name -> Term -> Maybe b)
-> TTerm (a -> b)
-> TTerm ((Term -> Maybe a) -> Name -> Term -> Maybe b)
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ TTerm (a -> b)
getB TTerm ((Term -> Maybe a) -> Name -> Term -> Maybe b)
-> TTerm (Term -> Maybe a) -> TTerm (Name -> Term -> Maybe b)
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ Name -> TTerm (Term -> Maybe a)
forall a. Name -> TTerm (Term -> Maybe a)
matchTermVariant Name
fname

matchTermVariant :: Name -> TTerm (Term -> Maybe a)
matchTermVariant :: forall a. Name -> TTerm (Term -> Maybe a)
matchTermVariant Name
fname = Name -> Name -> TTerm (Term -> Maybe a)
forall a b. Name -> Name -> TTerm (a -> Maybe b)
matchVariant Name
_Term Name
fname TTerm (Term -> Maybe a)
-> TTerm (Term -> Term) -> TTerm (Term -> Maybe a)
forall b c a. TTerm (b -> c) -> TTerm (a -> b) -> TTerm (a -> c)
<.> TElement (Term -> Term) -> TTerm (Term -> Term)
forall a. TElement a -> TTerm a
ref TElement (Term -> Term)
fullyStripTermDef

matchVariant :: Name -> Name -> TTerm (a -> Maybe b)
matchVariant :: forall a b. Name -> Name -> TTerm (a -> Maybe b)
matchVariant Name
tname Name
fname = Name -> Maybe (TTerm (Maybe b)) -> [Field] -> TTerm (a -> Maybe b)
forall b u. Name -> Maybe (TTerm b) -> [Field] -> TTerm (u -> b)
match Name
tname (TTerm (Maybe b) -> Maybe (TTerm (Maybe b))
forall a. a -> Maybe a
Just TTerm (Maybe b)
forall a. TTerm a
nothing) [Name -> TCase Any
forall a. Name -> TCase a
TCase Name
fname TCase Any -> TTerm (Any -> Maybe Any) -> Field
forall a b. TCase a -> TTerm (a -> b) -> Field
--> TTerm (Any -> Maybe Any)
forall a. TTerm (a -> Maybe a)
Optionals.pure]