-- | A module for decoding terms to native objects

module Hydra.Decode where

import qualified Hydra.Core as Core
import qualified Hydra.Lib.Equality as Equality
import qualified Hydra.Lib.Lists as Lists
import qualified Hydra.Lib.Logic as Logic
import qualified Hydra.Lib.Optionals as Optionals
import qualified Hydra.Strip as Strip
import Data.Int
import Data.List as L
import Data.Map as M
import Data.Set as S

bigfloat :: (Core.Term -> Maybe Double)
bigfloat :: Term -> Maybe Double
bigfloat = ((Term -> Maybe FloatValue)
-> (FloatValue -> Maybe Double) -> Term -> Maybe Double
forall a b c. (a -> Maybe b) -> (b -> Maybe c) -> a -> Maybe c
Optionals.compose ((Term -> Maybe Literal)
-> (Literal -> Maybe FloatValue) -> Term -> Maybe FloatValue
forall a b c. (a -> Maybe b) -> (b -> Maybe c) -> a -> Maybe c
Optionals.compose Term -> Maybe Literal
literal Literal -> Maybe FloatValue
floatLiteral) FloatValue -> Maybe Double
bigfloatValue)

bigfloatValue :: (Core.FloatValue -> Maybe Double)
bigfloatValue :: FloatValue -> Maybe Double
bigfloatValue FloatValue
x = case FloatValue
x of
  Core.FloatValueBigfloat Double
v75 -> (Double -> Maybe Double
forall a. a -> Maybe a
Optionals.pure Double
v75)
  FloatValue
_ -> Maybe Double
forall a. Maybe a
Nothing

bigint :: (Core.Term -> Maybe Integer)
bigint :: Term -> Maybe Integer
bigint = ((Term -> Maybe IntegerValue)
-> (IntegerValue -> Maybe Integer) -> Term -> Maybe Integer
forall a b c. (a -> Maybe b) -> (b -> Maybe c) -> a -> Maybe c
Optionals.compose ((Term -> Maybe Literal)
-> (Literal -> Maybe IntegerValue) -> Term -> Maybe IntegerValue
forall a b c. (a -> Maybe b) -> (b -> Maybe c) -> a -> Maybe c
Optionals.compose Term -> Maybe Literal
literal Literal -> Maybe IntegerValue
integerLiteral) IntegerValue -> Maybe Integer
bigintValue)

bigintValue :: (Core.IntegerValue -> Maybe Integer)
bigintValue :: IntegerValue -> Maybe Integer
bigintValue IntegerValue
x = case IntegerValue
x of
  Core.IntegerValueBigint Integer
v76 -> (Integer -> Maybe Integer
forall a. a -> Maybe a
Optionals.pure Integer
v76)
  IntegerValue
_ -> Maybe Integer
forall a. Maybe a
Nothing

binary :: (Core.Term -> Maybe String)
binary :: Term -> Maybe String
binary = ((Term -> Maybe Literal)
-> (Literal -> Maybe String) -> Term -> Maybe String
forall a b c. (a -> Maybe b) -> (b -> Maybe c) -> a -> Maybe c
Optionals.compose Term -> Maybe Literal
literal Literal -> Maybe String
binaryLiteral)

binaryLiteral :: (Core.Literal -> Maybe String)
binaryLiteral :: Literal -> Maybe String
binaryLiteral Literal
x = case Literal
x of
  Core.LiteralBinary String
v77 -> (String -> Maybe String
forall a. a -> Maybe a
Optionals.pure String
v77)
  Literal
_ -> Maybe String
forall a. Maybe a
Nothing

boolean :: (Core.Term -> Maybe Bool)
boolean :: Term -> Maybe Bool
boolean = ((Term -> Maybe Literal)
-> (Literal -> Maybe Bool) -> Term -> Maybe Bool
forall a b c. (a -> Maybe b) -> (b -> Maybe c) -> a -> Maybe c
Optionals.compose Term -> Maybe Literal
literal Literal -> Maybe Bool
booleanLiteral)

booleanLiteral :: (Core.Literal -> Maybe Bool)
booleanLiteral :: Literal -> Maybe Bool
booleanLiteral Literal
x = case Literal
x of
  Core.LiteralBoolean Bool
v78 -> (Bool -> Maybe Bool
forall a. a -> Maybe a
Optionals.pure Bool
v78)
  Literal
_ -> Maybe Bool
forall a. Maybe a
Nothing

