{-# LANGUAGE OverloadedStrings #-}

module Hydra.Sources.Libraries where

import Hydra.Kernel
import qualified Hydra.Dsl.Expect as Expect
import Hydra.Dsl.Prims as Prims
import qualified Hydra.Dsl.Terms as Terms
import qualified Hydra.Dsl.Types as Types

import qualified Hydra.Lib.Equality as Equality
import qualified Hydra.Lib.Flows as Flows
import qualified Hydra.Lib.Io as Io
import qualified Hydra.Lib.Lists as Lists
import qualified Hydra.Lib.Literals as Literals
import qualified Hydra.Lib.Logic as Logic
import qualified Hydra.Lib.Maps as Maps
import qualified Hydra.Lib.Math as Math
import qualified Hydra.Lib.Optionals as Optionals
import qualified Hydra.Lib.Sets as Sets
import qualified Hydra.Lib.Strings as Strings

import qualified Data.List as L


_hydra_lib_equality :: Namespace
_hydra_lib_equality :: Namespace
_hydra_lib_equality = String -> Namespace
Namespace String
"hydra/lib/equality"

_equality_equal :: Name
_equality_equal = Namespace -> String -> Name
qname Namespace
_hydra_lib_equality String
"equal" :: Name
_equality_equalBinary :: Name
_equality_equalBinary = Namespace -> String -> Name
qname Namespace
_hydra_lib_equality String
"equalBinary" :: Name
_equality_equalBoolean :: Name
_equality_equalBoolean = Namespace -> String -> Name
qname Namespace
_hydra_lib_equality String
"equalBoolean" :: Name
_equality_equalBigfloat :: Name
_equality_equalBigfloat = Namespace -> String -> Name
qname Namespace
_hydra_lib_equality String
"equalBigfloat" :: Name
_equality_equalFloat32 :: Name
_equality_equalFloat32 = Namespace -> String -> Name
qname Namespace
_hydra_lib_equality String
"equalFloat32" :: Name
_equality_equalFloat64 :: Name
_equality_equalFloat64 = Namespace -> String -> Name
qname Namespace
_hydra_lib_equality String
"equalFloat64" :: Name
_equality_equalBigint :: Name
_equality_equalBigint = Namespace -> String -> Name
qname Namespace
_hydra_lib_equality String
"equalBigint" :: Name
_equality_equalInt8 :: Name
_equality_equalInt8 = Namespace -> String -> Name
qname Namespace
_hydra_lib_equality String
"equalInt8" :: Name
_equality_equalInt16 :: Name
_equality_equalInt16 = Namespace -> String -> Name
qname Namespace
_hydra_lib_equality String
"equalInt16" :: Name
_equality_equalInt32 :: Name
_equality_equalInt32 = Namespace -> String -> Name
qname Namespace
_hydra_lib_equality String
"equalInt32" :: Name
_equality_equalInt64 :: Name
_equality_equalInt64 = Namespace -> String -> Name
qname Namespace
_hydra_lib_equality String
"equalInt64" :: Name
_equality_equalTerm :: Name
_equality_equalTerm = Namespace -> String -> Name
qname Namespace
_hydra_lib_equality String
"equalTerm" :: Name
_equality_equalType :: Name
_equality_equalType = Namespace -> String -> Name
qname Namespace
_hydra_lib_equality String
"equalType" :: Name
_equality_equalUint8 :: Name
_equality_equalUint8 = Namespace -> String -> Name
qname Namespace
_hydra_lib_equality String
"equalUint8" :: Name
_equality_equalUint16 :: Name
_equality_equalUint16 = Namespace -> String -> Name
qname Namespace
_hydra_lib_equality String
"equalUint16" :: Name
_equality_equalUint32 :: Name
_equality_equalUint32 = Namespace -> String -> Name
qname Namespace
_hydra_lib_equality String
"equalUint32" :: Name
_equality_equalUint64 :: Name
_equality_equalUint64 = Namespace -> String -> Name
qname Namespace
_hydra_lib_equality String
"equalUint64" :: Name
_equality_equalString :: Name
_equality_equalString = Namespace -> String -> Name
qname Namespace
_hydra_lib_equality String
"equalString" :: Name
_equality_identity :: Name
_equality_identity = Namespace -> String -> Name
qname Namespace
_hydra_lib_equality String
"identity" :: Name
_equality_gtInt32 :: Name
_equality_gtInt32 = Namespace -> String -> Name
qname Namespace
_hydra_lib_equality String
"gtInt32" :: Name
_equality_gteInt32 :: Name
_equality_gteInt32 = Namespace -> String -> Name
qname Namespace
_hydra_lib_equality String
"gteInt32" :: Name
_equality_ltInt32 :: Name
_equality_ltInt32 = Namespace -> String -> Name
qname Namespace
_hydra_lib_equality String
"ltInt32" :: Name
_equality_lteInt32 :: Name
_equality_lteInt32 = Namespace -> String -> Name
qname Namespace
_hydra_lib_equality String
"lteInt32" :: Name

hydraLibEquality :: Library
hydraLibEquality :: Library
hydraLibEquality = Namespace -> [Primitive] -> Library
standardLibrary Namespace
_hydra_lib_equality [
    [String]
-> Name
-> TermCoder Term
-> TermCoder Term
-> TermCoder Bool
-> (Term -> Term -> Bool)
-> Primitive
forall x y z.
[String]
-> Name
-> TermCoder x
-> TermCoder y
-> TermCoder z
-> (x -> y -> z)
-> Primitive
prim2 [] Name
_equality_equal TermCoder Term
x TermCoder Term
x TermCoder Bool
boolean Term -> Term -> Bool
forall a. Eq a => a -> a -> Bool
Equality.equal,
    [String]
-> Name
-> TermCoder String
-> TermCoder String
-> TermCoder Bool
-> (String -> String -> Bool)
-> Primitive
forall x y z.
[String]
-> Name
-> TermCoder x
-> TermCoder y
-> TermCoder z
-> (x -> y -> z)
-> Primitive
prim2 [] Name
_equality_equalBinary TermCoder String
binary TermCoder String
binary TermCoder Bool
boolean String -> String -> Bool
Equality.equalBinary,
    [String]
-> Name
-> TermCoder Bool
-> TermCoder Bool
-> TermCoder Bool
-> (Bool -> Bool -> Bool)
-> Primitive
forall x y z.
[String]
-> Name
-> TermCoder x
-> TermCoder y
-> TermCoder z
-> (x -> y -> z)
-> Primitive
prim2 [] Name
_equality_equalBoolean TermCoder Bool
boolean TermCoder Bool
boolean TermCoder Bool
boolean Bool -> Bool -> Bool
Equality.equalBoolean,
    [String]
-> Name
-> TermCoder Double
-> TermCoder Double
-> TermCoder Bool
-> (Double -> Double -> Bool)
-> Primitive
forall x y z.
[String]
-> Name
-> TermCoder x
-> TermCoder y
-> TermCoder z
-> (x -> y -> z)
-> Primitive
prim2 [] Name
_equality_equalBigfloat TermCoder Double
bigfloat TermCoder Double
bigfloat TermCoder Bool
boolean Double -> Double -> Bool
Equality.equalBigfloat,
    [String]
-> Name
-> TermCoder Float
-> TermCoder Float
-> TermCoder Bool
-> (Float -> Float -> Bool)
-> Primitive
forall x y z.
[String]
-> Name
-> TermCoder x
-> TermCoder y
-> TermCoder z
-> (x -> y -> z)
-> Primitive
prim2 [] Name
_equality_equalFloat32 TermCoder Float
float32 TermCoder Float
float32 TermCoder Bool
boolean Float -> Float -> Bool
Equality.equalFloat32,
    [String]
-> Name
-> TermCoder Double
-> TermCoder Double
-> TermCoder Bool
-> (Double -> Double -> Bool)
-> Primitive
forall x y z.
[String]
-> Name
-> TermCoder x
-> TermCoder y
-> TermCoder z
-> (x -> y -> z)
-> Primitive
prim2 [] Name
_equality_equalFloat64 TermCoder Double
float64 TermCoder Double
float64 TermCoder Bool
boolean Double -> Double -> Bool
Equality.equalFloat64,
    [String]
-> Name
-> TermCoder Integer
-> TermCoder Integer
-> TermCoder Bool
-> (Integer -> Integer -> Bool)
-> Primitive
forall x y z.
[String]
-> Name
-> TermCoder x
-> TermCoder y
-> TermCoder z
-> (x -> y -> z)
-> Primitive
prim2 [] Name
_equality_equalBigint TermCoder Integer
bigint TermCoder Integer
bigint TermCoder Bool
boolean Integer -> Integer -> Bool
Equality.equalBigint,
    [String]
-> Name
-> TermCoder Int8
-> TermCoder Int8
-> TermCoder Bool
-> (Int8 -> Int8 -> Bool)
-> Primitive
forall x y z.
[String]
-> Name
-> TermCoder x
-> TermCoder y
-> TermCoder z
-> (x -> y -> z)
-> Primitive
prim2 [] Name
_equality_equalInt8 TermCoder Int8
int8 TermCoder Int8
int8 TermCoder Bool
boolean Int8 -> Int8 -> Bool
Equality.equalInt8,
    [String]
-> Name
-> TermCoder Int16
-> TermCoder Int16
-> TermCoder Bool
-> (Int16 -> Int16 -> Bool)
-> Primitive
forall x y z.
[String]
-> Name
-> TermCoder x
-> TermCoder y
-> TermCoder z
-> (x -> y -> z)
-> Primitive
prim2 [] Name
_equality_equalInt16 TermCoder Int16
int16 TermCoder Int16
int16 TermCoder Bool
boolean Int16 -> Int16 -> Bool
Equality.equalInt16,
    [String]
-> Name
-> TermCoder Int
-> TermCoder Int
-> TermCoder Bool
-> (Int -> Int -> Bool)
-> Primitive
forall x y z.
[String]
-> Name
-> TermCoder x
-> TermCoder y
-> TermCoder z
-> (x -> y -> z)
-> Primitive
prim2 [] Name
_equality_equalInt32 TermCoder Int
int32 TermCoder Int
int32 TermCoder Bool
boolean Int -> Int -> Bool
Equality.equalInt32,
    [String]
-> Name
-> TermCoder Int64
-> TermCoder Int64
-> TermCoder Bool
-> (Int64 -> Int64 -> Bool)
-> Primitive
forall x y z.
[String]
-> Name
-> TermCoder x
-> TermCoder y
-> TermCoder z
-> (x -> y -> z)
-> Primitive
prim2 [] Name
_equality_equalInt64 TermCoder Int64
int64 TermCoder Int64
int64 TermCoder Bool
boolean Int64 -> Int64 -> Bool
Equality.equalInt64,
    [String]
-> Name
-> TermCoder Term
-> TermCoder Term
-> TermCoder Bool
-> (Term -> Term -> Bool)
-> Primitive
forall x y z.
[String]
-> Name
-> TermCoder x
-> TermCoder y
-> TermCoder z
-> (x -> y -> z)
-> Primitive
prim2 [] Name
_equality_equalTerm TermCoder Term
term TermCoder Term
term TermCoder Bool
boolean Term -> Term -> Bool
Equality.equalTerm,
    [String]
-> Name
-> TermCoder Type
-> TermCoder Type
-> TermCoder Bool
-> (Type -> Type -> Bool)
-> Primitive
forall x y z.
[String]
-> Name
-> TermCoder x
-> TermCoder y
-> TermCoder z
-> (x -> y -> z)
-> Primitive
prim2 [] Name
_equality_equalType TermCoder Type
type_ TermCoder Type
type_ TermCoder Bool
boolean Type -> Type -> Bool
Equality.equalType,
    [String]
-> Name
-> TermCoder Int16
-> TermCoder Int16
-> TermCoder Bool
-> (Int16 -> Int16 -> Bool)
-> Primitive
forall x y z.
[String]
-> Name
-> TermCoder x
-> TermCoder y
-> TermCoder z
-> (x -> y -> z)
-> Primitive
prim2 [] Name
_equality_equalUint8 TermCoder Int16
uint8 TermCoder Int16
uint8 TermCoder Bool
boolean Int16 -> Int16 -> Bool
Equality.equalUint8,
    [String]
-> Name
-> TermCoder Int
-> TermCoder Int
-> TermCoder Bool
-> (Int -> Int -> Bool)
-> Primitive
forall x y z.
[String]
-> Name
-> TermCoder x
-> TermCoder y
-> TermCoder z
-> (x -> y -> z)
-> Primitive
prim2 [] Name
_equality_equalUint16 TermCoder Int
uint16 TermCoder Int
uint16 TermCoder Bool
boolean Int -> Int -> Bool
Equality.equalUint16,
    [String]
-> Name
-> TermCoder Int64
-> TermCoder Int64
-> TermCoder Bool
-> (Int64 -> Int64 -> Bool)
-> Primitive
forall x y z.
[String]
-> Name
-> TermCoder x
-> TermCoder y
-> TermCoder z
-> (x -> y -> z)
-> Primitive
prim2 [] Name
_equality_equalUint32 TermCoder Int64
uint32 TermCoder Int64
uint32 TermCoder Bool
boolean Int64 -> Int64 -> Bool
Equality.equalUint32,
    [String]
-> Name
-> TermCoder Integer
-> TermCoder Integer
-> TermCoder Bool
-> (Integer -> Integer -> Bool)
-> Primitive
forall x y z.
[String]
-> Name
-> TermCoder x
-> TermCoder y
-> TermCoder z
-> (x -> y -> z)
-> Primitive
prim2 [] Name
_equality_equalUint64 TermCoder Integer
uint64 TermCoder Integer
uint64 TermCoder Bool
boolean Integer -> Integer -> Bool
Equality.equalUint64,
    [String]
-> Name
-> TermCoder String
-> TermCoder String
-> TermCoder Bool
-> (String -> String -> Bool)
-> Primitive
forall x y z.
[String]
-> Name
-> TermCoder x
-> TermCoder y
-> TermCoder z
-> (x -> y -> z)
-> Primitive
prim2 [] Name
_equality_equalString TermCoder String
string TermCoder String
string TermCoder Bool
boolean String -> String -> Bool
Equality.equalString,
    [String]
-> Name
-> TermCoder Term
-> TermCoder Term
-> (Term -> Term)
-> Primitive
forall x y.
[String]
-> Name -> TermCoder x -> TermCoder y -> (x -> y) -> Primitive
prim1 [String
"x"] Name
_equality_identity TermCoder Term
x TermCoder Term
x Term -> Term
forall x. x -> x
Equality.identity,
    [String]
-> Name
-> TermCoder Int
-> TermCoder Int
-> TermCoder Bool
-> (Int -> Int -> Bool)
-> Primitive
forall x y z.
[String]
-> Name
-> TermCoder x
-> TermCoder y
-> TermCoder z
-> (x -> y -> z)
-> Primitive
prim2 [] Name
_equality_gtInt32 TermCoder Int
int32 TermCoder Int
int32 TermCoder Bool
boolean Int -> Int -> Bool
Equality.gtInt32,
    [String]
-> Name
-> TermCoder Int
-> TermCoder Int
-> TermCoder Bool
-> (Int -> Int -> Bool)
-> Primitive
forall x y z.
[String]
-> Name
-> TermCoder x
-> TermCoder y
-> TermCoder z
-> (x -> y -> z)
-> Primitive
prim2 [] Name
_equality_gteInt32 TermCoder Int
int32 TermCoder Int
int32 TermCoder Bool
boolean Int -> Int -> Bool
Equality.gteInt32,
    [String]
-> Name
-> TermCoder Int
-> TermCoder Int
-> TermCoder Bool
-> (Int -> Int -> Bool)
-> Primitive
forall x y z.
[String]
-> Name
-> TermCoder x
-> TermCoder y
-> TermCoder z
-> (x -> y -> z)
-> Primitive
prim2 [] Name
_equality_ltInt32 TermCoder Int
int32 TermCoder Int
int32 TermCoder Bool
boolean Int -> Int -> Bool
Equality.ltInt32,
    [String]
-> Name
-> TermCoder Int
-> TermCoder Int
-> TermCoder Bool
-> (Int -> Int -> Bool)
-> Primitive
forall x y z.
[String]
-> Name
-> TermCoder x
-> TermCoder y
-> TermCoder z
-> (x -> y -> z)
-> Primitive
prim2 [] Name
_equality_lteInt32 TermCoder Int
int32 TermCoder Int
int32 TermCoder Bool
boolean Int -> Int -> Bool
Equality.lteInt32]
  where
    x :: TermCoder Term
x = String -> TermCoder Term
variable String
"x"

_hydra_lib_flows :: Namespace
_hydra_lib_flows :: Namespace
_hydra_lib_flows = String -> Namespace
Namespace String
"hydra/lib/flows"

_flows_apply :: Name
_flows_apply = Namespace -> String -> Name
qname Namespace
_hydra_lib_flows String
"apply" :: Name
_flows_bind :: Name
_flows_bind = Namespace -> String -> Name
qname Namespace
_hydra_lib_flows String
"bind" :: Name
_flows_fail :: Name
_flows_fail = Namespace -> String -> Name
qname Namespace
_hydra_lib_flows String
"fail" :: Name
_flows_map :: Name
_flows_map = Namespace -> String -> Name
qname Namespace
_hydra_lib_flows String
"map" :: Name
_flows_mapList :: Name
_flows_mapList = Namespace -> String -> Name
qname Namespace
_hydra_lib_flows String
"mapList" :: Name
_flows_pure :: Name
_flows_pure = Namespace -> String -> Name
qname Namespace
_hydra_lib_flows String
"pure" :: Name
_flows_sequence :: Name
_flows_sequence = Namespace -> String -> Name
qname Namespace
_hydra_lib_flows String
"sequence" :: Name

hydraLibFlows :: Library
hydraLibFlows :: Library
hydraLibFlows = Namespace -> [Primitive] -> Library
standardLibrary Namespace
_hydra_lib_flows [
    [String]
-> Name
-> TermCoder (Flow Term (Term -> Term))
-> TermCoder (Flow Term Term)
-> TermCoder (Flow Term Term)
-> (Flow Term (Term -> Term) -> Flow Term Term -> Flow Term Term)
-> Primitive
forall x y z.
[String]
-> Name
-> TermCoder x
-> TermCoder y
-> TermCoder z
-> (x -> y -> z)
-> Primitive
prim2 [String
"s", String
"x", String
"y"] Name
_flows_apply (TermCoder Term
-> TermCoder (Term -> Term) -> TermCoder (Flow Term (Term -> Term))
forall s x. TermCoder s -> TermCoder x -> TermCoder (Flow s x)
flow TermCoder Term
s (TermCoder Term -> TermCoder Term -> TermCoder (Term -> Term)
forall x y. TermCoder x -> TermCoder y -> TermCoder (x -> y)
function TermCoder Term
x TermCoder Term
y)) (TermCoder Term -> TermCoder Term -> TermCoder (Flow Term Term)
forall s x. TermCoder s -> TermCoder x -> TermCoder (Flow s x)
flow TermCoder Term
s TermCoder Term
x) (TermCoder Term -> TermCoder Term -> TermCoder (Flow Term Term)
forall s x. TermCoder s -> TermCoder x -> TermCoder (Flow s x)
flow TermCoder Term
s TermCoder Term
y) Flow Term (Term -> Term) -> Flow Term Term -> Flow Term Term
forall s x y. Flow s (x -> y) -> Flow s x -> Flow s y
Flows.apply,
    [String]
-> Name
-> TermCoder (Flow Term Term)
-> TermCoder (Term -> Flow Term Term)
-> TermCoder (Flow Term Term)
-> (Flow Term Term -> (Term -> Flow Term Term) -> Flow Term Term)
-> Primitive
forall x y z.
[String]
-> Name
-> TermCoder x
-> TermCoder y
-> TermCoder z
-> (x -> y -> z)
-> Primitive
prim2 [String
"s", String
"x", String
"y"] Name
_flows_bind  (TermCoder Term -> TermCoder Term -> TermCoder (Flow Term Term)
forall s x. TermCoder s -> TermCoder x -> TermCoder (Flow s x)
flow TermCoder Term
s TermCoder Term
x) (TermCoder Term
-> TermCoder (Flow Term Term) -> TermCoder (Term -> Flow Term Term)
forall x y. TermCoder x -> TermCoder y -> TermCoder (x -> y)
function TermCoder Term
x (TermCoder Term -> TermCoder Term -> TermCoder (Flow Term Term)
forall s x. TermCoder s -> TermCoder x -> TermCoder (Flow s x)
flow TermCoder Term
s TermCoder Term
y)) (TermCoder Term -> TermCoder Term -> TermCoder (Flow Term Term)
forall s x. TermCoder s -> TermCoder x -> TermCoder (Flow s x)
flow TermCoder Term
s TermCoder Term
y) Flow Term Term -> (Term -> Flow Term Term) -> Flow Term Term
forall s x y. Flow s x -> (x -> Flow s y) -> Flow s y
Flows.bind,
    [String]
-> Name
-> TermCoder String
-> TermCoder (Flow Term Term)
-> (String -> Flow Term Term)
-> Primitive
forall x y.
[String]
-> Name -> TermCoder x -> TermCoder y -> (x -> y) -> Primitive
prim1 [String
"s", String
"x"]      Name
_flows_fail  TermCoder String
string (TermCoder Term -> TermCoder Term -> TermCoder (Flow Term Term)
forall s x. TermCoder s -> TermCoder x -> TermCoder (Flow s x)
flow TermCoder Term
s TermCoder Term
x) String -> Flow Term Term
forall s x. String -> Flow s x
Flows.fail,
    [String]
-> Name
-> TermCoder (Term -> Term)
-> TermCoder (Flow Term Term)
-> TermCoder (Flow Term Term)
-> ((Term -> Term) -> Flow Term Term -> Flow Term Term)
-> Primitive
forall x y z.
[String]
-> Name
-> TermCoder x
-> TermCoder y
-> TermCoder z
-> (x -> y -> z)
-> Primitive
prim2 [String
"s", String
"x", String
"y"] Name
_flows_map   (TermCoder Term -> TermCoder Term -> TermCoder (Term -> Term)
forall x y. TermCoder x -> TermCoder y -> TermCoder (x -> y)
function TermCoder Term
x TermCoder Term
y) (TermCoder Term -> TermCoder Term -> TermCoder (Flow Term Term)
forall s x. TermCoder s -> TermCoder x -> TermCoder (Flow s x)
flow TermCoder Term
s TermCoder Term
x) (TermCoder Term -> TermCoder Term -> TermCoder (Flow Term Term)
forall s x. TermCoder s -> TermCoder x -> TermCoder (Flow s x)
flow TermCoder Term
s TermCoder Term
y) (Term -> Term) -> Flow Term Term -> Flow Term Term
forall x y s. (x -> y) -> Flow s x -> Flow s y
Flows.map,
    [String]
-> Name
-> TermCoder (Term -> Flow Term Term)
-> TermCoder [Term]
-> TermCoder (Flow Term [Term])
-> ((Term -> Flow Term Term) -> [Term] -> Flow Term [Term])
-> Primitive
forall x y z.
[String]
-> Name
-> TermCoder x
-> TermCoder y
-> TermCoder z
-> (x -> y -> z)
-> Primitive
prim2 [String
"s", String
"x", String
"y"] Name
_flows_mapList (TermCoder Term
-> TermCoder (Flow Term Term) -> TermCoder (Term -> Flow Term Term)
forall x y. TermCoder x -> TermCoder y -> TermCoder (x -> y)
function TermCoder Term
x (TermCoder Term -> TermCoder Term -> TermCoder (Flow Term Term)
forall s x. TermCoder s -> TermCoder x -> TermCoder (Flow s x)
flow TermCoder Term
s TermCoder Term
y)) (TermCoder Term -> TermCoder [Term]
forall x. TermCoder x -> TermCoder [x]
list TermCoder Term
x) (TermCoder Term -> TermCoder [Term] -> TermCoder (Flow Term [Term])
forall s x. TermCoder s -> TermCoder x -> TermCoder (Flow s x)
flow TermCoder Term
s (TermCoder Term -> TermCoder [Term]
forall x. TermCoder x -> TermCoder [x]
list TermCoder Term
y)) (Term -> Flow Term Term) -> [Term] -> Flow Term [Term]
forall x s y. (x -> Flow s y) -> [x] -> Flow s [y]
Flows.mapList,
    [String]
-> Name
-> TermCoder Term
-> TermCoder (Flow Term Term)
-> (Term -> Flow Term Term)
-> Primitive
forall x y.
[String]
-> Name -> TermCoder x -> TermCoder y -> (x -> y) -> Primitive
prim1 [String
"s", String
"x"]      Name
_flows_pure  TermCoder Term
x (TermCoder Term -> TermCoder Term -> TermCoder (Flow Term Term)
forall s x. TermCoder s -> TermCoder x -> TermCoder (Flow s x)
flow TermCoder Term
s TermCoder Term
x) Term -> Flow Term Term
forall x s. x -> Flow s x
Flows.pure,
    [String]
-> Name
-> TermCoder [Flow Term Term]
-> TermCoder (Flow Term [Term])
-> ([Flow Term Term] -> Flow Term [Term])
-> Primitive
forall x y.
[String]
-> Name -> TermCoder x -> TermCoder y -> (x -> y) -> Primitive
prim1 [String
"s", String
"x"]      Name
_flows_sequence (TermCoder (Flow Term Term) -> TermCoder [Flow Term Term]
forall x. TermCoder x -> TermCoder [x]
list (TermCoder Term -> TermCoder Term -> TermCoder (Flow Term Term)
forall s x. TermCoder s -> TermCoder x -> TermCoder (Flow s x)
flow TermCoder Term
s TermCoder Term
x)) (TermCoder Term -> TermCoder [Term] -> TermCoder (Flow Term [Term])
forall s x. TermCoder s -> TermCoder x -> TermCoder (Flow s x)
flow TermCoder Term
s (TermCoder Term -> TermCoder [Term]
forall x. TermCoder x -> TermCoder [x]
list TermCoder Term
x)) [Flow Term Term] -> Flow Term [Term]
forall s x. [Flow s x] -> Flow s [x]
Flows.sequence]
  where
    s :: TermCoder Term
s = String -> TermCoder Term
variable String
"s"
    x :: TermCoder Term
x = String -> TermCoder Term
variable String
"x"
    y :: TermCoder Term
y = String -> TermCoder Term
variable String
"y"

applyInterp :: Term -> Term -> Flow Graph Term
applyInterp :: Term -> Term -> Flow Graph Term
applyInterp Term
funs' Term
args' = do
    [Term]
funs <- (Term -> Flow Graph Term) -> Term -> Flow Graph [Term]
forall s x. (Term -> Flow s x) -> Term -> Flow s [x]
Expect.list Term -> Flow Graph Term
forall a. a -> Flow Graph a
forall (f :: * -> *) a. Applicative f => a -> f a
Prelude.pure Term
funs'
    [Term]
args <- (Term -> Flow Graph Term) -> Term -> Flow Graph [Term]
forall s x. (Term -> Flow s x) -> Term -> Flow s [x]
Expect.list Term -> Flow Graph Term
forall a. a -> Flow Graph a
forall (f :: * -> *) a. Applicative f => a -> f a
Prelude.pure Term
args'
    Term -> Flow Graph Term
forall a. a -> Flow Graph a
forall (m :: * -> *) a. Monad m => a -> m a
return (Term -> Flow Graph Term) -> Term -> Flow Graph Term
forall a b. (a -> b) -> a -> b
$ [Term] -> Term
Terms.list ([Term] -> Term) -> [Term] -> Term
forall a b. (a -> b) -> a -> b
$ [[Term]] -> [Term]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
L.concat ([Term] -> Term -> [Term]
forall {f :: * -> *}. Functor f => f Term -> Term -> f Term
helper [Term]
args (Term -> [Term]) -> [Term] -> [[Term]]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Term]
funs)
  where
    helper :: f Term -> Term -> f Term