casesCase :: (Core.Name -> Core.Name -> Core.Term -> Maybe Core.Term)
casesCase :: Name -> Name -> Term -> Maybe Term
casesCase Name
tname Name
fname = ((Term -> Maybe [Field])
-> ([Field] -> Maybe Term) -> Term -> Maybe Term
forall a b c. (a -> Maybe b) -> (b -> Maybe c) -> a -> Maybe c
Optionals.compose (Name -> Term -> Maybe [Field]
cases Name
tname) (Name -> [Field] -> Maybe Term
field Name
fname))

cases :: (Core.Name -> Core.Term -> Maybe [Core.Field])
cases :: Name -> Term -> Maybe [Field]
cases = ((CaseStatement -> Name)
-> (CaseStatement -> [Field])
-> (Term -> Maybe CaseStatement)
-> Name
-> Term
-> Maybe [Field]
forall a b c.
(a -> Name) -> (a -> b) -> (c -> Maybe a) -> Name -> c -> Maybe b
nominal CaseStatement -> Name
Core.caseStatementTypeName CaseStatement -> [Field]
Core.caseStatementCases ((Term -> Maybe Elimination)
-> (Elimination -> Maybe CaseStatement)
-> Term
-> Maybe CaseStatement
forall a b c. (a -> Maybe b) -> (b -> Maybe c) -> a -> Maybe c
Optionals.compose ((Term -> Maybe Function)
-> (Function -> Maybe Elimination) -> Term -> Maybe Elimination
forall a b c. (a -> Maybe b) -> (b -> Maybe c) -> a -> Maybe c
Optionals.compose (\Term
x -> (\Term
x -> case Term
x of
  Core.TermFunction Function
v79 -> (Function -> Maybe Function
forall a. a -> Maybe a
Optionals.pure Function
v79)
  Term
_ -> Maybe Function
forall a. Maybe a
Nothing) (Term -> Term
Strip.fullyStripTerm Term
x)) (\Function
x -> case Function
x of
  Core.FunctionElimination Elimination
v80 -> (Elimination -> Maybe Elimination
forall a. a -> Maybe a
Optionals.pure Elimination
v80)
  Function
_ -> Maybe Elimination
forall a. Maybe a
Nothing)) (\Elimination
x -> case Elimination
x of
  Core.EliminationUnion CaseStatement
v81 -> (CaseStatement -> Maybe CaseStatement
forall a. a -> Maybe a
Optionals.pure CaseStatement
v81)
  Elimination
_ -> Maybe CaseStatement
forall a. Maybe a
Nothing)))

field :: (Core.Name -> [Core.Field] -> Maybe Core.Term)
field :: Name -> [Field] -> Maybe Term
field Name
fname [Field]
fields =  
  let matches :: [Field]
matches = ((Field -> Bool) -> [Field] -> [Field]
forall a. (a -> Bool) -> [a] -> [a]
Lists.filter (\Field
f -> Name -> Name -> Bool
forall a. Eq a => a -> a -> Bool
Equality.equal (Field -> Name
Core.fieldName Field
f) Name
fname) [Field]
fields)
  in (Maybe Term -> Maybe Term -> Bool -> Maybe Term
forall a. a -> a -> Bool -> a
Logic.ifElse (Term -> Maybe Term
forall a. a -> Maybe a
Just (Field -> Term
Core.fieldTerm ([Field] -> Field
forall a. [a] -> a
Lists.head [Field]
matches))) Maybe Term
forall a. Maybe a
Nothing (Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
Equality.equal Int
1 ([Field] -> Int
forall a. [a] -> Int
Lists.length [Field]
matches)))

float32 :: (Core.Term -> Maybe Float)
float32 :: Term -> Maybe Float
float32 = ((Term -> Maybe FloatValue)
-> (FloatValue -> Maybe Float) -> Term -> Maybe Float
forall a b c. (a -> Maybe b) -> (b -> Maybe c) -> a -> Maybe c
Optionals.compose ((Term -> Maybe Literal)
-> (Literal -> Maybe FloatValue) -> Term -> Maybe FloatValue
forall a b c. (a -> Maybe b) -> (b -> Maybe c) -> a -> Maybe c
Optionals.compose Term -> Maybe Literal
literal Literal -> Maybe FloatValue
floatLiteral) FloatValue -> Maybe Float
float32Value)

float32Value :: (Core.FloatValue -> Maybe Float)
float32Value :: FloatValue -> Maybe Float
float32Value FloatValue
x = case FloatValue
x of
  Core.FloatValueFloat32 Float
v82 -> (Float -> Maybe Float
forall a. a -> Maybe a
Optionals.pure Float
v82)
  FloatValue
_ -> Maybe Float
forall a. Maybe a
Nothing

float64 :: (Core.Term -> Maybe Double)
float64 :: Term -> Maybe Double
float64 = ((Term -> Maybe FloatValue)
-> (FloatValue -> Maybe Double) -> Term -> Maybe Double
forall a b c. (a -> Maybe b) -> (b -> Maybe c) -> a -> Maybe c
Optionals.compose ((Term -> Maybe Literal)
-> (Literal -> Maybe FloatValue) -> Term -> Maybe FloatValue
forall a b c. (a -> Maybe b) -> (b -> Maybe c) -> a -> Maybe c
Optionals.compose Term -> Maybe Literal
literal Literal -> Maybe FloatValue
floatLiteral) FloatValue -> Maybe Double
float64Value)

float64Value :: (Core.FloatValue -> Maybe Double)
float64Value :: FloatValue -> Maybe Double
float64Value FloatValue
x = case FloatValue
x of
  Core.FloatValueFloat64 Double
v83 -> (Double -> Maybe Double
forall a. a -> Maybe a
Optionals.pure Double
v83)
  FloatValue
_ -> Maybe Double
forall a. Maybe a
Nothing

floatLiteral :: (Core.Literal -> Maybe Core.FloatValue)
floatLiteral :: Literal -> Maybe FloatValue
floatLiteral Literal
x = case Literal
x of
  Core.LiteralFloat FloatValue
v84 -> (FloatValue -> Maybe FloatValue
forall a. a -> Maybe a
Optionals.pure FloatValue
v84)
  Literal
_ -> Maybe FloatValue
forall a. Maybe a
Nothing

int16 :: (Core.Term -> Maybe Int16)
int16 :: Term -> Maybe Int16
int16 = ((Term -> Maybe IntegerValue)
-> (IntegerValue -> Maybe Int16) -> Term -> Maybe Int16
forall a b c. (a -> Maybe b) -> (b -> Maybe c) -> a -> Maybe c
Optionals.compose ((Term -> Maybe Literal)
-> (Literal -> Maybe IntegerValue) -> Term -> Maybe IntegerValue
forall a b c. (a -> Maybe b) -> (b -> Maybe c) -> a -> Maybe c
Optionals.compose Term -> Maybe Literal
literal Literal -> Maybe IntegerValue
integerLiteral) IntegerValue -> Maybe Int16
int16Value)

int16Value :: (Core.IntegerValue -> Maybe Int16)
int16Value :: IntegerValue -> Maybe Int16
int16Value IntegerValue
x = case IntegerValue
x of
  Core.IntegerValueInt16 Int16
v85 -> (Int16 -> Maybe Int16
forall a. a -> Maybe a
Optionals.pure Int16
v85)
  IntegerValue
_ -> Maybe Int16
forall a. Maybe a
Nothing

int32 :: (Core.Term -> Maybe Int)
int32 :: Term -> Maybe Int
int32 = ((Term -> Maybe IntegerValue)
-> (IntegerValue -> Maybe Int) -> Term -> Maybe Int
forall a b c. (a -> Maybe b) -> (b -> Maybe c) -> a -> Maybe c
Optionals.compose ((Term -> Maybe Literal)
-> (Literal -> Maybe IntegerValue) -> Term -> Maybe IntegerValue
forall a b c. (a -> Maybe b) -> (b -> Maybe c) -> a -> Maybe c
Optionals.compose Term -> Maybe Literal
literal Literal -> Maybe IntegerValue
integerLiteral) IntegerValue -> Maybe Int
int32Value)

int32Value :: (Core.IntegerValue -> Maybe Int)
int32Value :: IntegerValue -> Maybe Int
int32Value IntegerValue
x = case IntegerValue
x of
  Core.IntegerValueInt32 Int
v86 -> (Int -> Maybe Int
forall a. a -> Maybe a
Optionals.pure Int
v86)
  IntegerValue
_ -> Maybe Int
forall a. Maybe a
Nothing

int64 :: (Core.Term -> Maybe Int64)
int64 :: Term -> Maybe Int64
int64 = ((Term -> Maybe IntegerValue)
-> (IntegerValue -> Maybe Int64) -> Term -> Maybe Int64
forall a b c. (a -> Maybe b) -> (b -> Maybe c) -> a -> Maybe c
Optionals.compose ((Term -> Maybe Literal)
-> (Literal -> Maybe IntegerValue) -> Term -> Maybe IntegerValue
forall a b c. (a -> Maybe b) -> (b -> Maybe c) -> a -> Maybe c
Optionals.compose Term -> Maybe Literal
literal Literal -> Maybe IntegerValue
integerLiteral) IntegerValue -> Maybe Int64
int64Value)