helper f Term
args Term
f = Term -> Term -> Term
Terms.apply Term
f (Term -> Term) -> f Term -> f Term
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> f Term
args

bindInterp :: Term -> Term -> Flow Graph Term
bindInterp :: Term -> Term -> Flow Graph Term
bindInterp Term
args' Term
fun = do
    [Term]
args <- (Term -> Flow Graph Term) -> Term -> Flow Graph [Term]
forall s x. (Term -> Flow s x) -> Term -> Flow s [x]
Expect.list Term -> Flow Graph Term
forall a. a -> Flow Graph a
forall (f :: * -> *) a. Applicative f => a -> f a
Prelude.pure Term
args'
    Term -> Flow Graph Term
forall a. a -> Flow Graph a
forall (m :: * -> *) a. Monad m => a -> m a
return (Term -> Flow Graph Term) -> Term -> Flow Graph Term
forall a b. (a -> b) -> a -> b
$ Term -> Term -> Term
Terms.apply (Name -> Term
Terms.primitive (Name -> Term) -> Name -> Term
forall a b. (a -> b) -> a -> b
$ String -> Name
Name String
"hydra/lib/lists.concat") ([Term] -> Term
Terms.list ([Term] -> Term) -> [Term] -> Term
forall a b. (a -> b) -> a -> b
$ Term -> Term -> Term
Terms.apply Term
fun (Term -> Term) -> [Term] -> [Term]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Term]
args)