int64Value :: (Core.IntegerValue -> Maybe Int64)
int64Value :: IntegerValue -> Maybe Int64
int64Value IntegerValue
x = case IntegerValue
x of
  Core.IntegerValueInt64 Int64
v87 -> (Int64 -> Maybe Int64
forall a. a -> Maybe a
Optionals.pure Int64
v87)
  IntegerValue
_ -> Maybe Int64
forall a. Maybe a
Nothing

int8 :: (Core.Term -> Maybe Int8)
int8 :: Term -> Maybe Int8
int8 = ((Term -> Maybe IntegerValue)
-> (IntegerValue -> Maybe Int8) -> Term -> Maybe Int8
forall a b c. (a -> Maybe b) -> (b -> Maybe c) -> a -> Maybe c
Optionals.compose ((Term -> Maybe Literal)
-> (Literal -> Maybe IntegerValue) -> Term -> Maybe IntegerValue
forall a b c. (a -> Maybe b) -> (b -> Maybe c) -> a -> Maybe c
Optionals.compose Term -> Maybe Literal
literal Literal -> Maybe IntegerValue
integerLiteral) IntegerValue -> Maybe Int8
int8Value)

int8Value :: (Core.IntegerValue -> Maybe Int8)
int8Value :: IntegerValue -> Maybe Int8
int8Value IntegerValue
x = case IntegerValue
x of
  Core.IntegerValueInt8 Int8
v88 -> (Int8 -> Maybe Int8
forall a. a -> Maybe a
Optionals.pure Int8
v88)
  IntegerValue
_ -> Maybe Int8
forall a. Maybe a
Nothing

integerLiteral :: (Core.Literal -> Maybe Core.IntegerValue)
integerLiteral :: Literal -> Maybe IntegerValue
integerLiteral Literal
x = case Literal
x of
  Core.LiteralInteger IntegerValue
v89 -> (IntegerValue -> Maybe IntegerValue
forall a. a -> Maybe a
Optionals.pure IntegerValue
v89)
  Literal
_ -> Maybe IntegerValue
forall a. Maybe a
Nothing

lambda :: (Core.Term -> Maybe Core.Lambda)
lambda :: Term -> Maybe Lambda
lambda = ((Term -> Maybe Function)
-> (Function -> Maybe Lambda) -> Term -> Maybe Lambda
forall a b c. (a -> Maybe b) -> (b -> Maybe c) -> a -> Maybe c
Optionals.compose (\Term
x -> (\Term
x -> case Term
x of
  Core.TermFunction Function
v90 -> (Function -> Maybe Function
forall a. a -> Maybe a
Optionals.pure Function
v90)
  Term
_ -> Maybe Function
forall a. Maybe a
Nothing) (Term -> Term
Strip.fullyStripTerm Term
x)) (\Function
x -> case Function
x of
  Core.FunctionLambda Lambda
v91 -> (Lambda -> Maybe Lambda
forall a. a -> Maybe a
Optionals.pure Lambda
v91)
  Function
_ -> Maybe Lambda
forall a. Maybe a
Nothing))

letBinding :: (Core.Name -> Core.Term -> Maybe Core.LetBinding)
letBinding :: Name -> Term -> Maybe LetBinding
letBinding Name
fname Term
term = (Maybe [LetBinding]
-> ([LetBinding] -> Maybe LetBinding) -> Maybe LetBinding
forall a b. Maybe a -> (a -> Maybe b) -> Maybe b
Optionals.bind ((Let -> [LetBinding]) -> Maybe Let -> Maybe [LetBinding]
forall a b. (a -> b) -> Maybe a -> Maybe b
Optionals.map Let -> [LetBinding]
Core.letBindings (Term -> Maybe Let
letTerm Term
term)) (Name -> [LetBinding] -> Maybe LetBinding
letBindingWithKey Name
fname))

letBindingWithKey :: (Core.Name -> [Core.LetBinding] -> Maybe Core.LetBinding)
letBindingWithKey :: Name -> [LetBinding] -> Maybe LetBinding
letBindingWithKey Name
fname [LetBinding]
bindings =  
  let matches :: [LetBinding]
matches = ((LetBinding -> Bool) -> [LetBinding] -> [LetBinding]
forall a. (a -> Bool) -> [a] -> [a]
Lists.filter (\LetBinding
b -> Name -> Name -> Bool
forall a. Eq a => a -> a -> Bool
Equality.equal (LetBinding -> Name
Core.letBindingName LetBinding
b) Name
fname) [LetBinding]
bindings)
  in (Maybe LetBinding -> Maybe LetBinding -> Bool -> Maybe LetBinding
forall a. a -> a -> Bool -> a
Logic.ifElse (LetBinding -> Maybe LetBinding
forall a. a -> Maybe a
Just ([LetBinding] -> LetBinding
forall a. [a] -> a
Lists.head [LetBinding]
matches)) Maybe LetBinding
forall a. Maybe a
Nothing (Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
Equality.equal Int
1 ([LetBinding] -> Int
forall a. [a] -> Int
Lists.length [LetBinding]
matches)))

letTerm :: (Core.Term -> Maybe Core.Let)
letTerm :: Term -> Maybe Let
letTerm Term
x = ((\Term
x -> case Term
x of
  Core.TermLet Let
v92 -> (Let -> Maybe Let
forall a. a -> Maybe a
Optionals.pure Let
v92)
  Term
_ -> Maybe Let
forall a. Maybe a
Nothing) (Term -> Term
Strip.fullyStripTerm Term
x))

list :: (Core.Term -> Maybe [Core.Term])
list :: Term -> Maybe [Term]
list Term
x = ((\Term
x -> case Term
x of
  Core.TermList [Term]
v93 -> ([Term] -> Maybe [Term]
forall a. a -> Maybe a
Optionals.pure [Term]
v93)
  Term
_ -> Maybe [Term]
forall a. Maybe a
Nothing) (Term -> Term
Strip.fullyStripTerm Term
x))

literal :: (Core.Term -> Maybe Core.Literal)
literal :: Term -> Maybe Literal
literal Term
x = ((\Term
x -> case Term
x of
  Core.TermLiteral Literal
v94 -> (Literal -> Maybe Literal
forall a. a -> Maybe a
Optionals.pure Literal
v94)
  Term
_ -> Maybe Literal
forall a. Maybe a
Nothing) (Term -> Term
Strip.fullyStripTerm Term
x))

map :: (Core.Term -> Maybe (Map Core.Term Core.Term))
map :: Term -> Maybe (Map Term Term)
map Term
x = ((\Term
x -> case Term
x of
  Core.TermMap Map Term Term
v95 -> (Map Term Term -> Maybe (Map Term Term)
forall a. a -> Maybe a
Optionals.pure Map Term Term
v95)
  Term
_ -> Maybe (Map Term Term)
forall a. Maybe a
Nothing) (Term -> Term
Strip.fullyStripTerm Term
x))

name :: (Core.Term -> Maybe Core.Name)
name :: Term -> Maybe Name
name Term
term = ((String -> Name) -> Maybe String -> Maybe Name
forall a b. (a -> b) -> Maybe a -> Maybe b
Optionals.map (\String
s -> String -> Name
Core.Name String
s) (Maybe Term -> (Term -> Maybe String) -> Maybe String
forall a b. Maybe a -> (a -> Maybe b) -> Maybe b
Optionals.bind (Name -> Term -> Maybe Term
wrap (String -> Name
Core.Name String
"hydra/core.Name") Term
term) Term -> Maybe String
string))

nominal :: ((a -> Core.Name) -> (a -> b) -> (c -> Maybe a) -> Core.Name -> c -> Maybe b)
nominal :: forall a b c.
(a -> Name) -> (a -> b) -> (c -> Maybe a) -> Name -> c -> Maybe b
nominal a -> Name
getName a -> b
getB c -> Maybe a
getA Name
expected = ((c -> Maybe a) -> (a -> Maybe b) -> c -> Maybe b
forall a b c. (a -> Maybe b) -> (b -> Maybe c) -> a -> Maybe c
Optionals.compose c -> Maybe a
getA (\a
a -> Maybe b -> Maybe b -> Bool -> Maybe b
forall a. a -> a -> Bool -> a
Logic.ifElse (b -> Maybe b
forall a. a -> Maybe a
Just (a -> b
getB a
a)) Maybe b
forall a. Maybe a
Nothing (Name -> Name -> Bool
forall a. Eq a => a -> a -> Bool
Equality.equal (a -> Name
getName a
a) Name
expected)))