mapInterp :: Term -> Term -> Flow Graph Term
mapInterp :: Term -> Term -> Flow Graph Term
mapInterp Term
fun Term
args' = do
    [Term]
args <- (Term -> Flow Graph Term) -> Term -> Flow Graph [Term]
forall s x. (Term -> Flow s x) -> Term -> Flow s [x]
Expect.list Term -> Flow Graph Term
forall a. a -> Flow Graph a
forall (f :: * -> *) a. Applicative f => a -> f a
Prelude.pure Term
args'
    Term -> Flow Graph Term
forall a. a -> Flow Graph a
forall (m :: * -> *) a. Monad m => a -> m a
return (Term -> Flow Graph Term) -> Term -> Flow Graph Term
forall a b. (a -> b) -> a -> b
$ [Term] -> Term
Terms.list (Term -> Term -> Term
Terms.apply Term
fun (Term -> Term) -> [Term] -> [Term]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Term]
args)

_hydra_lib_io :: Namespace
_hydra_lib_io :: Namespace
_hydra_lib_io = String -> Namespace
Namespace String
"hydra/lib/io"

_io_showTerm :: Name
_io_showTerm = Namespace -> String -> Name
qname Namespace
_hydra_lib_io String
"showTerm" :: Name
_io_showType :: Name
_io_showType = Namespace -> String -> Name
qname Namespace
_hydra_lib_io String
"showType" :: Name

hydraLibIo :: Library
hydraLibIo :: Library
hydraLibIo = Namespace -> [Primitive] -> Library
standardLibrary Namespace
_hydra_lib_io [
    [String]
-> Name
-> TermCoder Term
-> TermCoder String
-> (Term -> String)
-> Primitive
forall x y.
[String]
-> Name -> TermCoder x -> TermCoder y -> (x -> y) -> Primitive
prim1 [] Name
_io_showTerm TermCoder Term
term TermCoder String
string Term -> String
Io.showTerm,
    [String]
-> Name
-> TermCoder Type
-> TermCoder String
-> (Type -> String)
-> Primitive
forall x y.
[String]
-> Name -> TermCoder x -> TermCoder y -> (x -> y) -> Primitive
prim1 [] Name
_io_showType TermCoder Type
type_ TermCoder String
string Type -> String
Io.showType]

_hydra_lib_lists :: Namespace
_hydra_lib_lists :: Namespace
_hydra_lib_lists = String -> Namespace
Namespace String
"hydra/lib/lists"

_lists_apply :: Name
_lists_apply = Namespace -> String -> Name
qname Namespace
_hydra_lib_lists String
"apply" :: Name
_lists_at :: Name
_lists_at = Namespace -> String -> Name
qname Namespace
_hydra_lib_lists String
"at" :: Name
_lists_bind :: Name
_lists_bind = Namespace -> String -> Name
qname Namespace
_hydra_lib_lists String
"bind" :: Name
_lists_concat :: Name
_lists_concat = Namespace -> String -> Name
qname Namespace
_hydra_lib_lists String
"concat" :: Name
_lists_concat2 :: Name
_lists_concat2 = Namespace -> String -> Name
qname Namespace
_hydra_lib_lists String
"concat2" :: Name
_lists_cons :: Name
_lists_cons = Namespace -> String -> Name
qname Namespace
_hydra_lib_lists String
"cons" :: Name
_lists_filter :: Name
_lists_filter = Namespace -> String -> Name
qname Namespace
_hydra_lib_lists String
"filter" :: Name
_lists_foldl :: Name
_lists_foldl = Namespace -> String -> Name
qname Namespace
_hydra_lib_lists String
"foldl" :: Name
_lists_head :: Name
_lists_head = Namespace -> String -> Name
qname Namespace
_hydra_lib_lists String
"head" :: Name
_lists_intercalate :: Name
_lists_intercalate = Namespace -> String -> Name
qname Namespace
_hydra_lib_lists String
"intercalate" :: Name
_lists_intersperse :: Name
_lists_intersperse = Namespace -> String -> Name
qname Namespace
_hydra_lib_lists String
"intersperse" :: Name
_lists_last :: Name
_lists_last = Namespace -> String -> Name
qname Namespace
_hydra_lib_lists String
"last" :: Name
_lists_length :: Name
_lists_length = Namespace -> String -> Name
qname Namespace
_hydra_lib_lists String
"length" :: Name
_lists_map :: Name
_lists_map = Namespace -> String -> Name
qname Namespace
_hydra_lib_lists String
"map" :: Name
_lists_nub :: Name
_lists_nub = Namespace -> String -> Name
qname Namespace
_hydra_lib_lists String
"nub" :: Name
_lists_null :: Name
_lists_null = Namespace -> String -> Name
qname Namespace
_hydra_lib_lists String
"null" :: Name
_lists_pure :: Name
_lists_pure = Namespace -> String -> Name
qname Namespace
_hydra_lib_lists String
"pure" :: Name
_lists_reverse :: Name
_lists_reverse = Namespace -> String -> Name
qname Namespace
_hydra_lib_lists String
"reverse" :: Name
_lists_safeHead :: Name
_lists_safeHead = Namespace -> String -> Name
qname Namespace
_hydra_lib_lists String
"safeHead" :: Name
_lists_tail :: Name
_lists_tail = Namespace -> String -> Name
qname Namespace
_hydra_lib_lists String
"tail" :: Name

hydraLibLists :: Library
hydraLibLists :: Library
hydraLibLists = Namespace -> [Primitive] -> Library
standardLibrary Namespace
_hydra_lib_lists [
    [String]
-> Name
-> TermCoder [Term -> Term]
-> TermCoder [Term]
-> TermCoder [Term]
-> (Term -> Term -> Flow Graph Term)
-> Primitive
forall x y z.
[String]
-> Name
-> TermCoder x
-> TermCoder y
-> TermCoder z
-> (Term -> Term -> Flow Graph Term)
-> Primitive
prim2Interp [String
"x", String
"y"] Name
_lists_apply (TermCoder (Term -> Term) -> TermCoder [Term -> Term]
forall x. TermCoder x -> TermCoder [x]
list (TermCoder (Term -> Term) -> TermCoder [Term -> Term])
-> TermCoder (Term -> Term) -> TermCoder [Term -> Term]
forall a b. (a -> b) -> a -> b
$ TermCoder Term -> TermCoder Term -> TermCoder (Term -> Term)
forall x y. TermCoder x -> TermCoder y -> TermCoder (x -> y)
function TermCoder Term
x TermCoder Term
y) (TermCoder Term -> TermCoder [Term]
forall x. TermCoder x -> TermCoder [x]
list TermCoder Term
x) (TermCoder Term -> TermCoder [Term]
forall x. TermCoder x -> TermCoder [x]
list TermCoder Term
y) Term -> Term -> Flow Graph Term
applyInterp,
    [String]
-> Name
-> TermCoder Int
-> TermCoder [Term]
-> TermCoder Term
-> (Int -> [Term] -> Term)
-> Primitive
forall x y z.
[String]
-> Name
-> TermCoder x
-> TermCoder y
-> TermCoder z
-> (x -> y -> z)
-> Primitive
prim2 [String
"x"] Name
_lists_at TermCoder Int
int32 (TermCoder Term -> TermCoder [Term]
forall x. TermCoder x -> TermCoder [x]
list TermCoder Term
x) TermCoder Term
x Int -> [Term] -> Term
forall a. Int -> [a] -> a
Lists.at,
    [String]
-> Name
-> TermCoder [Term]
-> TermCoder (Term -> [Term])
-> TermCoder [Term]
-> (Term -> Term -> Flow Graph Term)
-> Primitive
forall x y z.
[String]
-> Name
-> TermCoder x
-> TermCoder y
-> TermCoder z
-> (Term -> Term -> Flow Graph Term)
-> Primitive
prim2Interp [String
"x", String
"y"] Name
_lists_bind (TermCoder Term -> TermCoder [Term]
forall x. TermCoder x -> TermCoder [x]
list TermCoder Term
x) (TermCoder Term -> TermCoder [Term] -> TermCoder (Term -> [Term])
forall x y. TermCoder x -> TermCoder y -> TermCoder (x -> y)
function TermCoder Term
x (TermCoder Term -> TermCoder [Term]
forall x. TermCoder x -> TermCoder [x]
list TermCoder Term
y)) (TermCoder Term -> TermCoder [Term]
forall x. TermCoder x -> TermCoder [x]
list TermCoder Term
y) Term -> Term -> Flow Graph Term
bindInterp,
    [String]
-> Name
-> TermCoder [[Term]]
-> TermCoder [Term]
-> ([[Term]] -> [Term])
-> Primitive
forall x y.
[String]
-> Name -> TermCoder x -> TermCoder y -> (x -> y) -> Primitive
prim1 [String
"x"] Name
_lists_concat (TermCoder [Term] -> TermCoder [[Term]]
forall x. TermCoder x -> TermCoder [x]
list (TermCoder Term -> TermCoder [Term]
forall x. TermCoder x -> TermCoder [x]
list TermCoder Term
x)) (TermCoder Term -> TermCoder [Term]
forall x. TermCoder x -> TermCoder [x]
list TermCoder Term
x) [[Term]] -> [Term]
forall a. [[a]] -> [a]
Lists.concat,
    [String]
-> Name
-> TermCoder [Term]
-> TermCoder [Term]
-> TermCoder [Term]
-> ([Term] -> [Term] -> [Term])
-> Primitive
forall x y z.
[String]
-> Name
-> TermCoder x
-> TermCoder y
-> TermCoder z
-> (x -> y -> z)
-> Primitive
prim2 [String
"x"] Name
_lists_concat2 (TermCoder Term -> TermCoder [Term]
forall x. TermCoder x -> TermCoder [x]
list TermCoder Term
x) (TermCoder Term -> TermCoder [Term]
forall x. TermCoder x -> TermCoder [x]
list TermCoder Term
x) (TermCoder Term -> TermCoder [Term]
forall x. TermCoder x -> TermCoder [x]
list TermCoder Term
x) [Term] -> [Term] -> [Term]
forall a. [a] -> [a] -> [a]
Lists.concat2,
    [String]
-> Name
-> TermCoder Term
-> TermCoder [Term]
-> TermCoder [Term]
-> (Term -> [Term] -> [Term])
-> Primitive
forall x y z.
[String]
-> Name
-> TermCoder x
-> TermCoder y
-> TermCoder z
-> (x -> y -> z)
-> Primitive
prim2 [String
"x"] Name
_lists_cons TermCoder Term
x (TermCoder Term -> TermCoder [Term]
forall x. TermCoder x -> TermCoder [x]
list TermCoder Term
x) (TermCoder Term -> TermCoder [Term]
forall x. TermCoder x -> TermCoder [x]
list TermCoder Term
x) Term -> [Term] -> [Term]
forall a. a -> [a] -> [a]
Lists.cons,
    [String]
-> Name
-> TermCoder (Term -> Bool)
-> TermCoder [Term]
-> TermCoder [Term]
-> ((Term -> Bool) -> [Term] -> [Term])
-> Primitive
forall x y z.
[String]
-> Name
-> TermCoder x
-> TermCoder y
-> TermCoder z
-> (x -> y -> z)
-> Primitive
prim2 [String
"x"] Name
_lists_filter (TermCoder Term -> TermCoder Bool -> TermCoder (Term -> Bool)
forall x y. TermCoder x -> TermCoder y -> TermCoder (x -> y)
function TermCoder Term
x TermCoder Bool
boolean) (TermCoder Term -> TermCoder [Term]
forall x. TermCoder x -> TermCoder [x]
list TermCoder Term
x) (TermCoder Term -> TermCoder [Term]
forall x. TermCoder x -> TermCoder [x]
list TermCoder Term
x) (Term -> Bool) -> [Term] -> [Term]
forall a. (a -> Bool) -> [a] -> [a]
Lists.filter,
    [String]
-> Name
-> TermCoder (Term -> Term -> Term)
-> TermCoder Term
-> TermCoder [Term]
-> TermCoder Term
-> ((Term -> Term -> Term) -> Term -> [Term] -> Term)
-> Primitive
forall w x y z.
[String]
-> Name
-> TermCoder w
-> TermCoder x
-> TermCoder y
-> TermCoder z
-> (w -> x -> y -> z)
-> Primitive
prim3 [String
"x", String
"y"] Name
_lists_foldl (TermCoder Term
-> TermCoder (Term -> Term) -> TermCoder (Term -> Term -> Term)
forall x y. TermCoder x -> TermCoder y -> TermCoder (x -> y)
function TermCoder Term
y (TermCoder Term -> TermCoder Term -> TermCoder (Term -> Term)
forall x y. TermCoder x -> TermCoder y -> TermCoder (x -> y)
function TermCoder Term
x TermCoder Term
y)) TermCoder Term
y (TermCoder Term -> TermCoder [Term]
forall x. TermCoder x -> TermCoder [x]
list TermCoder Term
x) TermCoder Term
y (Term -> Term -> Term) -> Term -> [Term] -> Term
forall b a. (b -> a -> b) -> b -> [a] -> b
Lists.foldl,
    [String]
-> Name
-> TermCoder [Term]
-> TermCoder Term
-> ([Term] -> Term)
-> Primitive
forall x y.
[String]
-> Name -> TermCoder x -> TermCoder y -> (x -> y) -> Primitive
prim1 [String
"x"] Name
_lists_head (TermCoder Term -> TermCoder [Term]
forall x. TermCoder x -> TermCoder [x]
list TermCoder Term
x) TermCoder Term
x [Term] -> Term
forall a. [a] -> a
Lists.head,
    [String]
-> Name
-> TermCoder [Term]
-> TermCoder [[Term]]
-> TermCoder [Term]
-> ([Term] -> [[Term]] -> [Term])
-> Primitive
forall x y z.
[String]
-> Name
-> TermCoder x
-> TermCoder y
-> TermCoder z
-> (x -> y -> z)
-> Primitive
prim2 [String
"x"] Name
_lists_intercalate (TermCoder Term -> TermCoder [Term]
forall x. TermCoder x -> TermCoder [x]
list TermCoder Term
x) (TermCoder [Term] -> TermCoder [[Term]]
forall x. TermCoder x -> TermCoder [x]
list (TermCoder Term -> TermCoder [Term]
forall x. TermCoder x -> TermCoder [x]
list TermCoder Term
x)) (TermCoder Term -> TermCoder [Term]
forall x. TermCoder x -> TermCoder [x]
list TermCoder Term
x) [Term] -> [[Term]] -> [Term]
forall a. [a] -> [[a]] -> [a]
Lists.intercalate,
    [String]
-> Name
-> TermCoder Term
-> TermCoder [Term]
-> TermCoder [Term]
-> (Term -> [Term] -> [Term])
-> Primitive
forall x y z.
[String]
-> Name
-> TermCoder x
-> TermCoder y
-> TermCoder z
-> (x -> y -> z)
-> Primitive
prim2 [String
"x"] Name
_lists_intersperse TermCoder Term
x (TermCoder Term -> TermCoder [Term]
forall x. TermCoder x -> TermCoder [x]
list TermCoder Term
x) (TermCoder Term -> TermCoder [Term]
forall x. TermCoder x -> TermCoder [x]
list TermCoder Term
x) Term -> [Term] -> [Term]
forall a. a -> [a] -> [a]
Lists.intersperse,
    [String]
-> Name
-> TermCoder [Term]
-> TermCoder Term
-> ([Term] -> Term)
-> Primitive
forall x y.
[String]
-> Name -> TermCoder x -> TermCoder y -> (x -> y) -> Primitive
prim1 [String
"x"] Name
_lists_last (TermCoder Term -> TermCoder [Term]
forall x. TermCoder x -> TermCoder [x]
list TermCoder Term
x) TermCoder Term
x [Term] -> Term
forall a. [a] -> a
Lists.last,
    [String]
-> Name
-> TermCoder [Term]
-> TermCoder Int
-> ([Term] -> Int)
-> Primitive
forall x y.
[String]
-> Name -> TermCoder x -> TermCoder y -> (x -> y) -> Primitive
prim1 [String
"x"] Name
_lists_length (TermCoder Term -> TermCoder [Term]
forall x. TermCoder x -> TermCoder [x]
list TermCoder Term
x) TermCoder Int
int32 [Term] -> Int
forall a. [a] -> Int
Lists.length,
    [String]
-> Name
-> TermCoder (Term -> Term)
-> TermCoder [Term]
-> TermCoder [Term]
-> (Term -> Term -> Flow Graph Term)
-> Primitive
forall x y z.
[String]
-> Name
-> TermCoder x
-> TermCoder y
-> TermCoder z
-> (Term -> Term -> Flow Graph Term)
-> Primitive
prim2Interp [String
"x", String
"y"] Name
_lists_map (TermCoder Term -> TermCoder Term -> TermCoder (Term -> Term)
forall x y. TermCoder x -> TermCoder y -> TermCoder (x -> y)
function TermCoder Term
x TermCoder Term
y) (TermCoder Term -> TermCoder [Term]
forall x. TermCoder x -> TermCoder [x]
list TermCoder Term
x) (TermCoder Term -> TermCoder [Term]
forall x. TermCoder x -> TermCoder [x]
list TermCoder Term
y) Term -> Term -> Flow Graph Term
mapInterp,
    [String]
-> Name
-> TermCoder [Term]
-> TermCoder [Term]
-> ([Term] -> [Term])
-> Primitive
forall x y.
[String]
-> Name -> TermCoder x -> TermCoder y -> (x -> y) -> Primitive
prim1 [String
"x"] Name
_lists_nub (TermCoder Term -> TermCoder [Term]
forall x. TermCoder x -> TermCoder [x]
list TermCoder Term
x) (TermCoder Term -> TermCoder [Term]
forall x. TermCoder x -> TermCoder [x]
list TermCoder Term
x) [Term] -> [Term]
forall a. Eq a => [a] -> [a]
Lists.nub,
    [String]
-> Name
-> TermCoder [Term]
-> TermCoder Bool
-> ([Term] -> Bool)
-> Primitive
forall x y.
[String]
-> Name -> TermCoder x -> TermCoder y -> (x -> y) -> Primitive
prim1 [String
"x"] Name
_lists_null (TermCoder Term -> TermCoder [Term]
forall x. TermCoder x -> TermCoder [x]
list TermCoder Term
x) TermCoder Bool
boolean [Term] -> Bool
forall a. [a] -> Bool
Lists.null,
    [String]
-> Name
-> TermCoder Term
-> TermCoder [Term]
-> (Term -> [Term])
-> Primitive
forall x y.
[String]
-> Name -> TermCoder x -> TermCoder y -> (x -> y) -> Primitive
prim1 [String
"x"] Name
_lists_pure TermCoder Term
x (TermCoder Term -> TermCoder [Term]
forall x. TermCoder x -> TermCoder [x]
list TermCoder Term
x) Term -> [Term]
forall a. a -> [a]
Lists.pure,
    [String]
-> Name
-> TermCoder [Term]
-> TermCoder [Term]
-> ([Term] -> [Term])
-> Primitive
forall x y.
[String]
-> Name -> TermCoder x -> TermCoder y -> (x -> y) -> Primitive
prim1 [String
"x"] Name
_lists_reverse (TermCoder Term -> TermCoder [Term]
forall x. TermCoder x -> TermCoder [x]
list TermCoder Term
x) (TermCoder Term -> TermCoder [Term]
forall x. TermCoder x -> TermCoder [x]
list TermCoder Term
x) [Term] -> [Term]
forall a. [a] -> [a]
Lists.reverse,
    [String]
-> Name
-> TermCoder [Term]
-> TermCoder (Maybe Term)
-> ([Term] -> Maybe Term)
-> Primitive
forall x y.
[String]
-> Name -> TermCoder x -> TermCoder y -> (x -> y) -> Primitive
prim1 [String
"x"] Name
_lists_safeHead (TermCoder Term -> TermCoder [Term]
forall x. TermCoder x -> TermCoder [x]
list TermCoder Term
x) (TermCoder Term -> TermCoder (Maybe Term)
forall x. TermCoder x -> TermCoder (Maybe x)
optional TermCoder Term
x) [Term] -> Maybe Term
forall a. [a] -> Maybe a
Lists.safeHead,
    [String]
-> Name
-> TermCoder [Term]
-> TermCoder [Term]
-> ([Term] -> [Term])
-> Primitive
forall x y.
[String]
-> Name -> TermCoder x -> TermCoder y -> (x -> y) -> Primitive
prim1 [String
"x"] Name
_lists_tail (TermCoder Term -> TermCoder [Term]
forall x. TermCoder x -> TermCoder [x]
list TermCoder Term
x) (TermCoder Term -> TermCoder [Term]
forall x. TermCoder x -> TermCoder [x]
list TermCoder Term
x) [Term] -> [Term]
forall a. [a] -> [a]
Lists.tail]
  where
    x :: TermCoder Term