optCases :: (Core.Term -> Maybe Core.OptionalCases)
optCases :: Term -> Maybe OptionalCases
optCases = ((Term -> Maybe Elimination)
-> (Elimination -> Maybe OptionalCases)
-> Term
-> Maybe OptionalCases
forall a b c. (a -> Maybe b) -> (b -> Maybe c) -> a -> Maybe c
Optionals.compose ((Term -> Maybe Function)
-> (Function -> Maybe Elimination) -> Term -> Maybe Elimination
forall a b c. (a -> Maybe b) -> (b -> Maybe c) -> a -> Maybe c
Optionals.compose (\Term
x -> (\Term
x -> case Term
x of
  Core.TermFunction Function
v96 -> (Function -> Maybe Function
forall a. a -> Maybe a
Optionals.pure Function
v96)
  Term
_ -> Maybe Function
forall a. Maybe a
Nothing) (Term -> Term
Strip.fullyStripTerm Term
x)) (\Function
x -> case Function
x of
  Core.FunctionElimination Elimination
v97 -> (Elimination -> Maybe Elimination
forall a. a -> Maybe a
Optionals.pure Elimination
v97)
  Function
_ -> Maybe Elimination
forall a. Maybe a
Nothing)) (\Elimination
x -> case Elimination
x of
  Core.EliminationOptional OptionalCases
v98 -> (OptionalCases -> Maybe OptionalCases
forall a. a -> Maybe a
Optionals.pure OptionalCases
v98)
  Elimination
_ -> Maybe OptionalCases
forall a. Maybe a
Nothing))

optCasesJust :: (Core.Term -> Maybe Core.Term)
optCasesJust :: Term -> Maybe Term
optCasesJust Term
term = ((OptionalCases -> Term) -> Maybe OptionalCases -> Maybe Term
forall a b. (a -> b) -> Maybe a -> Maybe b
Optionals.map OptionalCases -> Term
Core.optionalCasesJust (Term -> Maybe OptionalCases
optCases Term
term))

optCasesNothing :: (Core.Term -> Maybe Core.Term)
optCasesNothing :: Term -> Maybe Term
optCasesNothing Term
term = ((OptionalCases -> Term) -> Maybe OptionalCases -> Maybe Term
forall a b. (a -> b) -> Maybe a -> Maybe b
Optionals.map OptionalCases -> Term
Core.optionalCasesNothing (Term -> Maybe OptionalCases
optCases Term
term))

optional :: (Core.Term -> Maybe (Maybe Core.Term))
optional :: Term -> Maybe (Maybe Term)
optional Term
x = ((\Term
x -> case Term
x of
  Core.TermOptional Maybe Term
v99 -> (Maybe Term -> Maybe (Maybe Term)
forall a. a -> Maybe a
Optionals.pure Maybe Term
v99)
  Term
_ -> Maybe (Maybe Term)
forall a. Maybe a
Nothing) (Term -> Term
Strip.fullyStripTerm Term
x))

pair :: (Core.Term -> Maybe (Core.Term, Core.Term))
pair :: Term -> Maybe (Term, Term)
pair = ((Term -> Maybe [Term])
-> ([Term] -> Maybe (Term, Term)) -> Term -> Maybe (Term, Term)
forall a b c. (a -> Maybe b) -> (b -> Maybe c) -> a -> Maybe c
Optionals.compose (\Term
x -> (\Term
x -> case Term
x of
  Core.TermProduct [Term]
v100 -> ([Term] -> Maybe [Term]
forall a. a -> Maybe a
Optionals.pure [Term]
v100)
  Term
_ -> Maybe [Term]
forall a. Maybe a
Nothing) (Term -> Term
Strip.fullyStripTerm Term
x)) (\[Term]
l -> Maybe (Term, Term)
-> Maybe (Term, Term) -> Bool -> Maybe (Term, Term)
forall a. a -> a -> Bool -> a
Logic.ifElse ((Term, Term) -> Maybe (Term, Term)
forall a. a -> Maybe a
Just (Int -> [Term] -> Term
forall a. Int -> [a] -> a
Lists.at Int
0 [Term]
l, (Int -> [Term] -> Term
forall a. Int -> [a] -> a
Lists.at Int
1 [Term]
l))) Maybe (Term, Term)
forall a. Maybe a
Nothing (Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
Equality.equal Int
2 ([Term] -> Int
forall a. [a] -> Int
Lists.length [Term]
l))))

record :: (Core.Name -> Core.Term -> Maybe [Core.Field])
record :: Name -> Term -> Maybe [Field]
record = ((Record -> Name)
-> (Record -> [Field])
-> (Term -> Maybe Record)
-> Name
-> Term
-> Maybe [Field]
forall a b c.
(a -> Name) -> (a -> b) -> (c -> Maybe a) -> Name -> c -> Maybe b
nominal Record -> Name
Core.recordTypeName Record -> [Field]
Core.recordFields (\Term
x -> (\Term
x -> case Term
x of
  Core.TermRecord Record
v101 -> (Record -> Maybe Record
forall a. a -> Maybe a
Optionals.pure Record
v101)
  Term
_ -> Maybe Record
forall a. Maybe a
Nothing) (Term -> Term
Strip.fullyStripTerm Term
x)))

set :: (Core.Term -> Maybe (Set Core.Term))
set :: Term -> Maybe (Set Term)
set Term
x = ((\Term
x -> case Term
x of
  Core.TermSet Set Term
v102 -> (Set Term -> Maybe (Set Term)
forall a. a -> Maybe a
Optionals.pure Set Term
v102)
  Term
_ -> Maybe (Set Term)
forall a. Maybe a
Nothing) (Term -> Term
Strip.fullyStripTerm Term
x))

string :: (Core.Term -> Maybe String)
string :: Term -> Maybe String
string = ((Term -> Maybe Literal)
-> (Literal -> Maybe String) -> Term -> Maybe String
forall a b c. (a -> Maybe b) -> (b -> Maybe c) -> a -> Maybe c
Optionals.compose Term -> Maybe Literal
literal Literal -> Maybe String
stringLiteral)

stringLiteral :: (Core.Literal -> Maybe String)
stringLiteral :: Literal -> Maybe String
stringLiteral Literal
x = case Literal
x of
  Core.LiteralString String
v103 -> (String -> Maybe String
forall a. a -> Maybe a
Optionals.pure String
v103)
  Literal
_ -> Maybe String
forall a. Maybe a
Nothing

uint16 :: (Core.Term -> Maybe Int)
uint16 :: Term -> Maybe Int
uint16 = ((Term -> Maybe IntegerValue)
-> (IntegerValue -> Maybe Int) -> Term -> Maybe Int
forall a b c. (a -> Maybe b) -> (b -> Maybe c) -> a -> Maybe c
Optionals.compose ((Term -> Maybe Literal)
-> (Literal -> Maybe IntegerValue) -> Term -> Maybe IntegerValue
forall a b c. (a -> Maybe b) -> (b -> Maybe c) -> a -> Maybe c
Optionals.compose Term -> Maybe Literal
literal Literal -> Maybe IntegerValue
integerLiteral) IntegerValue -> Maybe Int
uint16Value)

uint16Value :: (Core.IntegerValue -> Maybe Int)
uint16Value :: IntegerValue -> Maybe Int
uint16Value IntegerValue
x = case IntegerValue
x of
  Core.IntegerValueUint16 Int
v104 -> (Int -> Maybe Int
forall a. a -> Maybe a
Optionals.pure Int
v104)
  IntegerValue
_ -> Maybe Int
forall a. Maybe a
Nothing

uint32 :: (Core.Term -> Maybe Int64)
uint32 :: Term -> Maybe Int64
uint32 = ((Term -> Maybe IntegerValue)
-> (IntegerValue -> Maybe Int64) -> Term -> Maybe Int64
forall a b c. (a -> Maybe b) -> (b -> Maybe c) -> a -> Maybe c
Optionals.compose ((Term -> Maybe Literal)
-> (Literal -> Maybe IntegerValue) -> Term -> Maybe IntegerValue
forall a b c. (a -> Maybe b) -> (b -> Maybe c) -> a -> Maybe c
Optionals.compose Term -> Maybe Literal
literal Literal -> Maybe IntegerValue
integerLiteral) IntegerValue -> Maybe Int64
uint32Value)

uint32Value :: (Core.IntegerValue -> Maybe Int64)
uint32Value :: IntegerValue -> Maybe Int64
uint32Value IntegerValue
x = case IntegerValue
x of
  Core.IntegerValueUint32 Int64
v105 -> (Int64 -> Maybe Int64
forall a. a -> Maybe a
Optionals.pure Int64
v105)
  IntegerValue
_ -> Maybe Int64
forall a. Maybe a
Nothing

uint64 :: (Core.Term -> Maybe Integer)
uint64 :: Term -> Maybe Integer
uint64 = ((Term -> Maybe IntegerValue)
-> (IntegerValue -> Maybe Integer) -> Term -> Maybe Integer
forall a b c. (a -> Maybe b) -> (b -> Maybe c) -> a -> Maybe c
Optionals.compose ((Term -> Maybe Literal)
-> (Literal -> Maybe IntegerValue) -> Term -> Maybe IntegerValue
forall a b c. (a -> Maybe b) -> (b -> Maybe c) -> a -> Maybe c
Optionals.compose Term -> Maybe Literal
literal Literal -> Maybe IntegerValue
integerLiteral) IntegerValue -> Maybe Integer
uint64Value)

uint64Value :: (Core.IntegerValue -> Maybe Integer)
uint64Value :: IntegerValue -> Maybe Integer
uint64Value IntegerValue
x = case IntegerValue
x of
  Core.IntegerValueUint64 Integer