x = String -> TermCoder Term
variable String
"x"
    y :: TermCoder Term
y = String -> TermCoder Term
variable String
"y"

_hydra_lib_literals :: Namespace
_hydra_lib_literals :: Namespace
_hydra_lib_literals = String -> Namespace
Namespace String
"hydra/lib/literals"

_literals_bigfloatToBigint :: Name
_literals_bigfloatToBigint = Namespace -> String -> Name
qname Namespace
_hydra_lib_literals String
"bigfloatToBigint" :: Name
_literals_bigfloatToFloat32 :: Name
_literals_bigfloatToFloat32 = Namespace -> String -> Name
qname Namespace
_hydra_lib_literals String
"bigfloatToFloat32" :: Name
_literals_bigfloatToFloat64 :: Name
_literals_bigfloatToFloat64 = Namespace -> String -> Name
qname Namespace
_hydra_lib_literals String
"bigfloatToFloat64" :: Name
_literals_bigintToBigfloat :: Name
_literals_bigintToBigfloat = Namespace -> String -> Name
qname Namespace
_hydra_lib_literals String
"bigintToBigfloat" :: Name
_literals_bigintToInt8 :: Name
_literals_bigintToInt8 = Namespace -> String -> Name
qname Namespace
_hydra_lib_literals String
"bigintToInt8" :: Name
_literals_bigintToInt16 :: Name
_literals_bigintToInt16 = Namespace -> String -> Name
qname Namespace
_hydra_lib_literals String
"bigintToInt16" :: Name
_literals_bigintToInt32 :: Name
_literals_bigintToInt32 = Namespace -> String -> Name
qname Namespace
_hydra_lib_literals String
"bigintToInt32" :: Name
_literals_bigintToInt64 :: Name
_literals_bigintToInt64 = Namespace -> String -> Name
qname Namespace
_hydra_lib_literals String
"bigintToInt64" :: Name
_literals_bigintToUint8 :: Name
_literals_bigintToUint8 = Namespace -> String -> Name
qname Namespace
_hydra_lib_literals String
"bigintToUint8" :: Name
_literals_bigintToUint16 :: Name
_literals_bigintToUint16 = Namespace -> String -> Name
qname Namespace
_hydra_lib_literals String
"bigintToUint16" :: Name
_literals_bigintToUint32 :: Name
_literals_bigintToUint32 = Namespace -> String -> Name
qname Namespace
_hydra_lib_literals String
"bigintToUint32" :: Name
_literals_bigintToUint64 :: Name
_literals_bigintToUint64 = Namespace -> String -> Name
qname Namespace
_hydra_lib_literals String
"bigintToUint64" :: Name
_literals_float32ToBigfloat :: Name
_literals_float32ToBigfloat = Namespace -> String -> Name
qname Namespace
_hydra_lib_literals String
"float32ToBigfloat" :: Name
_literals_float64ToBigfloat :: Name
_literals_float64ToBigfloat = Namespace -> String -> Name
qname Namespace
_hydra_lib_literals String
"float64ToBigfloat" :: Name
_literals_int8ToBigint :: Name
_literals_int8ToBigint = Namespace -> String -> Name
qname Namespace
_hydra_lib_literals String
"int8ToBigint" :: Name
_literals_int16ToBigint :: Name
_literals_int16ToBigint = Namespace -> String -> Name
qname Namespace
_hydra_lib_literals String
"int16ToBigint" :: Name
_literals_int32ToBigint :: Name
_literals_int32ToBigint = Namespace -> String -> Name
qname Namespace
_hydra_lib_literals String
"int32ToBigint" :: Name
_literals_int64ToBigint :: Name
_literals_int64ToBigint = Namespace -> String -> Name
qname Namespace
_hydra_lib_literals String
"int64ToBigint" :: Name
_literals_showInt32 :: Name
_literals_showInt32 = Namespace -> String -> Name
qname Namespace
_hydra_lib_literals String
"showInt32" :: Name
_literals_showString :: Name
_literals_showString = Namespace -> String -> Name
qname Namespace
_hydra_lib_literals String
"showString" :: Name
_literals_uint8ToBigint :: Name
_literals_uint8ToBigint = Namespace -> String -> Name
qname Namespace
_hydra_lib_literals String
"uint8ToBigint" :: Name
_literals_uint16ToBigint :: Name
_literals_uint16ToBigint = Namespace -> String -> Name
qname Namespace
_hydra_lib_literals String
"uint16ToBigint" :: Name
_literals_uint32ToBigint :: Name
_literals_uint32ToBigint = Namespace -> String -> Name
qname Namespace
_hydra_lib_literals String
"uint32ToBigint" :: Name
_literals_uint64ToBigint :: Name
_literals_uint64ToBigint = Namespace -> String -> Name
qname Namespace
_hydra_lib_literals String
"uint64ToBigint" :: Name

hydraLibLiterals :: Library
hydraLibLiterals :: Library
hydraLibLiterals = Namespace -> [Primitive] -> Library
standardLibrary Namespace
_hydra_lib_literals [
  [String]
-> Name
-> TermCoder Double
-> TermCoder Integer
-> (Double -> Integer)
-> Primitive
forall x y.
[String]
-> Name -> TermCoder x -> TermCoder y -> (x -> y) -> Primitive
prim1 [] Name
_literals_bigfloatToBigint TermCoder Double
bigfloat TermCoder Integer
bigint Double -> Integer
Literals.bigfloatToBigint,
  [String]
-> Name
-> TermCoder Double
-> TermCoder Float
-> (Double -> Float)
-> Primitive
forall x y.
[String]
-> Name -> TermCoder x -> TermCoder y -> (x -> y) -> Primitive
prim1 [] Name
_literals_bigfloatToFloat32 TermCoder Double
bigfloat TermCoder Float
float32 Double -> Float
Literals.bigfloatToFloat32,
  [String]
-> Name
-> TermCoder Double
-> TermCoder Double
-> (Double -> Double)
-> Primitive
forall x y.
[String]
-> Name -> TermCoder x -> TermCoder y -> (x -> y) -> Primitive
prim1 [] Name
_literals_bigfloatToFloat64 TermCoder Double
bigfloat TermCoder Double
float64 Double -> Double
Literals.bigfloatToFloat64,
  [String]
-> Name
-> TermCoder Integer
-> TermCoder Double
-> (Integer -> Double)
-> Primitive
forall x y.
[String]
-> Name -> TermCoder x -> TermCoder y -> (x -> y) -> Primitive
prim1 [] Name
_literals_bigintToBigfloat TermCoder Integer
bigint TermCoder Double
bigfloat Integer -> Double
Literals.bigintToBigfloat,
  [String]
-> Name
-> TermCoder Integer
-> TermCoder Int8
-> (Integer -> Int8)
-> Primitive
forall x y.
[String]
-> Name -> TermCoder x -> TermCoder y -> (x -> y) -> Primitive
prim1 [] Name
_literals_bigintToInt8 TermCoder Integer
bigint TermCoder Int8
int8 Integer -> Int8
Literals.bigintToInt8,
  [String]
-> Name
-> TermCoder Integer
-> TermCoder Int16
-> (Integer -> Int16)
-> Primitive
forall x y.
[String]
-> Name -> TermCoder x -> TermCoder y -> (x -> y) -> Primitive
prim1 [] Name
_literals_bigintToInt16 TermCoder Integer
bigint TermCoder Int16
int16 Integer -> Int16
Literals.bigintToInt16,
  [String]
-> Name
-> TermCoder Integer
-> TermCoder Int
-> (Integer -> Int)
-> Primitive
forall x y.
[String]
-> Name -> TermCoder x -> TermCoder y -> (x -> y) -> Primitive
prim1 [] Name
_literals_bigintToInt32 TermCoder Integer
bigint TermCoder Int
int32 Integer -> Int
Literals.bigintToInt32,
  [String]
-> Name
-> TermCoder Integer
-> TermCoder Int64
-> (Integer -> Int64)
-> Primitive
forall x y.
[String]
-> Name -> TermCoder x -> TermCoder y -> (x -> y) -> Primitive
prim1 [] Name
_literals_bigintToInt64 TermCoder Integer
bigint TermCoder Int64
int64 Integer -> Int64
Literals.bigintToInt64,
  [String]
-> Name
-> TermCoder Integer
-> TermCoder Int16
-> (Integer -> Int16)
-> Primitive
forall x y.
[String]
-> Name -> TermCoder x -> TermCoder y -> (x -> y) -> Primitive
prim1 [] Name
_literals_bigintToUint8 TermCoder Integer
bigint TermCoder Int16
uint8 Integer -> Int16
Literals.bigintToUint8,
  [String]
-> Name
-> TermCoder Integer
-> TermCoder Int
-> (Integer -> Int)
-> Primitive
forall x y.
[String]
-> Name -> TermCoder x -> TermCoder y -> (x -> y) -> Primitive
prim1 [] Name
_literals_bigintToUint16 TermCoder Integer
bigint TermCoder Int
uint16 Integer -> Int
Literals.bigintToUint16,
  [String]
-> Name
-> TermCoder Integer
-> TermCoder Int64
-> (Integer -> Int64)
-> Primitive
forall x y.
[String]
-> Name -> TermCoder x -> TermCoder y -> (x -> y) -> Primitive
prim1 [] Name
_literals_bigintToUint32 TermCoder Integer
bigint TermCoder Int64
uint32 Integer -> Int64
Literals.bigintToUint32,
  [String]
-> Name
-> TermCoder Integer
-> TermCoder Integer
-> (Integer -> Integer)
-> Primitive
forall x y.
[String]
-> Name -> TermCoder x -> TermCoder y -> (x -> y) -> Primitive
prim1 [] Name
_literals_bigintToUint64 TermCoder Integer
bigint TermCoder Integer
uint64 Integer -> Integer
Literals.bigintToUint64,
  [String]
-> Name
-> TermCoder Float
-> TermCoder Double
-> (Float -> Double)
-> Primitive
forall x y.
[String]
-> Name -> TermCoder x -> TermCoder y -> (x -> y) -> Primitive
prim1 [] Name
_literals_float32ToBigfloat TermCoder Float
float32 TermCoder Double
bigfloat Float -> Double
Literals.float32ToBigfloat,
  [String]
-> Name
-> TermCoder Double
-> TermCoder Double
-> (Double -> Double)
-> Primitive
forall x y.
[String]
-> Name -> TermCoder x -> TermCoder y -> (x -> y) -> Primitive
prim1 [] Name
_literals_float64ToBigfloat TermCoder Double
float64 TermCoder Double
bigfloat Double -> Double
Literals.float64ToBigfloat,
  [String]
-> Name
-> TermCoder Int8
-> TermCoder Integer
-> (Int8 -> Integer)
-> Primitive
forall x y.
[String]
-> Name -> TermCoder x -> TermCoder y -> (x -> y) -> Primitive
prim1 [] Name
_literals_int8ToBigint TermCoder Int8
int8 TermCoder Integer
bigint Int8 -> Integer
Literals.int8ToBigint,
  [String]
-> Name
-> TermCoder Int16
-> TermCoder Integer
-> (Int16 -> Integer)
-> Primitive
forall x y.
[String]
-> Name -> TermCoder x -> TermCoder y -> (x -> y) -> Primitive
prim1 [] Name
_literals_int16ToBigint TermCoder Int16
int16 TermCoder Integer
bigint Int16 -> Integer
Literals.int16ToBigint,
  [String]
-> Name
-> TermCoder Int
-> TermCoder Integer
-> (Int -> Integer)
-> Primitive
forall x y.
[String]
-> Name -> TermCoder x -> TermCoder y -> (x -> y) -> Primitive
prim1 [] Name
_literals_int32ToBigint TermCoder Int
int32 TermCoder Integer
bigint Int -> Integer
Literals.int32ToBigint,
  [String]
-> Name
-> TermCoder Int64
-> TermCoder Integer
-> (Int64 -> Integer)
-> Primitive
forall x y.
[String]
-> Name -> TermCoder x -> TermCoder y -> (x -> y) -> Primitive
prim1 [] Name
_literals_int64ToBigint TermCoder Int64
int64 TermCoder Integer
bigint Int64 -> Integer
Literals.int64ToBigint,
  [String]
-> Name
-> TermCoder Int
-> TermCoder String
-> (Int -> String)
-> Primitive
forall x y.
[String]
-> Name -> TermCoder x -> TermCoder y -> (x -> y) -> Primitive
prim1 [] Name
_literals_showInt32 TermCoder Int
int32 TermCoder String
string Int -> String
Literals.showInt32,
  [String]
-> Name
-> TermCoder String
-> TermCoder String
-> (String -> String)
-> Primitive
forall x y.
[String]
-> Name -> TermCoder x -> TermCoder y -> (x -> y) -> Primitive
prim1 [] Name
_literals_showString TermCoder String
string TermCoder String
string String -> String
Literals.showString,
  [String]
-> Name
-> TermCoder Int16
-> TermCoder Integer
-> (Int16 -> Integer)
-> Primitive
forall x y.
[String]
-> Name -> TermCoder x -> TermCoder y -> (x -> y) -> Primitive
prim1 [] Name
_literals_uint8ToBigint TermCoder Int16
uint8 TermCoder Integer
bigint Int16 -> Integer
Literals.uint8ToBigint,
  [String]
-> Name
-> TermCoder Int
-> TermCoder Integer
-> (Int -> Integer)
-> Primitive
forall x y.
[String]
-> Name -> TermCoder x -> TermCoder y -> (x -> y) -> Primitive
prim1 [] Name
_literals_uint16ToBigint TermCoder Int
uint16 TermCoder Integer
bigint Int -> Integer
Literals.uint16ToBigint,
  [String]
-> Name
-> TermCoder Int64
-> TermCoder Integer
-> (Int64 -> Integer)
-> Primitive
forall x y.
[String]
-> Name -> TermCoder x -> TermCoder y -> (x -> y) -> Primitive
prim1 [] Name
_literals_uint32ToBigint TermCoder Int64
uint32 TermCoder Integer
bigint Int64 -> Integer
Literals.uint32ToBigint,
  [String]
-> Name
-> TermCoder Integer
-> TermCoder Integer
-> (Integer -> Integer)
-> Primitive
forall x y.
[String]
-> Name -> TermCoder x -> TermCoder y -> (x -> y) -> Primitive
prim1 [] Name
_literals_uint64ToBigint TermCoder Integer
uint64 TermCoder Integer
bigint Integer -> Integer
Literals.uint64ToBigint]

_hydra_lib_logic :: Namespace
_hydra_lib_logic :: Namespace
_hydra_lib_logic = String -> Namespace
Namespace String
"hydra/lib/logic"

_logic_and :: Name
_logic_and = Namespace -> String -> Name
qname Namespace
_hydra_lib_logic String
"and" :: Name
_logic_ifElse :: Name
_logic_ifElse = Namespace -> String -> Name
qname Namespace
_hydra_lib_logic String
"ifElse" :: Name
_logic_not :: Name
_logic_not = Namespace -> String -> Name
qname Namespace
_hydra_lib_logic String
"not" :: Name
_logic_or :: Name
_logic_or = Namespace -> String -> Name
qname Namespace
_hydra_lib_logic String
"or" :: Name

hydraLibLogic :: Library
hydraLibLogic :: Library
hydraLibLogic = Namespace -> [Primitive] -> Library
standardLibrary Namespace
_hydra_lib_logic [
    [String]
-> Name
-> TermCoder Bool
-> TermCoder Bool
-> TermCoder Bool
-> (Bool -> Bool -> Bool)
-> Primitive
forall x y z.
[String]
-> Name
-> TermCoder x
-> TermCoder y
-> TermCoder z
-> (x -> y -> z)
-> Primitive
prim2 [] Name
_logic_and TermCoder Bool
boolean TermCoder Bool
boolean TermCoder Bool
boolean Bool -> Bool -> Bool
Logic.and,
    [String]
-> Name
-> TermCoder Term
-> TermCoder Term
-> TermCoder Bool
-> TermCoder Term
-> (Term -> Term -> Bool -> Term)
-> Primitive
forall w x y z.
[String]
-> Name
-> TermCoder w
-> TermCoder x
-> TermCoder y
-> TermCoder z
-> (w -> x -> y -> z)
-> Primitive
prim3 [String
"x"] Name
_logic_ifElse TermCoder Term
x TermCoder Term
x TermCoder Bool
boolean TermCoder Term
x Term -> Term -> Bool -> Term
forall a. a -> a -> Bool -> a
Logic.ifElse,
    [String]
-> Name
-> TermCoder Bool
-> TermCoder Bool
-> (Bool -> Bool)
-> Primitive
forall x y.
[String]
-> Name -> TermCoder x -> TermCoder y -> (x -> y) -> Primitive
prim1 [] Name
_logic_not TermCoder Bool
boolean TermCoder Bool
boolean Bool -> Bool
Logic.not,
    [String]
-> Name
-> TermCoder Bool
-> TermCoder Bool
-> TermCoder Bool
-> (Bool -> Bool -> Bool)
-> Primitive
forall x y z.
[String]
-> Name
-> TermCoder x
-> TermCoder y
-> TermCoder z
-> (x -> y -> z)
-> Primitive
prim2 [] Name
_logic_or TermCoder Bool
boolean TermCoder Bool
boolean TermCoder Bool
boolean Bool -> Bool -> Bool
Logic.or]
  where
    x :: TermCoder Term
x = String -> TermCoder Term
variable String
"x"

_hydra_lib_maps :: Namespace
_hydra_lib_maps :: Namespace
_hydra_lib_maps = String -> Namespace
Namespace String
"hydra/lib/maps"

_maps_empty :: Name
_maps_empty = Namespace -> String -> Name
qname Namespace
_hydra_lib_maps String
"empty" :: Name
_maps_fromList :: Name
_maps_fromList = Namespace -> String -> Name
qname Namespace
_hydra_lib_maps String
"fromList" :: Name
_maps_insert :: Name
_maps_insert = Namespace -> String -> Name
qname Namespace
_hydra_lib_maps String
"insert" :: Name
_maps_isEmpty :: Name
_maps_isEmpty = Namespace -> String -> Name
qname Namespace
_hydra_lib_maps String
"isEmpty" :: Name
_maps_keys :: Name
_maps_keys = Namespace -> String -> Name
qname Namespace
_hydra_lib_maps String
"keys" :: Name
_maps_lookup :: Name
_maps_lookup = Namespace -> String -> Name
qname Namespace
_hydra_lib_maps String
"lookup" :: Name
_maps_map :: Name
_maps_map = Namespace -> String -> Name
qname Namespace
_hydra_lib_maps String
"map" :: Name
_maps_mapKeys :: Name
_maps_mapKeys = Namespace -> String -> Name
qname Namespace
_hydra_lib_maps String
"mapKeys" :: Name
_maps_remove :: Name
_maps_remove = Namespace -> String -> Name
qname Namespace
_hydra_lib_maps String
"remove" :: Name
_maps_singleton :: Name
_maps_singleton = Namespace -> String -> Name
qname Namespace
_hydra_lib_maps String
"singleton" :: Name
_maps_size :: Name
_maps_size = Namespace -> String -> Name
qname Namespace
_hydra_lib_maps String
"size" :: Name
_maps_toList :: Name
_maps_toList = Namespace -> String -> Name
qname Namespace
_hydra_lib_maps String
"toList" :: Name
_maps_values :: Name
_maps_values = Namespace -> String -> Name
qname Namespace
_hydra_lib_maps String
"values" :: Name