v106 -> (Integer -> Maybe Integer
forall a. a -> Maybe a
Optionals.pure Integer
v106)
  IntegerValue
_ -> Maybe Integer
forall a. Maybe a
Nothing

uint8 :: (Core.Term -> Maybe Int16)
uint8 :: Term -> Maybe Int16
uint8 = ((Term -> Maybe IntegerValue)
-> (IntegerValue -> Maybe Int16) -> Term -> Maybe Int16
forall a b c. (a -> Maybe b) -> (b -> Maybe c) -> a -> Maybe c
Optionals.compose ((Term -> Maybe Literal)
-> (Literal -> Maybe IntegerValue) -> Term -> Maybe IntegerValue
forall a b c. (a -> Maybe b) -> (b -> Maybe c) -> a -> Maybe c
Optionals.compose Term -> Maybe Literal
literal Literal -> Maybe IntegerValue
integerLiteral) IntegerValue -> Maybe Int16
uint8Value)

uint8Value :: (Core.IntegerValue -> Maybe Int16)
uint8Value :: IntegerValue -> Maybe Int16
uint8Value IntegerValue
x = case IntegerValue
x of
  Core.IntegerValueUint8 Int16
v107 -> (Int16 -> Maybe Int16
forall a. a -> Maybe a
Optionals.pure Int16
v107)
  IntegerValue
_ -> Maybe Int16
forall a. Maybe a
Nothing

unit :: (Core.Term -> Maybe ())
unit :: Term -> Maybe ()
unit Term
term = (([Field] -> ()) -> Maybe [Field] -> Maybe ()
forall a b. (a -> b) -> Maybe a -> Maybe b
Optionals.map (\[Field]
_ -> ()) (Name -> Term -> Maybe [Field]
record (String -> Name
Core.Name String
"hydra/core.Unit") Term
term))

unitVariant :: (Core.Name -> Core.Term -> Maybe Core.Name)
unitVariant :: Name -> Term -> Maybe Name
unitVariant Name
tname Term
term = ((Field -> Name) -> Maybe Field -> Maybe Name
forall a b. (a -> b) -> Maybe a -> Maybe b
Optionals.map Field -> Name
Core.fieldName (Name -> Term -> Maybe Field
variant Name
tname Term
term))

variable :: (Core.Term -> Maybe Core.Name)
variable :: Term -> Maybe Name
variable Term
x = ((\Term
x -> (\Term
x -> case Term
x of
  Core.TermVariable Name
v108 -> (Name -> Maybe Name
forall a. a -> Maybe a
Optionals.pure Name
v108)
  Term
_ -> Maybe Name
forall a. Maybe a
Nothing) (Term -> Term
Strip.fullyStripTerm Term
x)) (Term -> Term
Strip.fullyStripTerm Term
x))

variant :: (Core.Name -> Core.Term -> Maybe Core.Field)
variant :: Name -> Term -> Maybe Field
variant = ((Injection -> Name)
-> (Injection -> Field)
-> (Term -> Maybe Injection)
-> Name
-> Term
-> Maybe Field
forall a b c.
(a -> Name) -> (a -> b) -> (c -> Maybe a) -> Name -> c -> Maybe b
nominal Injection -> Name
Core.injectionTypeName Injection -> Field
Core.injectionField (\Term
x -> (\Term
x -> case Term
x of
  Core.TermUnion Injection
v109 -> (Injection -> Maybe Injection
forall a. a -> Maybe a
Optionals.pure Injection
v109)
  Term
_ -> Maybe Injection
forall a. Maybe a
Nothing) (Term -> Term
Strip.fullyStripTerm Term
x)))

wrap :: (Core.Name -> Core.Term -> Maybe Core.Term)
wrap :: Name -> Term -> Maybe Term
wrap = ((WrappedTerm -> Name)
-> (WrappedTerm -> Term)
-> (Term -> Maybe WrappedTerm)
-> Name
-> Term
-> Maybe Term
forall a b c.
(a -> Name) -> (a -> b) -> (c -> Maybe a) -> Name -> c -> Maybe b
nominal WrappedTerm -> Name
Core.wrappedTermTypeName WrappedTerm -> Term
Core.wrappedTermObject (\Term
x -> (\Term
x -> case Term
x of
  Core.TermWrap WrappedTerm
v110 -> (WrappedTerm -> Maybe WrappedTerm
forall a. a -> Maybe a
Optionals.pure WrappedTerm
v110)
  Term
_ -> Maybe WrappedTerm
forall a. Maybe a
Nothing) (Term -> Term
Strip.fullyStripTerm Term
x)))