hydraLibMaps :: Library
hydraLibMaps :: Library
hydraLibMaps = Namespace -> [Primitive] -> Library
standardLibrary Namespace
_hydra_lib_maps [
    [String]
-> Name -> TermCoder (Map Term Term) -> Map Term Term -> Primitive
forall x. [String] -> Name -> TermCoder x -> x -> Primitive
prim0 [String
"k", String
"v"] Name
_maps_empty TermCoder (Map Term Term)
mapKv Map Term Term
forall k v. Map k v
Maps.empty,
    [String]
-> Name
-> TermCoder [(Term, Term)]
-> TermCoder (Map Term Term)
-> ([(Term, Term)] -> Map Term Term)
-> Primitive
forall x y.
[String]
-> Name -> TermCoder x -> TermCoder y -> (x -> y) -> Primitive
prim1 [String
"k", String
"v"] Name
_maps_fromList (TermCoder (Term, Term) -> TermCoder [(Term, Term)]
forall x. TermCoder x -> TermCoder [x]
list (TermCoder (Term, Term) -> TermCoder [(Term, Term)])
-> TermCoder (Term, Term) -> TermCoder [(Term, Term)]
forall a b. (a -> b) -> a -> b
$ TermCoder Term -> TermCoder Term -> TermCoder (Term, Term)
forall k v. TermCoder k -> TermCoder v -> TermCoder (k, v)
pair TermCoder Term
k TermCoder Term
v) TermCoder (Map Term Term)
mapKv [(Term, Term)] -> Map Term Term
forall k v. Ord k => [(k, v)] -> Map k v
Maps.fromList,
    [String]
-> Name
-> TermCoder Term
-> TermCoder Term
-> TermCoder (Map Term Term)
-> TermCoder (Map Term Term)
-> (Term -> Term -> Map Term Term -> Map Term Term)
-> Primitive
forall w x y z.
[String]
-> Name
-> TermCoder w
-> TermCoder x
-> TermCoder y
-> TermCoder z
-> (w -> x -> y -> z)
-> Primitive
prim3 [String
"k", String
"v"] Name
_maps_insert TermCoder Term
k TermCoder Term
v TermCoder (Map Term Term)
mapKv TermCoder (Map Term Term)
mapKv Term -> Term -> Map Term Term -> Map Term Term
forall k v. Ord k => k -> v -> Map k v -> Map k v
Maps.insert,
    [String]
-> Name
-> TermCoder (Map Term Term)
-> TermCoder Bool
-> (Map Term Term -> Bool)
-> Primitive
forall x y.
[String]
-> Name -> TermCoder x -> TermCoder y -> (x -> y) -> Primitive
prim1 [String
"k", String
"v"] Name
_maps_isEmpty TermCoder (Map Term Term)
mapKv TermCoder Bool
boolean Map Term Term -> Bool
forall k v. Map k v -> Bool
Maps.isEmpty,
    [String]
-> Name
-> TermCoder (Map Term Term)
-> TermCoder [Term]
-> (Map Term Term -> [Term])
-> Primitive
forall x y.
[String]
-> Name -> TermCoder x -> TermCoder y -> (x -> y) -> Primitive
prim1 [String
"k", String
"v"] Name
_maps_keys TermCoder (Map Term Term)
mapKv (TermCoder Term -> TermCoder [Term]
forall x. TermCoder x -> TermCoder [x]
list TermCoder Term
k) Map Term Term -> [Term]
forall k v. Map k v -> [k]
Maps.keys,
    [String]
-> Name
-> TermCoder Term
-> TermCoder (Map Term Term)
-> TermCoder (Maybe Term)
-> (Term -> Map Term Term -> Maybe Term)
-> Primitive
forall x y z.
[String]
-> Name
-> TermCoder x
-> TermCoder y
-> TermCoder z
-> (x -> y -> z)
-> Primitive
prim2 [String
"k", String
"v"] Name
_maps_lookup TermCoder Term
k TermCoder (Map Term Term)
mapKv (TermCoder Term -> TermCoder (Maybe Term)
forall x. TermCoder x -> TermCoder (Maybe x)
optional TermCoder Term
v) Term -> Map Term Term -> Maybe Term
forall k v. Ord k => k -> Map k v -> Maybe v
Maps.lookup,
    [String]
-> Name
-> TermCoder (Term -> Term)
-> TermCoder (Map Term Term)
-> TermCoder (Map Term Term)
-> ((Term -> Term) -> Map Term Term -> Map Term Term)
-> Primitive
forall x y z.
[String]
-> Name
-> TermCoder x
-> TermCoder y
-> TermCoder z
-> (x -> y -> z)
-> Primitive
prim2 [String
"k", String
"v1", String
"v2"] Name
_maps_map (TermCoder Term -> TermCoder Term -> TermCoder (Term -> Term)
forall x y. TermCoder x -> TermCoder y -> TermCoder (x -> y)
function TermCoder Term
v1 TermCoder Term
v2) (TermCoder Term -> TermCoder Term -> TermCoder (Map Term Term)
forall k v.
Ord k =>
TermCoder k -> TermCoder v -> TermCoder (Map k v)
Prims.map TermCoder Term
k TermCoder Term
v1) (TermCoder Term -> TermCoder Term -> TermCoder (Map Term Term)
forall k v.
Ord k =>
TermCoder k -> TermCoder v -> TermCoder (Map k v)
Prims.map TermCoder Term
k TermCoder Term
v2) (Term -> Term) -> Map Term Term -> Map Term Term
forall v1 v2 k. (v1 -> v2) -> Map k v1 -> Map k v2
Maps.map,
    [String]
-> Name
-> TermCoder (Term -> Term)
-> TermCoder (Map Term Term)
-> TermCoder (Map Term Term)
-> ((Term -> Term) -> Map Term Term -> Map Term Term)
-> Primitive
forall x y z.
[String]
-> Name
-> TermCoder x
-> TermCoder y
-> TermCoder z
-> (x -> y -> z)
-> Primitive
prim2 [String
"k1", String
"k2", String
"v"] Name
_maps_mapKeys (TermCoder Term -> TermCoder Term -> TermCoder (Term -> Term)
forall x y. TermCoder x -> TermCoder y -> TermCoder (x -> y)
function TermCoder Term
k1 TermCoder Term
k2) (TermCoder Term -> TermCoder Term -> TermCoder (Map Term Term)
forall k v.
Ord k =>
TermCoder k -> TermCoder v -> TermCoder (Map k v)
Prims.map TermCoder Term
k1 TermCoder Term
v) (TermCoder Term -> TermCoder Term -> TermCoder (Map Term Term)
forall k v.
Ord k =>
TermCoder k -> TermCoder v -> TermCoder (Map k v)
Prims.map TermCoder Term
k2 TermCoder Term
v) (Term -> Term) -> Map Term Term -> Map Term Term
forall k1 k2 v.
(Ord k1, Ord k2) =>
(k1 -> k2) -> Map k1 v -> Map k2 v
Maps.mapKeys,
    [String]
-> Name
-> TermCoder (Map Term Term)
-> TermCoder Int
-> (Map Term Term -> Int)
-> Primitive
forall x y.
[String]
-> Name -> TermCoder x -> TermCoder y -> (x -> y) -> Primitive
prim1 [String
"k", String
"v"] Name
_maps_size TermCoder (Map Term Term)
mapKv TermCoder Int
int32 Map Term Term -> Int
forall k v. Map k v -> Int
Maps.size,
    [String]
-> Name
-> TermCoder Term
-> TermCoder (Map Term Term)
-> TermCoder (Map Term Term)
-> (Term -> Map Term Term -> Map Term Term)
-> Primitive
forall x y z.
[String]
-> Name
-> TermCoder x
-> TermCoder y
-> TermCoder z
-> (x -> y -> z)
-> Primitive
prim2 [String
"k", String
"v"] Name
_maps_remove TermCoder Term
k TermCoder (Map Term Term)
mapKv TermCoder (Map Term Term)
mapKv Term -> Map Term Term -> Map Term Term
forall k v. Ord k => k -> Map k v -> Map k v
Maps.remove,
    [String]
-> Name
-> TermCoder Term
-> TermCoder Term
-> TermCoder (Map Term Term)
-> (Term -> Term -> Map Term Term)
-> Primitive
forall x y z.
[String]
-> Name
-> TermCoder x
-> TermCoder y
-> TermCoder z
-> (x -> y -> z)
-> Primitive
prim2 [String
"k", String
"v"] Name
_maps_singleton TermCoder Term
k TermCoder Term
v TermCoder (Map Term Term)
mapKv Term -> Term -> Map Term Term
forall k v. k -> v -> Map k v
Maps.singleton,
    [String]
-> Name
-> TermCoder (Map Term Term)
-> TermCoder Int
-> (Map Term Term -> Int)
-> Primitive
forall x y.
[String]
-> Name -> TermCoder x -> TermCoder y -> (x -> y) -> Primitive
prim1 [String
"k", String
"v"] Name
_maps_size TermCoder (Map Term Term)
mapKv TermCoder Int
int32 Map Term Term -> Int
forall k v. Map k v -> Int
Maps.size,
    [String]
-> Name
-> TermCoder (Map Term Term)
-> TermCoder [(Term, Term)]
-> (Map Term Term -> [(Term, Term)])
-> Primitive
forall x y.
[String]
-> Name -> TermCoder x -> TermCoder y -> (x -> y) -> Primitive
prim1 [String
"k", String
"v"] Name
_maps_toList TermCoder (Map Term Term)
mapKv (TermCoder (Term, Term) -> TermCoder [(Term, Term)]
forall x. TermCoder x -> TermCoder [x]
list (TermCoder (Term, Term) -> TermCoder [(Term, Term)])
-> TermCoder (Term, Term) -> TermCoder [(Term, Term)]
forall a b. (a -> b) -> a -> b
$ TermCoder Term -> TermCoder Term -> TermCoder (Term, Term)
forall k v. TermCoder k -> TermCoder v -> TermCoder (k, v)
pair TermCoder Term
k TermCoder Term
v) Map Term Term -> [(Term, Term)]
forall k v. Map k v -> [(k, v)]
Maps.toList,
    [String]
-> Name
-> TermCoder (Map Term Term)
-> TermCoder [Term]
-> (Map Term Term -> [Term])
-> Primitive
forall x y.
[String]
-> Name -> TermCoder x -> TermCoder y -> (x -> y) -> Primitive
prim1 [String
"k", String
"v"] Name
_maps_values TermCoder (Map Term Term)
mapKv (TermCoder Term -> TermCoder [Term]
forall x. TermCoder x -> TermCoder [x]
list TermCoder Term
v) Map Term Term -> [Term]
forall k v. Map k v -> [v]
Maps.values]
  where
    k :: TermCoder Term
k = String -> TermCoder Term
variable String
"k"
    k1 :: TermCoder Term
k1 = String -> TermCoder Term
variable String
"k1"
    k2 :: TermCoder Term
k2 = String -> TermCoder Term
variable String
"k2"
    v :: TermCoder Term
v = String -> TermCoder Term
variable String
"v"
    v1 :: TermCoder Term
v1 = String -> TermCoder Term
variable String
"v1"
    v2 :: TermCoder Term
v2 = String -> TermCoder Term
variable String
"v2"
    mapKv :: TermCoder (Map Term Term)
mapKv = TermCoder Term -> TermCoder Term -> TermCoder (Map Term Term)
forall k v.
Ord k =>
TermCoder k -> TermCoder v -> TermCoder (Map k v)
Prims.map TermCoder Term
k TermCoder Term
v

_hydra_lib_math :: Namespace
_hydra_lib_math :: Namespace
_hydra_lib_math = String -> Namespace
Namespace String
"hydra/lib/math"

_math_add :: Name
_math_add = Namespace -> String -> Name
qname Namespace
_hydra_lib_math String
"add" :: Name
_math_div :: Name
_math_div = Namespace -> String -> Name
qname Namespace
_hydra_lib_math String
"div" :: Name
_math_mod :: Name
_math_mod = Namespace -> String -> Name
qname Namespace
_hydra_lib_math String
"mod" :: Name
_math_mul :: Name
_math_mul = Namespace -> String -> Name
qname Namespace
_hydra_lib_math String
"mul" :: Name
_math_neg :: Name
_math_neg = Namespace -> String -> Name
qname Namespace
_hydra_lib_math String
"neg" :: Name
_math_rem :: Name
_math_rem = Namespace -> String -> Name
qname Namespace
_hydra_lib_math String
"rem" :: Name
_math_sub :: Name
_math_sub = Namespace -> String -> Name
qname Namespace
_hydra_lib_math String
"sub" :: Name

hydraLibMathInt32 :: Library
hydraLibMathInt32 :: Library
hydraLibMathInt32 = Namespace -> [Primitive] -> Library
standardLibrary Namespace
_hydra_lib_math [
  [String]
-> Name
-> TermCoder Int
-> TermCoder Int
-> TermCoder Int
-> (Int -> Int -> Int)
-> Primitive
forall x y z.
[String]
-> Name
-> TermCoder x
-> TermCoder y
-> TermCoder z
-> (x -> y -> z)
-> Primitive
prim2 [] Name
_math_add TermCoder Int
int32 TermCoder Int
int32 TermCoder Int
int32 Int -> Int -> Int
Math.add,
  [String]
-> Name
-> TermCoder Int
-> TermCoder Int
-> TermCoder Int
-> (Int -> Int -> Int)
-> Primitive
forall x y z.
[String]
-> Name
-> TermCoder x
-> TermCoder y
-> TermCoder z
-> (x -> y -> z)
-> Primitive
prim2 [] Name
_math_div TermCoder Int
int32 TermCoder Int
int32 TermCoder Int
int32 Int -> Int -> Int
Math.div,
  [String]
-> Name
-> TermCoder Int
-> TermCoder Int
-> TermCoder Int
-> (Int -> Int -> Int)
-> Primitive
forall x y z.
[String]
-> Name
-> TermCoder x
-> TermCoder y
-> TermCoder z
-> (x -> y -> z)
-> Primitive
prim2 [] Name
_math_mod TermCoder Int
int32 TermCoder Int
int32 TermCoder Int
int32 Int -> Int -> Int
Math.mod,
  [String]
-> Name
-> TermCoder Int
-> TermCoder Int
-> TermCoder Int
-> (Int -> Int -> Int)
-> Primitive
forall x y z.
[String]
-> Name
-> TermCoder x
-> TermCoder y
-> TermCoder z
-> (x -> y -> z)
-> Primitive
prim2 [] Name
_math_mul TermCoder Int
int32 TermCoder Int
int32 TermCoder Int
int32 Int -> Int -> Int
Math.mul,
  [String]
-> Name
-> TermCoder Int
-> TermCoder Int
-> (Int -> Int)
-> Primitive
forall x y.
[String]
-> Name -> TermCoder x -> TermCoder y -> (x -> y) -> Primitive
prim1 [] Name
_math_neg TermCoder Int
int32 TermCoder Int
int32 Int -> Int
Math.neg,
  [String]
-> Name
-> TermCoder Int
-> TermCoder Int
-> TermCoder Int
-> (Int -> Int -> Int)
-> Primitive
forall x y z.
[String]
-> Name
-> TermCoder x
-> TermCoder y
-> TermCoder z
-> (x -> y -> z)
-> Primitive
prim2 [] Name
_math_rem TermCoder Int
int32 TermCoder Int
int32 TermCoder Int
int32 Int -> Int -> Int
Math.rem,
  [String]
-> Name
-> TermCoder Int
-> TermCoder Int
-> TermCoder Int
-> (Int -> Int -> Int)
-> Primitive
forall x y z.
[String]
-> Name
-> TermCoder x
-> TermCoder y
-> TermCoder z
-> (x -> y -> z)
-> Primitive
prim2 [] Name
_math_sub TermCoder Int
int32 TermCoder Int
int32 TermCoder Int
int32 Int -> Int -> Int
Math.sub]

_hydra_lib_optionals :: Namespace
_hydra_lib_optionals :: Namespace
_hydra_lib_optionals = String -> Namespace
Namespace String
"hydra/lib/optionals"

_optionals_apply :: Name
_optionals_apply :: Name
_optionals_apply = Namespace -> String -> Name
qname Namespace
_hydra_lib_optionals String
"apply" :: Name
_optionals_bind :: Name
_optionals_bind = Namespace -> String -> Name
qname Namespace
_hydra_lib_optionals String
"bind" :: Name
_optionals_cat :: Name
_optionals_cat = Namespace -> String -> Name
qname Namespace
_hydra_lib_optionals String
"cat" :: Name
_optionals_compose :: Name
_optionals_compose = Namespace -> String -> Name
qname Namespace
_hydra_lib_optionals String
"compose" :: Name
_optionals_fromMaybe :: Name
_optionals_fromMaybe = Namespace -> String -> Name
qname Namespace
_hydra_lib_optionals String
"fromMaybe" :: Name
_optionals_isJust :: Name
_optionals_isJust = Namespace -> String -> Name
qname Namespace
_hydra_lib_optionals String
"isJust" :: Name
_optionals_isNothing :: Name
_optionals_isNothing = Namespace -> String -> Name
qname Namespace
_hydra_lib_optionals String
"isNothing" :: Name
_optionals_map :: Name
_optionals_map = Namespace -> String -> Name
qname Namespace
_hydra_lib_optionals String
"map" :: Name
_optionals_maybe :: Name
_optionals_maybe = Namespace -> String -> Name
qname Namespace
_hydra_lib_optionals String
"maybe" :: Name
_optionals_pure :: Name
_optionals_pure = Namespace -> String -> Name
qname Namespace
_hydra_lib_optionals String
"pure" :: Name

hydraLibOptionals :: Library
hydraLibOptionals :: Library
hydraLibOptionals = Namespace -> [Primitive] -> Library
standardLibrary Namespace
_hydra_lib_optionals [
    [String]
-> Name
-> TermCoder (Maybe (Term -> Term))
-> TermCoder (Maybe Term)
-> TermCoder (Maybe Term)
-> (Maybe (Term -> Term) -> Maybe Term -> Maybe Term)
-> Primitive
forall x y z.
[String]
-> Name
-> TermCoder x
-> TermCoder y
-> TermCoder z
-> (x -> y -> z)
-> Primitive
prim2 [String
"x", String
"y"] Name
_optionals_apply (TermCoder (Term -> Term) -> TermCoder (Maybe (Term -> Term))
forall x. TermCoder x -> TermCoder (Maybe x)
optional (TermCoder (Term -> Term) -> TermCoder (Maybe (Term -> Term)))
-> TermCoder (Term -> Term) -> TermCoder (Maybe (Term -> Term))
forall a b. (a -> b) -> a -> b
$ TermCoder Term -> TermCoder Term -> TermCoder (Term -> Term)
forall x y. TermCoder x -> TermCoder y -> TermCoder (x -> y)
function TermCoder Term
x TermCoder Term
y) (TermCoder Term -> TermCoder (Maybe Term)
forall x. TermCoder x -> TermCoder (Maybe x)
optional TermCoder Term
x) (TermCoder Term -> TermCoder (Maybe Term)
forall x. TermCoder x -> TermCoder (Maybe x)
optional TermCoder Term
y) Maybe (Term -> Term) -> Maybe Term -> Maybe Term
forall a b. Maybe (a -> b) -> Maybe a -> Maybe b
Optionals.apply,
    [String]
-> Name
-> TermCoder (Maybe Term)
-> TermCoder (Term -> Maybe Term)
-> TermCoder (Maybe Term)
-> (Maybe Term -> (Term -> Maybe Term) -> Maybe Term)
-> Primitive
forall x y z.
[String]
-> Name
-> TermCoder x
-> TermCoder y
-> TermCoder z
-> (x -> y -> z)
-> Primitive
prim2 [String
"x", String
"y"] Name
_optionals_bind (TermCoder Term -> TermCoder (Maybe Term)
forall x. TermCoder x -> TermCoder (Maybe x)
optional TermCoder Term
x) (TermCoder Term
-> TermCoder (Maybe Term) -> TermCoder (Term -> Maybe Term)
forall x y. TermCoder x -> TermCoder y -> TermCoder (x -> y)
function TermCoder Term
x (TermCoder Term -> TermCoder (Maybe Term)
forall x. TermCoder x -> TermCoder (Maybe x)
optional TermCoder Term
y)) (TermCoder Term -> TermCoder (Maybe Term)
forall x. TermCoder x -> TermCoder (Maybe x)
optional TermCoder Term
y) Maybe Term -> (Term -> Maybe Term) -> Maybe Term
forall a b. Maybe a -> (a -> Maybe b) -> Maybe b
Optionals.bind,
    [String]
-> Name
-> TermCoder [Maybe Term]
-> TermCoder [Term]
-> ([Maybe Term] -> [Term])
-> Primitive
forall x y.
[String]
-> Name -> TermCoder x -> TermCoder y -> (x -> y) -> Primitive
prim1 [String
"x"] Name
_optionals_cat (TermCoder (Maybe Term) -> TermCoder [Maybe Term]
forall x. TermCoder x -> TermCoder [x]
list (TermCoder (Maybe Term) -> TermCoder [Maybe Term])
-> TermCoder (Maybe Term) -> TermCoder [Maybe Term]
forall a b. (a -> b) -> a -> b
$ TermCoder Term -> TermCoder (Maybe Term)
forall x. TermCoder x -> TermCoder (Maybe x)
optional TermCoder Term
x) (TermCoder Term -> TermCoder [Term]
forall x. TermCoder x -> TermCoder [x]
list TermCoder Term
x) [Maybe Term] -> [Term]
forall a. [Maybe a] -> [a]
Optionals.cat,
    [String]
-> Name
-> TermCoder (Term -> Maybe Term)
-> TermCoder (Term -> Maybe Term)
-> TermCoder (Term -> Maybe Term)
-> ((Term -> Maybe Term)
    -> (Term -> Maybe Term) -> Term -> Maybe Term)
-> Primitive
forall x y z.
[String]
-> Name
-> TermCoder x
-> TermCoder y
-> TermCoder z
-> (x -> y -> z)
-> Primitive
prim2 [String
"x", String
"y", String
"z"] Name
_optionals_compose (TermCoder Term
-> TermCoder (Maybe Term) -> TermCoder (Term -> Maybe Term)
forall x y. TermCoder x -> TermCoder y -> TermCoder (x -> y)
function TermCoder Term
x (TermCoder (Maybe Term) -> TermCoder (Term -> Maybe Term))
-> TermCoder (Maybe Term) -> TermCoder (Term -> Maybe Term)
forall a b. (a -> b) -> a -> b
$ TermCoder Term -> TermCoder (Maybe Term)
forall x. TermCoder x -> TermCoder (Maybe x)
optional TermCoder Term
y) (TermCoder Term
-> TermCoder (Maybe Term) -> TermCoder (Term -> Maybe Term)
forall x y. TermCoder x -> TermCoder y -> TermCoder (x -> y)
function TermCoder Term
y (TermCoder (Maybe Term) -> TermCoder (Term -> Maybe Term))
-> TermCoder (Maybe Term) -> TermCoder (Term -> Maybe Term)
forall a b. (a -> b) -> a -> b
$ TermCoder Term -> TermCoder (Maybe Term)
forall x. TermCoder x -> TermCoder (Maybe x)
optional TermCoder Term
z) (TermCoder Term
-> TermCoder (Maybe Term) -> TermCoder (Term -> Maybe Term)
forall x y. TermCoder x -> TermCoder y -> TermCoder (x -> y)
function TermCoder Term
x (TermCoder (Maybe Term) -> TermCoder (Term -> Maybe Term))
-> TermCoder (Maybe Term) -> TermCoder (Term -> Maybe Term)
forall a b. (a -> b) -> a -> b
$ TermCoder Term -> TermCoder (Maybe Term)
forall x. TermCoder x -> TermCoder (Maybe x)
optional TermCoder Term
z) (Term -> Maybe Term) -> (Term -> Maybe Term) -> Term -> Maybe Term
forall a b c. (a -> Maybe b) -> (b -> Maybe c) -> a -> Maybe c
Optionals.compose,
    [String]
-> Name
-> TermCoder Term
-> TermCoder (Maybe Term)
-> TermCoder Term
-> (Term -> Maybe Term -> Term)
-> Primitive
forall x y z.
[String]
-> Name
-> TermCoder x
-> TermCoder y
-> TermCoder z
-> (x -> y -> z)
-> Primitive
prim2 [String
"x"] Name
_optionals_fromMaybe TermCoder Term
x (TermCoder Term -> TermCoder (Maybe Term)
forall x. TermCoder x -> TermCoder (Maybe x)
optional TermCoder Term
x) TermCoder Term
x Term -> Maybe Term -> Term
forall a. a -> Maybe a -> a
Optionals.fromMaybe,
    [String]
-> Name
-> TermCoder (Maybe Term)
-> TermCoder Bool
-> (Maybe Term -> Bool)
-> Primitive
forall x y.
[String]
-> Name -> TermCoder x -> TermCoder y -> (x -> y) -> Primitive
prim1 [String
"x"] Name
_optionals_isJust (TermCoder Term -> TermCoder (Maybe Term)
forall x. TermCoder x -> TermCoder (Maybe x)
optional TermCoder Term
x) TermCoder Bool
boolean Maybe Term -> Bool
forall a. Maybe a -> Bool
Optionals.isJust,
    [String]
-> Name
-> TermCoder (Maybe Term)
-> TermCoder Bool
-> (Maybe Term -> Bool)
-> Primitive
forall x y.
[String]
-> Name -> TermCoder x -> TermCoder y -> (x -> y) -> Primitive
prim1 [String
"x"] Name
_optionals_isNothing (TermCoder Term -> TermCoder (Maybe Term)
forall x. TermCoder x -> TermCoder (Maybe x)
optional TermCoder Term
x) TermCoder Bool
boolean Maybe Term -> Bool
forall a. Maybe a -> Bool
Optionals.isNothing,
    [String]
-> Name
-> TermCoder (Term -> Term)
-> TermCoder (Maybe Term)
-> TermCoder (Maybe Term)
-> ((Term -> Term) -> Maybe Term -> Maybe Term)
-> Primitive
forall x y z.
[String]
-> Name
-> TermCoder x
-> TermCoder y
-> TermCoder z
-> (x -> y -> z)
-> Primitive
prim2 [String
"x", String
"y"] Name
_optionals_map (TermCoder Term -> TermCoder Term -> TermCoder (Term -> Term)
forall x y. TermCoder x -> TermCoder y -> TermCoder (x -> y)
function TermCoder Term
x TermCoder Term
y) (TermCoder Term -> TermCoder (Maybe Term)
forall x. TermCoder x -> TermCoder (Maybe x)
optional TermCoder Term
x) (TermCoder Term -> TermCoder (Maybe Term)
forall x. TermCoder x -> TermCoder (Maybe x)
optional TermCoder Term
y) (Term -> Term) -> Maybe Term -> Maybe Term
forall a b. (a -> b) -> Maybe a -> Maybe b
Optionals.map,
    [String]
-> Name
-> TermCoder Term
-> TermCoder (Term -> Term)
-> TermCoder (Maybe Term)
-> TermCoder Term
-> (Term -> (Term -> Term) -> Maybe Term -> Term)
-> Primitive
forall w x y z.
[String]
-> Name
-> TermCoder w
-> TermCoder x
-> TermCoder y
-> TermCoder z
-> (w -> x -> y -> z)
-> Primitive
prim3 [String
"x", String
"y"] Name
_optionals_maybe TermCoder Term
y (TermCoder Term -> TermCoder Term -> TermCoder (Term -> Term)
forall x y. TermCoder x -> TermCoder y -> TermCoder (x -> y)
function TermCoder Term
x TermCoder Term
y) (TermCoder Term -> TermCoder (Maybe Term)
forall x. TermCoder x -> TermCoder (Maybe x)
optional TermCoder Term
x) TermCoder Term
y Term -> (Term -> Term) -> Maybe Term -> Term
forall b a. b -> (a -> b) -> Maybe a -> b
Optionals.maybe,
    [String]
-> Name
-> TermCoder Term
-> TermCoder (Maybe Term)
-> (Term -> Maybe Term)
-> Primitive
forall x y.
[String]
-> Name -> TermCoder x -> TermCoder y -> (x -> y) -> Primitive
prim1 [String
"x"] Name
_optionals_pure TermCoder Term
x (TermCoder Term -> TermCoder (Maybe Term)
forall x. TermCoder x -> TermCoder (Maybe x)
optional TermCoder Term
x) Term -> Maybe Term
forall a. a -> Maybe a
Optionals.pure]
  where
    x :: TermCoder Term
x = String -> TermCoder Term
variable String
"x"
    y :: TermCoder Term
y = String -> TermCoder Term
variable String
"y"
    z :: TermCoder Term
z = String -> TermCoder Term
variable String
"z"

_hydra_lib_sets :: Namespace
_hydra_lib_sets :: Namespace
_hydra_lib_sets = String -> Namespace
Namespace String
"hydra/lib/sets"

_sets_insert :: Name
_sets_insert = Namespace -> String -> Name
qname Namespace
_hydra_lib_sets String
"add" :: Name
_sets_contains :: Name
_sets_contains = Namespace -> String -> Name
qname Namespace
_hydra_lib_sets String
"contains" :: Name
_sets_difference :: Name
_sets_difference = Namespace -> String -> Name
qname Namespace
_hydra_lib_sets String
"difference" :: Name
_sets_empty :: Name
_sets_empty = Namespace -> String -> Name
qname Namespace
_hydra_lib_sets String
"empty" :: Name
_sets_fromList :: Name
_sets_fromList = Namespace -> String -> Name
qname Namespace
_hydra_lib_sets String
"fromList" :: Name
_sets_intersection :: Name
_sets_intersection = Namespace -> String -> Name
qname Namespace
_hydra_lib_sets String
"intersection" :: Name
_sets_isEmpty :: Name
_sets_isEmpty = Namespace -> String -> Name
qname Namespace
_hydra_lib_sets String
"isEmpty" :: Name
_sets_map :: Name
_sets_map = Namespace -> String -> Name
qname Namespace
_hydra_lib_sets String
"map" :: Name
_sets_remove :: Name
_sets_remove = Namespace -> String -> Name
qname Namespace
_hydra_lib_sets String
"remove" :: Name
_sets_singleton :: Name
_sets_singleton = Namespace -> String -> Name
qname Namespace
_hydra_lib_sets String
"singleton" :: Name
_sets_size :: Name
_sets_size = Namespace -> String -> Name
qname Namespace
_hydra_lib_sets String
"size" :: Name
_sets_toList :: Name
_sets_toList = Namespace -> String -> Name
qname Namespace
_hydra_lib_sets String
"toList" :: Name
_sets_union :: Name
_sets_union = Namespace -> String -> Name
qname Namespace
_hydra_lib_sets String
"union" :: Name

hydraLibSets :: Library
hydraLibSets :: Library
hydraLibSets = Namespace -> [Primitive] -> Library
standardLibrary Namespace
_hydra_lib_sets [
    [String]
-> Name
-> TermCoder Term
-> TermCoder (Set Term)
-> TermCoder Bool
-> (Term -> Set Term -> Bool)
-> Primitive
forall x y z.
[String]
-> Name
-> TermCoder x
-> TermCoder y
-> TermCoder z
-> (x -> y -> z)
-> Primitive
prim2 [String
"x"] Name
_sets_contains TermCoder Term
x (TermCoder Term -> TermCoder (Set Term)
forall x. Ord x => TermCoder x -> TermCoder (Set x)
set TermCoder Term
x) TermCoder Bool
boolean Term -> Set Term -> Bool
forall x. Ord x => x -> Set x -> Bool
Sets.contains,
    [String]
-> Name
-> TermCoder (Set Term)
-> TermCoder (Set Term)
-> TermCoder (Set Term)
-> (Set Term -> Set Term -> Set Term)
-> Primitive
forall x y z.
[String]
-> Name
-> TermCoder x
-> TermCoder y
-> TermCoder z
-> (x -> y -> z)
-> Primitive
prim2 [String
"x"] Name
_sets_difference (TermCoder Term -> TermCoder (Set Term)
forall x. Ord x => TermCoder x -> TermCoder (Set x)
set TermCoder Term
x) (TermCoder Term -> TermCoder (Set Term)
forall x. Ord x => TermCoder x -> TermCoder (Set x)
set TermCoder Term
x) (TermCoder Term -> TermCoder (Set Term)
forall x. Ord x => TermCoder x -> TermCoder (Set x)
set TermCoder Term
x) Set Term -> Set Term -> Set Term
forall x. Ord x => Set x -> Set x -> Set x
Sets.difference,
    [String] -> Name -> TermCoder (Set Term) -> Set Term -> Primitive
forall x. [String] -> Name -> TermCoder x -> x -> Primitive
prim0 [String
"x"] Name
_sets_empty (TermCoder Term -> TermCoder (Set Term)
forall x. Ord x => TermCoder x -> TermCoder (Set x)
set TermCoder Term
x) Set Term
forall x. Set x
Sets.empty,
    [String]
-> Name
-> TermCoder [Term]
-> TermCoder (Set Term)
-> ([Term] -> Set Term)
-> Primitive
forall x y.
[String]
-> Name -> TermCoder x -> TermCoder y -> (x -> y) -> Primitive
prim1 [String
"x"] Name
_sets_fromList (TermCoder Term -> TermCoder [Term]
forall x. TermCoder x -> TermCoder [x]
list TermCoder Term
x) (TermCoder Term -> TermCoder (Set Term)
forall x. Ord x => TermCoder x -> TermCoder (Set x)
set TermCoder Term
x) [Term] -> Set Term
forall x. Ord x => [x] -> Set x
Sets.fromList,
    [String]
-> Name
-> TermCoder Term
-> TermCoder (Set Term)
-> TermCoder (Set Term)
-> (Term -> Set Term -> Set Term)
-> Primitive
forall x y z.
[String]
-> Name
-> TermCoder x
-> TermCoder y
-> TermCoder z
-> (x -> y -> z)
-> Primitive
prim2 [String
"x"] Name
_sets_insert TermCoder Term
x (TermCoder Term -> TermCoder (Set Term)
forall x. Ord x => TermCoder x -> TermCoder (Set x)
set TermCoder Term
x) (TermCoder Term -> TermCoder (Set Term)
forall x. Ord x => TermCoder x -> TermCoder (Set x)
set TermCoder Term
x) Term -> Set Term -> Set Term
forall x. Ord x => x -> Set x -> Set x
Sets.insert,
    [String]
-> Name
-> TermCoder (Set Term)
-> TermCoder (Set Term)
-> TermCoder (Set Term)
-> (Set Term -> Set Term -> Set Term)
-> Primitive
forall x y z.
[String]
-> Name
-> TermCoder x
-> TermCoder y
-> TermCoder z
-> (x -> y -> z)
-> Primitive
prim2 [String
"x"] Name
_sets_intersection (TermCoder Term -> TermCoder (Set Term)
forall x. Ord x => TermCoder x -> TermCoder (Set x)
set TermCoder Term
x) (TermCoder Term -> TermCoder (Set Term)
forall x. Ord x => TermCoder x -> TermCoder (Set x)
set TermCoder Term
x) (TermCoder Term -> TermCoder (Set Term)
forall x. Ord x => TermCoder x -> TermCoder (Set x)
set TermCoder Term
x) Set Term -> Set Term -> Set Term
forall x. Ord x => Set x -> Set x -> Set x
Sets.intersection,
    [String]
-> Name
-> TermCoder (Set Term)
-> TermCoder Bool
-> (Set Term -> Bool)
-> Primitive
forall x y.
[String]
-> Name -> TermCoder x -> TermCoder y -> (x -> y) -> Primitive
prim1 [String
"x"] Name
_sets_isEmpty (TermCoder Term -> TermCoder (Set Term)
forall x. Ord x => TermCoder x -> TermCoder (Set x)
set TermCoder Term
x) TermCoder Bool
boolean Set Term -> Bool
forall x. Set x -> Bool
Sets.isEmpty,
    [String]
-> Name
-> TermCoder (Term -> Term)
-> TermCoder (Set Term)
-> TermCoder (Set Term)
-> ((Term -> Term) -> Set Term -> Set Term)
-> Primitive
forall x y z.
[String]
-> Name
-> TermCoder x
-> TermCoder y
-> TermCoder z
-> (x -> y -> z)
-> Primitive
prim2 [String
"x", String
"y"] Name
_sets_map (TermCoder Term -> TermCoder Term -> TermCoder (Term -> Term)
forall x y. TermCoder x -> TermCoder y -> TermCoder (x -> y)
function TermCoder Term
x TermCoder Term
y) (TermCoder Term -> TermCoder (Set Term)
forall x. Ord x => TermCoder x -> TermCoder (Set x)
set TermCoder Term
x) (TermCoder Term -> TermCoder (Set Term)
forall x. Ord x => TermCoder x -> TermCoder (Set x)
set TermCoder Term
y) (Term -> Term) -> Set Term -> Set Term
forall y x. Ord y => (x -> y) -> Set x -> Set y
Sets.map,
    [String]
-> Name
-> TermCoder Term
-> TermCoder (Set Term)
-> TermCoder (Set Term)
-> (Term -> Set Term -> Set Term)
-> Primitive
forall x y z.
[String]
-> Name
-> TermCoder x
-> TermCoder y
-> TermCoder z
-> (x -> y -> z)
-> Primitive
prim2 [String
"x"] Name
_sets_remove TermCoder Term
x (TermCoder Term -> TermCoder (Set Term)
forall x. Ord x => TermCoder x -> TermCoder (Set x)
set TermCoder Term
x) (TermCoder Term -> TermCoder (Set Term)
forall x. Ord x => TermCoder x -> TermCoder (Set x)
set TermCoder Term
x) Term -> Set Term -> Set Term
forall x. Ord x => x -> Set x -> Set x
Sets.remove,
    [String]
-> Name
-> TermCoder Term
-> TermCoder (Set Term)
-> (Term -> Set Term)
-> Primitive
forall x y.
[String]
-> Name -> TermCoder x -> TermCoder y -> (x -> y) -> Primitive
prim1 [String
"x"] Name
_sets_singleton TermCoder Term
x (TermCoder Term -> TermCoder (Set Term)
forall x. Ord x => TermCoder x -> TermCoder (Set x)
set TermCoder Term
x) Term -> Set Term
forall x. x -> Set x
Sets.singleton,
    [String]
-> Name
-> TermCoder (Set Term)
-> TermCoder Int
-> (Set Term -> Int)
-> Primitive
forall x y.
[String]
-> Name -> TermCoder x -> TermCoder y -> (x -> y) -> Primitive
prim1 [String
"x"] Name
_sets_size (TermCoder Term -> TermCoder (Set Term)
forall x. Ord x => TermCoder x -> TermCoder (Set x)
set TermCoder Term
x) TermCoder Int
int32 Set Term -> Int
forall x. Set x -> Int
Sets.size,
    [String]
-> Name
-> TermCoder (Set Term)
-> TermCoder [Term]
-> (Set Term -> [Term])
-> Primitive
forall x y.
[String]
-> Name -> TermCoder x -> TermCoder y -> (x -> y) -> Primitive
prim1 [String
"x"] Name
_sets_toList (TermCoder Term -> TermCoder (Set Term)
forall x. Ord x => TermCoder x -> TermCoder (Set x)
set TermCoder Term
x) (TermCoder Term -> TermCoder [Term]
forall x. TermCoder x -> TermCoder [x]
list TermCoder Term
x) Set Term -> [Term]
forall x. Ord x => Set x -> [x]
Sets.toList,
    [String]
-> Name
-> TermCoder (Set Term)
-> TermCoder (Set Term)
-> TermCoder (Set Term)
-> (Set Term -> Set Term -> Set Term)
-> Primitive
forall x y z.
[String]
-> Name
-> TermCoder x
-> TermCoder y
-> TermCoder z
-> (x -> y -> z)
-> Primitive
prim2 [String
"x"] Name
_sets_union (TermCoder Term -> TermCoder (Set Term)
forall x. Ord x => TermCoder x -> TermCoder (Set x)
set TermCoder Term
x) (TermCoder Term -> TermCoder (Set Term)
forall x. Ord x => TermCoder x -> TermCoder (Set x)
set TermCoder Term
x) (TermCoder Term -> TermCoder (Set Term)
forall x. Ord x => TermCoder x -> TermCoder (Set x)
set TermCoder Term
x) Set Term -> Set Term -> Set Term
forall x. Ord x => Set x -> Set x -> Set x
Sets.union]
  where
    x :: TermCoder Term
x = String -> TermCoder Term
variable String
"x"
    y :: TermCoder Term
y = String -> TermCoder Term
variable String
"y"

_hydra_lib_strings :: Namespace
_hydra_lib_strings :: Namespace
_hydra_lib_strings = String -> Namespace
Namespace String
"hydra/lib/strings"

_strings_cat :: Name
_strings_cat = Namespace -> String -> Name
qname Namespace
_hydra_lib_strings String
"cat" :: Name
_strings_cat2 :: Name
_strings_cat2 = Namespace -> String -> Name
qname Namespace
_hydra_lib_strings String
"cat2" :: Name
_strings_fromList :: Name
_strings_fromList = Namespace -> String -> Name
qname Namespace
_hydra_lib_strings String
"fromList" :: Name
_strings_intercalate :: Name
_strings_intercalate = Namespace -> String -> Name
qname Namespace
_hydra_lib_strings String
"intercalate" :: Name
_strings_isEmpty :: Name
_strings_isEmpty = Namespace -> String -> Name
qname Namespace
_hydra_lib_strings String
"isEmpty" :: Name
_strings_length :: Name
_strings_length = Namespace -> String -> Name
qname Namespace
_hydra_lib_strings String
"length" :: Name
_strings_splitOn :: Name
_strings_splitOn = Namespace -> String -> Name
qname Namespace
_hydra_lib_strings String
"splitOn" :: Name
_strings_toList :: Name
_strings_toList = Namespace -> String -> Name
qname Namespace
_hydra_lib_strings String
"toList" :: Name
_strings_toLower :: Name
_strings_toLower = Namespace -> String -> Name
qname Namespace
_hydra_lib_strings String
"toLower" :: Name
_strings_toUpper :: Name
_strings_toUpper = Namespace -> String -> Name
qname Namespace
_hydra_lib_strings String
"toUpper" :: Name

hydraLibStrings :: Library
hydraLibStrings :: Library
hydraLibStrings = Namespace -> [Primitive] -> Library
standardLibrary Namespace
_hydra_lib_strings [
  [String]
-> Name
-> TermCoder [String]
-> TermCoder String
-> ([String] -> String)
-> Primitive
forall x y.
[String]
-> Name -> TermCoder x -> TermCoder y -> (x -> y) -> Primitive
prim1 [] Name
_strings_cat (TermCoder String -> TermCoder [String]
forall x. TermCoder x -> TermCoder [x]
list TermCoder String
string) TermCoder String
string [String] -> String
Strings.cat,
  [String]
-> Name
-> TermCoder String
-> TermCoder String
-> TermCoder String
-> (String -> String -> String)
-> Primitive
forall x y z.
[String]
-> Name
-> TermCoder x
-> TermCoder y
-> TermCoder z
-> (x -> y -> z)
-> Primitive
prim2 [] Name
_strings_cat2 TermCoder String
string TermCoder String
string TermCoder String
string String -> String -> String
Strings.cat2,
  [String]
-> Name
-> TermCoder [Int]
-> TermCoder String
-> ([Int] -> String)
-> Primitive
forall x y.
[String]
-> Name -> TermCoder x -> TermCoder y -> (x -> y) -> Primitive
prim1 [] Name
_strings_fromList (TermCoder Int -> TermCoder [Int]
forall x. TermCoder x -> TermCoder [x]
list TermCoder Int
int32) TermCoder String
string [Int] -> String
Strings.fromList,
  [String]
-> Name
-> TermCoder String
-> TermCoder [String]
-> TermCoder String
-> (String -> [String] -> String)
-> Primitive
forall x y z.
[String]
-> Name
-> TermCoder x
-> TermCoder y
-> TermCoder z
-> (x -> y -> z)
-> Primitive
prim2 [] Name
_strings_intercalate TermCoder String
string (TermCoder String -> TermCoder [String]
forall x. TermCoder x -> TermCoder [x]
list TermCoder String
string) TermCoder String
string String -> [String] -> String
Strings.intercalate,
  [String]
-> Name
-> TermCoder String
-> TermCoder Bool
-> (String -> Bool)
-> Primitive
forall x y.
[String]
-> Name -> TermCoder x -> TermCoder y -> (x -> y) -> Primitive
prim1 [] Name
_strings_isEmpty TermCoder String
string TermCoder Bool
boolean String -> Bool
Strings.isEmpty,
  [String]
-> Name
-> TermCoder String
-> TermCoder Int
-> (String -> Int)
-> Primitive
forall x y.
[String]
-> Name -> TermCoder x -> TermCoder y -> (x -> y) -> Primitive
prim1 [] Name
_strings_length TermCoder String
string TermCoder Int
int32 String -> Int
Strings.length,
  [String]
-> Name
-> TermCoder String
-> TermCoder String
-> TermCoder [String]
-> (String -> String -> [String])
-> Primitive
forall x y z.
[String]
-> Name
-> TermCoder x
-> TermCoder y
-> TermCoder z
-> (x -> y -> z)
-> Primitive
prim2 [] Name
_strings_splitOn TermCoder String
string TermCoder String
string (TermCoder String -> TermCoder [String]
forall x. TermCoder x -> TermCoder [x]
list TermCoder String
string) String -> String -> [String]
Strings.splitOn,
  [String]
-> Name
-> TermCoder String
-> TermCoder [Int]
-> (String -> [Int])
-> Primitive
forall x y.
[String]
-> Name -> TermCoder x -> TermCoder y -> (x -> y) -> Primitive
prim1 [] Name
_strings_toList TermCoder String
string (TermCoder Int -> TermCoder [Int]
forall x. TermCoder x -> TermCoder [x]
list TermCoder Int
int32) String -> [Int]
Strings.toList,
  [String]
-> Name
-> TermCoder String
-> TermCoder String
-> (String -> String)
-> Primitive
forall x y.
[String]
-> Name -> TermCoder x -> TermCoder y -> (x -> y) -> Primitive
prim1 [] Name
_strings_toLower TermCoder String
string TermCoder String
string String -> String
Strings.toLower,
  [String]
-> Name
-> TermCoder String
-> TermCoder String
-> (String -> String)
-> Primitive
forall x y.
[String]
-> Name -> TermCoder x -> TermCoder y -> (x -> y) -> Primitive
prim1 [] Name
_strings_toUpper TermCoder String
string TermCoder String
string String -> String
Strings.toUpper]

standardLibrary :: Namespace -> [Primitive] -> Library
standardLibrary :: Namespace -> [Primitive] -> Library
standardLibrary Namespace
ns [Primitive]
prims = Library {
  libraryNamespace :: Namespace
libraryNamespace = Namespace
ns,
  libraryPrefix :: String
libraryPrefix = Int -> String -> String
forall a. Int -> [a] -> [a]
L.drop (String -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
L.length (String
"hydra/lib/" :: String)) (String -> String) -> String -> String
forall a b. (a -> b) -> a -> b
$ Namespace -> String
unNamespace Namespace
ns,
  libraryPrimitives :: [Primitive]
libraryPrimitives = [Primitive]
prims}

standardLibraries :: [Library]
standardLibraries :: [Library]
standardLibraries = [
  Library
hydraLibEquality,
  Library
hydraLibFlows,
  Library
hydraLibIo,
  Library
hydraLibLists,
  Library
hydraLibLiterals,
  Library
hydraLibLogic,
  Library
hydraLibMaps,
  Library
hydraLibMathInt32,
  Library
hydraLibOptionals,
  Library
hydraLibSets,
  Library
hydraLibStrings]