{-# LANGUAGE FlexibleInstances #-} -- for IsString with nontrivial parameters

-- | A DSL for constructing primitive function definitions
module Hydra.Dsl.Prims where

import Hydra.Compute
import Hydra.Core
import Hydra.Graph
import Hydra.CoreDecoding
import Hydra.CoreEncoding
import qualified Hydra.Dsl.Expect as Expect
import qualified Hydra.Dsl.Terms as Terms
import qualified Hydra.Dsl.Types as Types

import Data.Int
import qualified Data.List as L
import qualified Data.Map as M
import qualified Data.Set as S
import qualified Data.Maybe as Y
import Hydra.Rewriting (removeTermAnnotations)
import Data.String(IsString(..))

instance IsString (TermCoder (Term)) where fromString :: String -> TermCoder Term
fromString = String -> TermCoder Term
variable

bigfloat :: TermCoder Double
bigfloat :: TermCoder Double
bigfloat = Type -> Coder Graph Graph Term Double -> TermCoder Double
forall x. Type -> Coder Graph Graph Term x -> TermCoder x
TermCoder Type
Types.bigfloat (Coder Graph Graph Term Double -> TermCoder Double)
-> Coder Graph Graph Term Double -> TermCoder Double
forall a b. (a -> b) -> a -> b
$ (Term -> Flow Graph Double)
-> (Double -> Flow Graph Term) -> Coder Graph Graph Term Double
forall s1 s2 v1 v2.
(v1 -> Flow s1 v2) -> (v2 -> Flow s2 v1) -> Coder s1 s2 v1 v2
Coder Term -> Flow Graph Double
forall {s}. Term -> Flow s Double
encode Double -> Flow Graph Term
decode
  where
    encode :: Term -> Flow s Double
encode = Term -> Flow s Double
forall {s}. Term -> Flow s Double
Expect.bigfloat
    decode :: Double -> Flow Graph Term
decode = Term -> Flow Graph Term
forall a. a -> Flow Graph a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Term -> Flow Graph Term)
-> (Double -> Term) -> Double -> Flow Graph Term
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Double -> Term
Terms.bigfloat

bigint :: TermCoder Integer
bigint :: TermCoder Integer
bigint = Type -> Coder Graph Graph Term Integer -> TermCoder Integer
forall x. Type -> Coder Graph Graph Term x -> TermCoder x
TermCoder Type
Types.bigint (Coder Graph Graph Term Integer -> TermCoder Integer)
-> Coder Graph Graph Term Integer -> TermCoder Integer
forall a b. (a -> b) -> a -> b
$ (Term -> Flow Graph Integer)
-> (Integer -> Flow Graph Term) -> Coder Graph Graph Term Integer
forall s1 s2 v1 v2.
(v1 -> Flow s1 v2) -> (v2 -> Flow s2 v1) -> Coder s1 s2 v1 v2
Coder Term -> Flow Graph Integer
forall {s}. Term -> Flow s Integer
encode Integer -> Flow Graph Term
decode
  where
    encode :: Term -> Flow s Integer
encode = Term -> Flow s Integer
forall {s}. Term -> Flow s Integer
Expect.bigint
    decode :: Integer -> Flow Graph Term
decode = Term -> Flow Graph Term
forall a. a -> Flow Graph a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Term -> Flow Graph Term)
-> (Integer -> Term) -> Integer -> Flow Graph Term
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Term
Terms.bigint

binary :: TermCoder String
binary :: TermCoder String
binary = Type -> Coder Graph Graph Term String -> TermCoder String
forall x. Type -> Coder Graph Graph Term x -> TermCoder x
TermCoder Type
Types.binary (Coder Graph Graph Term String -> TermCoder String)
-> Coder Graph Graph Term String -> TermCoder String
forall a b. (a -> b) -> a -> b
$ (Term -> Flow Graph String)
-> (String -> Flow Graph Term) -> Coder Graph Graph Term String
forall s1 s2 v1 v2.
(v1 -> Flow s1 v2) -> (v2 -> Flow s2 v1) -> Coder s1 s2 v1 v2
Coder Term -> Flow Graph String
forall {s}. Term -> Flow s String
encode String -> Flow Graph Term
decode
  where
    encode :: Term -> Flow s String
encode = Term -> Flow s String
forall {s}. Term -> Flow s String
Expect.binary
    decode :: String -> Flow Graph Term
decode = Term -> Flow Graph Term
forall a. a -> Flow Graph a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Term -> Flow Graph Term)
-> (String -> Term) -> String -> Flow Graph Term
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Term
Terms.binary

boolean :: TermCoder Bool
boolean :: TermCoder Bool
boolean = Type -> Coder Graph Graph Term Bool -> TermCoder Bool
forall x. Type -> Coder Graph Graph Term x -> TermCoder x
TermCoder Type
Types.boolean (Coder Graph Graph Term Bool -> TermCoder Bool)
-> Coder Graph Graph Term Bool -> TermCoder Bool
forall a b. (a -> b) -> a -> b
$ (Term -> Flow Graph Bool)
-> (Bool -> Flow Graph Term) -> Coder Graph Graph Term Bool
forall s1 s2 v1 v2.
(v1 -> Flow s1 v2) -> (v2 -> Flow s2 v1) -> Coder s1 s2 v1 v2
Coder Term -> Flow Graph Bool
forall {s}. Term -> Flow s Bool
encode Bool -> Flow Graph Term
decode
  where
    encode :: Term -> Flow s Bool
encode = Term -> Flow s Bool
forall {s}. Term -> Flow s Bool
Expect.boolean
    decode :: Bool -> Flow Graph Term
decode = Term -> Flow Graph Term
forall a. a -> Flow Graph a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Term -> Flow Graph Term)
-> (Bool -> Term) -> Bool -> Flow Graph Term
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Term
Terms.boolean

float32 :: TermCoder Float
float32 :: TermCoder Float
float32 = Type -> Coder Graph Graph Term Float -> TermCoder Float
forall x. Type -> Coder Graph Graph Term x -> TermCoder x
TermCoder Type
Types.float32 (Coder Graph Graph Term Float -> TermCoder Float)
-> Coder Graph Graph Term Float -> TermCoder Float
forall a b. (a -> b) -> a -> b
$ (Term -> Flow Graph Float)
-> (Float -> Flow Graph Term) -> Coder Graph Graph Term Float
forall s1 s2 v1 v2.
(v1 -> Flow s1 v2) -> (v2 -> Flow s2 v1) -> Coder s1 s2 v1 v2
Coder Term -> Flow Graph Float
forall {s}. Term -> Flow s Float
encode Float -> Flow Graph Term
decode
  where
    encode :: Term -> Flow s Float
encode = Term -> Flow s Float
forall {s}. Term -> Flow s Float
Expect.float32
    decode :: Float -> Flow Graph Term
decode = Term -> Flow Graph Term
forall a. a -> Flow Graph a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Term -> Flow Graph Term)
-> (Float -> Term) -> Float -> Flow Graph Term
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Float -> Term
Terms.float32

float64 :: TermCoder Double
float64 :: TermCoder Double
float64 = Type -> Coder Graph Graph Term Double -> TermCoder Double
forall x. Type -> Coder Graph Graph Term x -> TermCoder x
TermCoder Type
Types.float64 (Coder Graph Graph Term Double -> TermCoder Double)
-> Coder Graph Graph Term Double -> TermCoder Double
forall a b. (a -> b) -> a -> b
$ (Term -> Flow Graph Double)
-> (Double -> Flow Graph Term) -> Coder Graph Graph Term Double
forall s1 s2 v1 v2.
(v1 -> Flow s1 v2) -> (v2 -> Flow s2 v1) -> Coder s1 s2 v1 v2
Coder Term -> Flow Graph Double
forall {s}. Term -> Flow s Double
encode Double -> Flow Graph Term
decode
  where
    encode :: Term -> Flow s Double
encode = Term -> Flow s Double
forall {s}. Term -> Flow s Double
Expect.float64
    decode :: Double -> Flow Graph Term
decode = Term -> Flow Graph Term
forall a. a -> Flow Graph a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Term -> Flow Graph Term)
-> (Double -> Term) -> Double -> Flow Graph Term
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Double -> Term
Terms.float64

flow :: TermCoder s -> TermCoder x -> TermCoder (Flow s x)
flow :: forall s x. TermCoder s -> TermCoder x -> TermCoder (Flow s x)
flow TermCoder s
states TermCoder x
values = Type -> Coder Graph Graph Term (Flow s x) -> TermCoder (Flow s x)
forall x. Type -> Coder Graph Graph Term x -> TermCoder x
TermCoder (Name -> Type
TypeVariable Name
_Flow Type -> Type -> Type
Types.@@ (TermCoder s -> Type
forall x. TermCoder x -> Type
termCoderType TermCoder s
states) Type -> Type -> Type
Types.@@ (TermCoder x -> Type
forall x. TermCoder x -> Type
termCoderType TermCoder x
values)) (Coder Graph Graph Term (Flow s x) -> TermCoder (Flow s x))
-> Coder Graph Graph Term (Flow s x) -> TermCoder (Flow s x)
forall a b. (a -> b) -> a -> b
$
    (Term -> Flow Graph (Flow s x))
-> (Flow s x -> Flow Graph Term)
-> Coder Graph Graph Term (Flow s x)
forall s1 s2 v1 v2.
(v1 -> Flow s1 v2) -> (v2 -> Flow s2 v1) -> Coder s1 s2 v1 v2
Coder Term -> Flow Graph (Flow s x)
forall {m :: * -> *} {p} {a}. MonadFail m => p -> m a
encode Flow s x -> Flow Graph Term
forall {m :: * -> *} {p} {a}. MonadFail m => p -> m a
decode
  where
    encode :: p -> m a
encode p
_ = String -> m a
forall a. String -> m a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> m a) -> String -> m a
forall a b. (a -> b) -> a -> b
$ String
"cannot currently encode flows from terms"
    decode :: p -> m a
decode p
_ = String -> m a
forall a. String -> m a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> m a) -> String -> m a
forall a b. (a -> b) -> a -> b
$ String
"cannot decode flows to terms"

function :: TermCoder x -> TermCoder y -> TermCoder (x -> y)
function :: forall x y. TermCoder x -> TermCoder y -> TermCoder (x -> y)
function TermCoder x
dom TermCoder y
cod = Type -> Coder Graph Graph Term (x -> y) -> TermCoder (x -> y)
forall x. Type -> Coder Graph Graph Term x -> TermCoder x
TermCoder (Type -> Type -> Type
Types.function (TermCoder x -> Type
forall x. TermCoder x -> Type
termCoderType TermCoder x
dom) (TermCoder y -> Type
forall x. TermCoder x -> Type
termCoderType TermCoder y
cod)) (Coder Graph Graph Term (x -> y) -> TermCoder (x -> y))
-> Coder Graph Graph Term (x -> y) -> TermCoder (x -> y)
forall a b. (a -> b) -> a -> b
$ (Term -> Flow Graph (x -> y))
-> ((x -> y) -> Flow Graph Term) -> Coder Graph Graph Term (x -> y)
forall s1 s2 v1 v2.
(v1 -> Flow s1 v2) -> (v2 -> Flow s2 v1) -> Coder s1 s2 v1 v2
Coder Term -> Flow Graph (x -> y)
forall {m :: * -> *} {p} {a}. MonadFail m => p -> m a
encode (x -> y) -> Flow Graph Term
forall {m :: * -> *} {p} {a}. MonadFail m => p -> m a
decode
  where
    encode :: p -> m a
encode p
term = String -> m a
forall a. String -> m a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> m a) -> String -> m a
forall a b. (a -> b) -> a -> b
$ String
"cannot encode terms to functions"
    decode :: p -> m a
decode p
_ = String -> m a
forall a. String -> m a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> m a) -> String -> m a
forall a b. (a -> b) -> a -> b
$ String
"cannot decode functions to terms"

int8 :: TermCoder Int8
int8 :: TermCoder Int8
int8 = Type -> Coder Graph Graph Term Int8 -> TermCoder Int8
forall x. Type -> Coder Graph Graph Term x -> TermCoder x
TermCoder Type
Types.int8 (Coder Graph Graph Term Int8 -> TermCoder Int8)
-> Coder Graph Graph Term Int8 -> TermCoder Int8
forall a b. (a -> b) -> a -> b
$ (Term -> Flow Graph Int8)
-> (Int8 -> Flow Graph Term) -> Coder Graph Graph Term Int8
forall s1 s2 v1 v2.
(v1 -> Flow s1 v2) -> (v2 -> Flow s2 v1) -> Coder s1 s2 v1 v2
Coder Term -> Flow Graph Int8
forall {s}. Term -> Flow s Int8
encode Int8 -> Flow Graph Term
decode
  where
    encode :: Term -> Flow s Int8
encode = Term -> Flow s Int8
forall {s}. Term -> Flow s Int8
Expect.int8
    decode :: Int8 -> Flow Graph Term
decode = Term -> Flow Graph Term
forall a. a -> Flow Graph a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Term -> Flow Graph Term)
-> (Int8 -> Term) -> Int8 -> Flow Graph Term
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int8 -> Term
Terms.int8

int16 :: TermCoder Int16
int16 :: TermCoder Int16
int16 = Type -> Coder Graph Graph Term Int16 -> TermCoder Int16
forall x. Type -> Coder Graph Graph Term x -> TermCoder x
TermCoder Type
Types.int16 (Coder Graph Graph Term Int16 -> TermCoder Int16)
-> Coder Graph Graph Term Int16 -> TermCoder Int16
forall a b. (a -> b) -> a -> b
$ (Term -> Flow Graph Int16)
-> (Int16 -> Flow Graph Term) -> Coder Graph Graph Term Int16
forall s1 s2 v1 v2.
(v1 -> Flow s1 v2) -> (v2 -> Flow s2 v1) -> Coder s1 s2 v1 v2
Coder Term -> Flow Graph Int16
forall {s}. Term -> Flow s Int16
encode Int16 -> Flow Graph Term
decode
  where
    encode :: Term -> Flow s Int16
encode = Term -> Flow s Int16
forall {s}. Term -> Flow s Int16
Expect.int16
    decode :: Int16 -> Flow Graph Term
decode = Term -> Flow Graph Term
forall a. a -> Flow Graph a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Term -> Flow Graph Term)
-> (Int16 -> Term) -> Int16 -> Flow Graph Term
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int16 -> Term
Terms.int16

int32 :: TermCoder Int
int32 :: TermCoder Int
int32 = Type -> Coder Graph Graph Term Int -> TermCoder Int
forall x. Type -> Coder Graph Graph Term x -> TermCoder x
TermCoder Type
Types.int32 (Coder Graph Graph Term Int -> TermCoder Int)
-> Coder Graph Graph Term Int -> TermCoder Int
forall a b. (a -> b) -> a -> b
$ (Term -> Flow Graph Int)
-> (Int -> Flow Graph Term) -> Coder Graph Graph Term Int
forall s1 s2 v1 v2.
(v1 -> Flow s1 v2) -> (v2 -> Flow s2 v1) -> Coder s1 s2 v1 v2
Coder Term -> Flow Graph Int
forall {s}. Term -> Flow s Int
encode Int -> Flow Graph Term
decode
  where
    encode :: Term -> Flow s Int
encode = Term -> Flow s Int
forall {s}. Term -> Flow s Int
Expect.int32
    decode :: Int -> Flow Graph Term
decode = Term -> Flow Graph Term
forall a. a -> Flow Graph a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Term -> Flow Graph Term)
-> (Int -> Term) -> Int -> Flow Graph Term
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Term
Terms.int32

int64 :: TermCoder Int64
int64 :: TermCoder Int64
int64 = Type -> Coder Graph Graph Term Int64 -> TermCoder Int64
forall x. Type -> Coder Graph Graph Term x -> TermCoder x
TermCoder Type
Types.int64 (Coder Graph Graph Term Int64 -> TermCoder Int64)
-> Coder Graph Graph Term Int64 -> TermCoder Int64
forall a b. (a -> b) -> a -> b
$ (Term -> Flow Graph Int64)
-> (Int64 -> Flow Graph Term) -> Coder Graph Graph Term Int64
forall s1 s2 v1 v2.
(v1 -> Flow s1 v2) -> (v2 -> Flow s2 v1) -> Coder s1 s2 v1 v2
Coder Term -> Flow Graph Int64
forall {s}. Term -> Flow s Int64
encode Int64 -> Flow Graph Term
decode
  where
    encode :: Term -> Flow s Int64
encode = Term -> Flow s Int64
forall {s}. Term -> Flow s Int64
Expect.int64
    decode :: Int64 -> Flow Graph Term
decode = Term -> Flow Graph Term
forall a. a -> Flow Graph a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Term -> Flow Graph Term)
-> (Int64 -> Term) -> Int64 -> Flow Graph Term
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int64 -> Term
Terms.int64

list :: TermCoder x -> TermCoder [x]
list :: forall x. TermCoder x -> TermCoder [x]
list TermCoder x
els = Type -> Coder Graph Graph Term [x] -> TermCoder [x]
forall x. Type -> Coder Graph Graph Term x -> TermCoder x
TermCoder (Type -> Type
Types.list (Type -> Type) -> Type -> Type
forall a b. (a -> b) -> a -> b
$ TermCoder x -> Type
forall x. TermCoder x -> Type
termCoderType TermCoder x
els) (Coder Graph Graph Term [x] -> TermCoder [x])
-> Coder Graph Graph Term [x] -> TermCoder [x]
forall a b. (a -> b) -> a -> b
$ (Term -> Flow Graph [x])
-> ([x] -> Flow Graph Term) -> Coder Graph Graph Term [x]
forall s1 s2 v1 v2.
(v1 -> Flow s1 v2) -> (v2 -> Flow s2 v1) -> Coder s1 s2 v1 v2
Coder Term -> Flow Graph [x]
encode [x] -> Flow Graph Term
decode
  where
    encode :: Term -> Flow Graph [x]
encode = (Term -> Flow Graph x) -> Term -> Flow Graph [x]
forall s x. (Term -> Flow s x) -> Term -> Flow s [x]
Expect.list (Coder Graph Graph Term x -> Term -> Flow Graph x
forall s1 s2 v1 v2. Coder s1 s2 v1 v2 -> v1 -> Flow s1 v2
coderEncode (Coder Graph Graph Term x -> Term -> Flow Graph x)
-> Coder Graph Graph Term x -> Term -> Flow Graph x
forall a b. (a -> b) -> a -> b
$ TermCoder x -> Coder Graph Graph Term x
forall x. TermCoder x -> Coder Graph Graph Term x
termCoderCoder TermCoder x
els)
    decode :: [x] -> Flow Graph Term
decode [x]
l = [Term] -> Term
Terms.list ([Term] -> Term) -> Flow Graph [Term] -> Flow Graph Term
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (x -> Flow Graph Term) -> [x] -> Flow Graph [Term]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM (Coder Graph Graph Term x -> x -> Flow Graph Term
forall s1 s2 v1 v2. Coder s1 s2 v1 v2 -> v2 -> Flow s2 v1
coderDecode (Coder Graph Graph Term x -> x -> Flow Graph Term)
-> Coder Graph Graph Term x -> x -> Flow Graph Term
forall a b. (a -> b) -> a -> b
$ TermCoder x -> Coder Graph Graph Term x
forall x. TermCoder x -> Coder Graph Graph Term x
termCoderCoder TermCoder x
els) [x]
l

map :: Ord k => TermCoder k -> TermCoder v -> TermCoder (M.Map k v)
map :: forall k v.
Ord k =>
TermCoder k -> TermCoder v -> TermCoder (Map k v)
map TermCoder k
keys TermCoder v
values = Type -> Coder Graph Graph Term (Map k v) -> TermCoder (Map k v)
forall x. Type -> Coder Graph Graph Term x -> TermCoder x
TermCoder (Type -> Type -> Type
Types.map (TermCoder k -> Type
forall x. TermCoder x -> Type
termCoderType TermCoder k
keys) (TermCoder v -> Type
forall x. TermCoder x -> Type
termCoderType TermCoder v
values)) (Coder Graph Graph Term (Map k v) -> TermCoder (Map k v))
-> Coder Graph Graph Term (Map k v) -> TermCoder (Map k v)
forall a b. (a -> b) -> a -> b
$ (Term -> Flow Graph (Map k v))
-> (Map k v -> Flow Graph Term) -> Coder Graph Graph Term (Map k v)
forall s1 s2 v1 v2.
(v1 -> Flow s1 v2) -> (v2 -> Flow s2 v1) -> Coder s1 s2 v1 v2
Coder Term -> Flow Graph (Map k v)
encode Map k v -> Flow Graph Term
decode
  where
    encode :: Term -> Flow Graph (Map k v)
encode = (Term -> Flow Graph k)
-> (Term -> Flow Graph v) -> Term -> Flow Graph (Map k v)
forall k s v.
Ord k =>
(Term -> Flow s k)
-> (Term -> Flow s v) -> Term -> Flow s (Map k v)
Expect.map (Coder Graph Graph Term k -> Term -> Flow Graph k
forall s1 s2 v1 v2. Coder s1 s2 v1 v2 -> v1 -> Flow s1 v2
coderEncode (Coder Graph Graph Term k -> Term -> Flow Graph k)
-> Coder Graph Graph Term k -> Term -> Flow Graph k
forall a b. (a -> b) -> a -> b
$ TermCoder k -> Coder Graph Graph Term k
forall x. TermCoder x -> Coder Graph Graph Term x
termCoderCoder TermCoder k
keys) (Coder Graph Graph Term v -> Term -> Flow Graph v
forall s1 s2 v1 v2. Coder s1 s2 v1 v2 -> v1 -> Flow s1 v2
coderEncode (Coder Graph Graph Term v -> Term -> Flow Graph v)
-> Coder Graph Graph Term v -> Term -> Flow Graph v
forall a b. (a -> b) -> a -> b
$ TermCoder v -> Coder Graph Graph Term v
forall x. TermCoder x -> Coder Graph Graph Term x
termCoderCoder TermCoder v
values)
    decode :: Map k v -> Flow Graph Term
decode Map k v
m = Map Term Term -> Term
Terms.map (Map Term Term -> Term)
-> ([(Term, Term)] -> Map Term Term) -> [(Term, Term)] -> Term
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [(Term, Term)] -> Map Term Term
forall k a. Ord k => [(k, a)] -> Map k a
M.fromList ([(Term, Term)] -> Term)
-> Flow Graph [(Term, Term)] -> Flow Graph Term
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ((k, v) -> Flow Graph (Term, Term))
-> [(k, v)] -> Flow Graph [(Term, Term)]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM (k, v) -> Flow Graph (Term, Term)
decodePair (Map k v -> [(k, v)]
forall k a. Map k a -> [(k, a)]
M.toList Map k v
m)
      where
        decodePair :: (k, v) -> Flow Graph (Term, Term)
decodePair (k
k, v
v) = do
          Term
ke <- (Coder Graph Graph Term k -> k -> Flow Graph Term
forall s1 s2 v1 v2. Coder s1 s2 v1 v2 -> v2 -> Flow s2 v1
coderDecode (Coder Graph Graph Term k -> k -> Flow Graph Term)
-> Coder Graph Graph Term k -> k -> Flow Graph Term
forall a b. (a -> b) -> a -> b
$ TermCoder k -> Coder Graph Graph Term k
forall x. TermCoder x -> Coder Graph Graph Term x
termCoderCoder TermCoder k
keys) k
k
          Term
ve <- (Coder Graph Graph Term v -> v -> Flow Graph Term
forall s1 s2 v1 v2. Coder s1 s2 v1 v2 -> v2 -> Flow s2 v1
coderDecode (Coder Graph Graph Term v -> v -> Flow Graph Term)
-> Coder Graph Graph Term v -> v -> Flow Graph Term
forall a b. (a -> b) -> a -> b
$ TermCoder v -> Coder Graph Graph Term v
forall x. TermCoder x -> Coder Graph Graph Term x
termCoderCoder TermCoder v
values) v
v
          (Term, Term) -> Flow Graph (Term, Term)
forall a. a -> Flow Graph a
forall (m :: * -> *) a. Monad m => a -> m a
return (Term
ke, Term
ve)

optional :: TermCoder x -> TermCoder (Y.Maybe x)
optional :: forall x. TermCoder x -> TermCoder (Maybe x)
optional TermCoder x
mel = Type -> Coder Graph Graph Term (Maybe x) -> TermCoder (Maybe x)
forall x. Type -> Coder Graph Graph Term x -> TermCoder x
TermCoder (Type -> Type
Types.optional (Type -> Type) -> Type -> Type
forall a b. (a -> b) -> a -> b
$ TermCoder x -> Type
forall x. TermCoder x -> Type
termCoderType TermCoder x
mel) (Coder Graph Graph Term (Maybe x) -> TermCoder (Maybe x))
-> Coder Graph Graph Term (Maybe x) -> TermCoder (Maybe x)
forall a b. (a -> b) -> a -> b
$ (Term -> Flow Graph (Maybe x))
-> (Maybe x -> Flow Graph Term) -> Coder Graph Graph Term (Maybe x)
forall s1 s2 v1 v2.
(v1 -> Flow s1 v2) -> (v2 -> Flow s2 v1) -> Coder s1 s2 v1 v2
Coder Term -> Flow Graph (Maybe x)
encode Maybe x -> Flow Graph Term
decode
  where
    encode :: Term -> Flow Graph (Maybe x)
encode = (Term -> Flow Graph x) -> Term -> Flow Graph (Maybe x)
forall s x. (Term -> Flow s x) -> Term -> Flow s (Maybe x)
Expect.optional (Coder Graph Graph Term x -> Term -> Flow Graph x
forall s1 s2 v1 v2. Coder s1 s2 v1 v2 -> v1 -> Flow s1 v2
coderEncode (Coder Graph Graph Term x -> Term -> Flow Graph x)
-> Coder Graph Graph Term x -> Term -> Flow Graph x
forall a b. (a -> b) -> a -> b
$ TermCoder x -> Coder Graph Graph Term x
forall x. TermCoder x -> Coder Graph Graph Term x
termCoderCoder TermCoder x
mel)
    decode :: Maybe x -> Flow Graph Term
decode Maybe x
mv = Maybe Term -> Term
Terms.optional (Maybe Term -> Term) -> Flow Graph (Maybe Term) -> Flow Graph Term
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> case Maybe x
mv of
      Maybe x
Nothing -> Maybe Term -> Flow Graph (Maybe Term)
forall a. a -> Flow Graph a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe Term
forall a. Maybe a
Nothing
      Just x
v -> Term -> Maybe Term
forall a. a -> Maybe a
Just (Term -> Maybe Term) -> Flow Graph Term -> Flow Graph (Maybe Term)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Coder Graph Graph Term x -> x -> Flow Graph Term
forall s1 s2 v1 v2. Coder s1 s2 v1 v2 -> v2 -> Flow s2 v1
coderDecode (Coder Graph Graph Term x -> x -> Flow Graph Term)
-> Coder Graph Graph Term x -> x -> Flow Graph Term
forall a b. (a -> b) -> a -> b
$ TermCoder x -> Coder Graph Graph Term x
forall x. TermCoder x -> Coder Graph Graph Term x
termCoderCoder TermCoder x
mel) x
v

pair :: TermCoder k -> TermCoder v -> TermCoder (k, v)
pair :: forall k v. TermCoder k -> TermCoder v -> TermCoder (k, v)
pair TermCoder k
kCoder TermCoder v
vCoder = Type -> Coder Graph Graph Term (k, v) -> TermCoder (k, v)
forall x. Type -> Coder Graph Graph Term x -> TermCoder x
TermCoder ([Type] -> Type
Types.product [TermCoder k -> Type
forall x. TermCoder x -> Type
termCoderType TermCoder k
kCoder, TermCoder v -> Type
forall x. TermCoder x -> Type
termCoderType TermCoder v
vCoder]) (Coder Graph Graph Term (k, v) -> TermCoder (k, v))
-> Coder Graph Graph Term (k, v) -> TermCoder (k, v)
forall a b. (a -> b) -> a -> b
$ (Term -> Flow Graph (k, v))
-> ((k, v) -> Flow Graph Term) -> Coder Graph Graph Term (k, v)
forall s1 s2 v1 v2.
(v1 -> Flow s1 v2) -> (v2 -> Flow s2 v1) -> Coder s1 s2 v1 v2
Coder Term -> Flow Graph (k, v)
encode (k, v) -> Flow Graph Term
decode
  where
    encode :: Term -> Flow Graph (k, v)
encode = (Term -> Flow Graph k)
-> (Term -> Flow Graph v) -> Term -> Flow Graph (k, v)
forall s k v.
(Term -> Flow s k) -> (Term -> Flow s v) -> Term -> Flow s (k, v)
Expect.pair (Coder Graph Graph Term k -> Term -> Flow Graph k
forall s1 s2 v1 v2. Coder s1 s2 v1 v2 -> v1 -> Flow s1 v2
coderEncode (Coder Graph Graph Term k -> Term -> Flow Graph k)
-> Coder Graph Graph Term k -> Term -> Flow Graph k
forall a b. (a -> b) -> a -> b
$ TermCoder k -> Coder Graph Graph Term k
forall x. TermCoder x -> Coder Graph Graph Term x
termCoderCoder TermCoder k
kCoder) (Coder Graph Graph Term v -> Term -> Flow Graph v
forall s1 s2 v1 v2. Coder s1 s2 v1 v2 -> v1 -> Flow s1 v2
coderEncode (Coder Graph Graph Term v -> Term -> Flow Graph v)
-> Coder Graph Graph Term v -> Term -> Flow Graph v
forall a b. (a -> b) -> a -> b
$ TermCoder v -> Coder Graph Graph Term v
forall x. TermCoder x -> Coder Graph Graph Term x
termCoderCoder TermCoder v
vCoder)
    decode :: (k, v) -> Flow Graph Term
decode (k
k, v
v) = do
      Term
kTerm <- Coder Graph Graph Term k -> k -> Flow Graph Term
forall s1 s2 v1 v2. Coder s1 s2 v1 v2 -> v2 -> Flow s2 v1
coderDecode (TermCoder k -> Coder Graph Graph Term k
forall x. TermCoder x -> Coder Graph Graph Term x
termCoderCoder TermCoder k
kCoder) k
k
      Term
vTerm <- Coder Graph Graph Term v -> v -> Flow Graph Term
forall s1 s2 v1 v2. Coder s1 s2 v1 v2 -> v2 -> Flow s2 v1
coderDecode (TermCoder v -> Coder Graph Graph Term v
forall x. TermCoder x -> Coder Graph Graph Term x
termCoderCoder TermCoder v
vCoder) v
v
      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.product [Term
kTerm, Term
vTerm]

prim0 :: [String] -> Name -> TermCoder x -> x -> Primitive
prim0 :: forall x. [String] -> Name -> TermCoder x -> x -> Primitive
prim0 [String]
vars Name
name TermCoder x
output x
value = Name -> TypeScheme -> ([Term] -> Flow Graph Term) -> Primitive
Primitive Name
name TypeScheme
typ [Term] -> Flow Graph Term
forall {p}. p -> Flow Graph Term
impl
  where
    typ :: TypeScheme
typ = [Name] -> Type -> TypeScheme
TypeScheme (String -> Name
Name (String -> Name) -> [String] -> [Name]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [String]
vars) (Type -> TypeScheme) -> Type -> TypeScheme
forall a b. (a -> b) -> a -> b
$
      TermCoder x -> Type
forall x. TermCoder x -> Type
termCoderType TermCoder x
output
    impl :: p -> Flow Graph Term
impl p
_ = Coder Graph Graph Term x -> x -> Flow Graph Term
forall s1 s2 v1 v2. Coder s1 s2 v1 v2 -> v2 -> Flow s2 v1
coderDecode (TermCoder x -> Coder Graph Graph Term x
forall x. TermCoder x -> Coder Graph Graph Term x
termCoderCoder TermCoder x
output) x
value

prim1 :: [String] -> Name -> TermCoder x -> TermCoder y -> (x -> y) -> Primitive
prim1 :: forall x y.
[String]
-> Name -> TermCoder x -> TermCoder y -> (x -> y) -> Primitive
prim1 [String]
vars Name
name TermCoder x
input1 TermCoder y
output x -> y
compute = Name -> TypeScheme -> ([Term] -> Flow Graph Term) -> Primitive
Primitive Name
name TypeScheme
typ [Term] -> Flow Graph Term
impl
  where
    typ :: TypeScheme
typ = [Name] -> Type -> TypeScheme
TypeScheme (String -> Name
Name (String -> Name) -> [String] -> [Name]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [String]
vars) (Type -> TypeScheme) -> Type -> TypeScheme
forall a b. (a -> b) -> a -> b
$
      FunctionType -> Type
TypeFunction (FunctionType -> Type) -> FunctionType -> Type
forall a b. (a -> b) -> a -> b
$ Type -> Type -> FunctionType
FunctionType (TermCoder x -> Type
forall x. TermCoder x -> Type
termCoderType TermCoder x
input1) (Type -> FunctionType) -> Type -> FunctionType
forall a b. (a -> b) -> a -> b
$ TermCoder y -> Type
forall x. TermCoder x -> Type
termCoderType TermCoder y
output
    impl :: [Term] -> Flow Graph Term
impl [Term]
args = do
      Int -> [Term] -> Flow Graph ()
forall s. Int -> [Term] -> Flow s ()
Expect.nArgs Int
1 [Term]
args
      x
arg1 <- Coder Graph Graph Term x -> Term -> Flow Graph x
forall s1 s2 v1 v2. Coder s1 s2 v1 v2 -> v1 -> Flow s1 v2
coderEncode (TermCoder x -> Coder Graph Graph Term x
forall x. TermCoder x -> Coder Graph Graph Term x
termCoderCoder TermCoder x
input1) ([Term]
args [Term] -> Int -> Term
forall a. HasCallStack => [a] -> Int -> a
!! Int
0)
      Coder Graph Graph Term y -> y -> Flow Graph Term
forall s1 s2 v1 v2. Coder s1 s2 v1 v2 -> v2 -> Flow s2 v1
coderDecode (TermCoder y -> Coder Graph Graph Term y
forall x. TermCoder x -> Coder Graph Graph Term x
termCoderCoder TermCoder y
output) (y -> Flow Graph Term) -> y -> Flow Graph Term
forall a b. (a -> b) -> a -> b
$ x -> y
compute x
arg1

prim2 :: [String] -> Name -> TermCoder x -> TermCoder y -> TermCoder z -> (x -> y -> z) -> Primitive
prim2 :: forall x y z.
[String]
-> Name
-> TermCoder x
-> TermCoder y
-> TermCoder z
-> (x -> y -> z)
-> Primitive
prim2 [String]
vars Name
name TermCoder x
input1 TermCoder y
input2 TermCoder z
output x -> y -> z
compute = Name -> TypeScheme -> ([Term] -> Flow Graph Term) -> Primitive
Primitive Name
name TypeScheme
typ [Term] -> Flow Graph Term
impl
  where
    typ :: TypeScheme
typ = [Name] -> Type -> TypeScheme
TypeScheme (String -> Name
Name (String -> Name) -> [String] -> [Name]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [String]
vars) (Type -> TypeScheme) -> Type -> TypeScheme
forall a b. (a -> b) -> a -> b
$
      FunctionType -> Type
TypeFunction (FunctionType -> Type) -> FunctionType -> Type
forall a b. (a -> b) -> a -> b
$ Type -> Type -> FunctionType
FunctionType (TermCoder x -> Type
forall x. TermCoder x -> Type
termCoderType TermCoder x
input1) (Type -> Type -> Type
Types.function (TermCoder y -> Type
forall x. TermCoder x -> Type
termCoderType TermCoder y
input2) (TermCoder z -> Type
forall x. TermCoder x -> Type
termCoderType TermCoder z
output))
    impl :: [Term] -> Flow Graph Term
impl [Term]
args = do
      Int -> [Term] -> Flow Graph ()
forall s. Int -> [Term] -> Flow s ()
Expect.nArgs Int
2 [Term]
args
      x
arg1 <- Coder Graph Graph Term x -> Term -> Flow Graph x
forall s1 s2 v1 v2. Coder s1 s2 v1 v2 -> v1 -> Flow s1 v2
coderEncode (TermCoder x -> Coder Graph Graph Term x
forall x. TermCoder x -> Coder Graph Graph Term x
termCoderCoder TermCoder x
input1) ([Term]
args [Term] -> Int -> Term
forall a. HasCallStack => [a] -> Int -> a
!! Int
0)
      y
arg2 <- Coder Graph Graph Term y -> Term -> Flow Graph y
forall s1 s2 v1 v2. Coder s1 s2 v1 v2 -> v1 -> Flow s1 v2
coderEncode (TermCoder y -> Coder Graph Graph Term y
forall x. TermCoder x -> Coder Graph Graph Term x
termCoderCoder TermCoder y
input2) ([Term]
args [Term] -> Int -> Term
forall a. HasCallStack => [a] -> Int -> a
!! Int
1)
      Coder Graph Graph Term z -> z -> Flow Graph Term
forall s1 s2 v1 v2. Coder s1 s2 v1 v2 -> v2 -> Flow s2 v1
coderDecode (TermCoder z -> Coder Graph Graph Term z
forall x. TermCoder x -> Coder Graph Graph Term x
termCoderCoder TermCoder z
output) (z -> Flow Graph Term) -> z -> Flow Graph Term
forall a b. (a -> b) -> a -> b
$ x -> y -> z
compute x
arg1 y
arg2

prim2Interp :: [String] -> Name -> TermCoder x -> TermCoder y -> TermCoder z -> (Term -> Term -> Flow (Graph) (Term)) -> Primitive
prim2Interp :: forall x y z.
[String]
-> Name
-> TermCoder x
-> TermCoder y
-> TermCoder z
-> (Term -> Term -> Flow Graph Term)
-> Primitive
prim2Interp [String]
vars Name
name TermCoder x
input1 TermCoder y
input2 TermCoder z
output Term -> Term -> Flow Graph Term
compute = Name -> TypeScheme -> ([Term] -> Flow Graph Term) -> Primitive
Primitive Name
name TypeScheme
typ [Term] -> Flow Graph Term
impl
  where
    typ :: TypeScheme
typ = [Name] -> Type -> TypeScheme
TypeScheme (String -> Name
Name (String -> Name) -> [String] -> [Name]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [String]
vars) (Type -> TypeScheme) -> Type -> TypeScheme
forall a b. (a -> b) -> a -> b
$
      FunctionType -> Type
TypeFunction (FunctionType -> Type) -> FunctionType -> Type
forall a b. (a -> b) -> a -> b
$ Type -> Type -> FunctionType
FunctionType (TermCoder x -> Type
forall x. TermCoder x -> Type
termCoderType TermCoder x
input1) (Type -> Type -> Type
Types.function (TermCoder y -> Type
forall x. TermCoder x -> Type
termCoderType TermCoder y
input2) (TermCoder z -> Type
forall x. TermCoder x -> Type
termCoderType TermCoder z
output))
    impl :: [Term] -> Flow Graph Term
impl [Term]
args = do
      Int -> [Term] -> Flow Graph ()
forall s. Int -> [Term] -> Flow s ()
Expect.nArgs Int
2 [Term]
args
      Term -> Term -> Flow Graph Term
compute ([Term]
args [Term] -> Int -> Term
forall a. HasCallStack => [a] -> Int -> a
!! Int
0) ([Term]
args [Term] -> Int -> Term
forall a. HasCallStack => [a] -> Int -> a
!! Int
1)

prim3 :: [String] -> Name -> TermCoder w -> TermCoder x -> TermCoder y -> TermCoder z -> (w -> x -> y -> z) -> Primitive
prim3 :: forall w x y z.
[String]
-> Name
-> TermCoder w
-> TermCoder x
-> TermCoder y
-> TermCoder z
-> (w -> x -> y -> z)
-> Primitive
prim3 [String]
vars Name
name TermCoder w
input1 TermCoder x
input2 TermCoder y
input3 TermCoder z
output w -> x -> y -> z
compute = Name -> TypeScheme -> ([Term] -> Flow Graph Term) -> Primitive
Primitive Name
name TypeScheme
typ [Term] -> Flow Graph Term
impl
  where
    typ :: TypeScheme
typ = [Name] -> Type -> TypeScheme
TypeScheme (String -> Name
Name (String -> Name) -> [String] -> [Name]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [String]
vars) (Type -> TypeScheme) -> Type -> TypeScheme
forall a b. (a -> b) -> a -> b
$
      FunctionType -> Type
TypeFunction (FunctionType -> Type) -> FunctionType -> Type
forall a b. (a -> b) -> a -> b
$ Type -> Type -> FunctionType
FunctionType
        (TermCoder w -> Type
forall x. TermCoder x -> Type
termCoderType TermCoder w
input1)
        (Type -> Type -> Type
Types.function (TermCoder x -> Type
forall x. TermCoder x -> Type
termCoderType TermCoder x
input2)
        (Type -> Type -> Type
Types.function (TermCoder y -> Type
forall x. TermCoder x -> Type
termCoderType TermCoder y
input3) (TermCoder z -> Type
forall x. TermCoder x -> Type
termCoderType TermCoder z
output)))
    impl :: [Term] -> Flow Graph Term
impl [Term]
args = do
      Int -> [Term] -> Flow Graph ()
forall s. Int -> [Term] -> Flow s ()
Expect.nArgs Int
2 [Term]
args
      w
arg1 <- Coder Graph Graph Term w -> Term -> Flow Graph w
forall s1 s2 v1 v2. Coder s1 s2 v1 v2 -> v1 -> Flow s1 v2
coderEncode (TermCoder w -> Coder Graph Graph Term w
forall x. TermCoder x -> Coder Graph Graph Term x
termCoderCoder TermCoder w
input1) ([Term]
args [Term] -> Int -> Term
forall a. HasCallStack => [a] -> Int -> a
!! Int
0)
      x
arg2 <- Coder Graph Graph Term x -> Term -> Flow Graph x
forall s1 s2 v1 v2. Coder s1 s2 v1 v2 -> v1 -> Flow s1 v2
coderEncode (TermCoder x -> Coder Graph Graph Term x
forall x. TermCoder x -> Coder Graph Graph Term x
termCoderCoder TermCoder x
input2) ([Term]
args [Term] -> Int -> Term
forall a. HasCallStack => [a] -> Int -> a
!! Int
1)
      y
arg3 <- Coder Graph Graph Term y -> Term -> Flow Graph y
forall s1 s2 v1 v2. Coder s1 s2 v1 v2 -> v1 -> Flow s1 v2
coderEncode (TermCoder y -> Coder Graph Graph Term y
forall x. TermCoder x -> Coder Graph Graph Term x
termCoderCoder TermCoder y
input3) ([Term]
args [Term] -> Int -> Term
forall a. HasCallStack => [a] -> Int -> a
!! Int
2)
      Coder Graph Graph Term z -> z -> Flow Graph Term
forall s1 s2 v1 v2. Coder s1 s2 v1 v2 -> v2 -> Flow s2 v1
coderDecode (TermCoder z -> Coder Graph Graph Term z
forall x. TermCoder x -> Coder Graph Graph Term x
termCoderCoder TermCoder z
output) (z -> Flow Graph Term) -> z -> Flow Graph Term
forall a b. (a -> b) -> a -> b
$ w -> x -> y -> z
compute w
arg1 x
arg2 y
arg3

set :: Ord x => TermCoder x -> TermCoder (S.Set x)
set :: forall x. Ord x => TermCoder x -> TermCoder (Set x)
set TermCoder x
els = Type -> Coder Graph Graph Term (Set x) -> TermCoder (Set x)
forall x. Type -> Coder Graph Graph Term x -> TermCoder x
TermCoder (Type -> Type
Types.set (Type -> Type) -> Type -> Type
forall a b. (a -> b) -> a -> b
$ TermCoder x -> Type
forall x. TermCoder x -> Type
termCoderType TermCoder x
els) (Coder Graph Graph Term (Set x) -> TermCoder (Set x))
-> Coder Graph Graph Term (Set x) -> TermCoder (Set x)
forall a b. (a -> b) -> a -> b
$ (Term -> Flow Graph (Set x))
-> (Set x -> Flow Graph Term) -> Coder Graph Graph Term (Set x)
forall s1 s2 v1 v2.
(v1 -> Flow s1 v2) -> (v2 -> Flow s2 v1) -> Coder s1 s2 v1 v2
Coder Term -> Flow Graph (Set x)
encode Set x -> Flow Graph Term
decode
  where
    encode :: Term -> Flow Graph (Set x)
encode = (Term -> Flow Graph x) -> Term -> Flow Graph (Set x)
forall x s. Ord x => (Term -> Flow s x) -> Term -> Flow s (Set x)
Expect.set (Coder Graph Graph Term x -> Term -> Flow Graph x
forall s1 s2 v1 v2. Coder s1 s2 v1 v2 -> v1 -> Flow s1 v2
coderEncode (Coder Graph Graph Term x -> Term -> Flow Graph x)
-> Coder Graph Graph Term x -> Term -> Flow Graph x
forall a b. (a -> b) -> a -> b
$ TermCoder x -> Coder Graph Graph Term x
forall x. TermCoder x -> Coder Graph Graph Term x
termCoderCoder TermCoder x
els)
    decode :: Set x -> Flow Graph Term
decode Set x
s = Set Term -> Term
Terms.set (Set Term -> Term) -> ([Term] -> Set Term) -> [Term] -> Term
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Term] -> Set Term
forall a. Ord a => [a] -> Set a
S.fromList ([Term] -> Term) -> Flow Graph [Term] -> Flow Graph Term
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (x -> Flow Graph Term) -> [x] -> Flow Graph [Term]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM (Coder Graph Graph Term x -> x -> Flow Graph Term
forall s1 s2 v1 v2. Coder s1 s2 v1 v2 -> v2 -> Flow s2 v1
coderDecode (Coder Graph Graph Term x -> x -> Flow Graph Term)
-> Coder Graph Graph Term x -> x -> Flow Graph Term
forall a b. (a -> b) -> a -> b
$ TermCoder x -> Coder Graph Graph Term x
forall x. TermCoder x -> Coder Graph Graph Term x
termCoderCoder TermCoder x
els) (Set x -> [x]
forall a. Set a -> [a]
S.toList Set x
s)

string :: TermCoder String
string :: TermCoder String
string = Type -> Coder Graph Graph Term String -> TermCoder String
forall x. Type -> Coder Graph Graph Term x -> TermCoder x
TermCoder Type
Types.string (Coder Graph Graph Term String -> TermCoder String)
-> Coder Graph Graph Term String -> TermCoder String
forall a b. (a -> b) -> a -> b
$ (Term -> Flow Graph String)
-> (String -> Flow Graph Term) -> Coder Graph Graph Term String
forall s1 s2 v1 v2.
(v1 -> Flow s1 v2) -> (v2 -> Flow s2 v1) -> Coder s1 s2 v1 v2
Coder Term -> Flow Graph String
forall {s}. Term -> Flow s String
encode String -> Flow Graph Term
decode
  where
    encode :: Term -> Flow s String
encode = Term -> Flow s String
forall {s}. Term -> Flow s String
Expect.string
    decode :: String -> Flow Graph Term
decode = Term -> Flow Graph Term
forall a. a -> Flow Graph a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Term -> Flow Graph Term)
-> (String -> Term) -> String -> Flow Graph Term
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Term
Terms.string

term :: TermCoder (Term)
term :: TermCoder Term
term = Type -> Coder Graph Graph Term Term -> TermCoder Term
forall x. Type -> Coder Graph Graph Term x -> TermCoder x
TermCoder (Type -> Type -> Type
Types.apply (Name -> Type
TypeVariable Name
_Term) (String -> Type
Types.var String
"a")) (Coder Graph Graph Term Term -> TermCoder Term)
-> Coder Graph Graph Term Term -> TermCoder Term
forall a b. (a -> b) -> a -> b
$ (Term -> Flow Graph Term)
-> (Term -> Flow Graph Term) -> Coder Graph Graph Term Term
forall s1 s2 v1 v2.
(v1 -> Flow s1 v2) -> (v2 -> Flow s2 v1) -> Coder s1 s2 v1 v2
Coder Term -> Flow Graph Term
forall a. a -> Flow Graph a
encode Term -> Flow Graph Term
forall a. a -> Flow Graph a
decode
  where
    encode :: a -> Flow Graph a
encode = a -> Flow Graph a
forall a. a -> Flow Graph a
forall (f :: * -> *) a. Applicative f => a -> f a
pure
    decode :: a -> Flow Graph a
decode = a -> Flow Graph a
forall a. a -> Flow Graph a
forall (f :: * -> *) a. Applicative f => a -> f a
pure

type_ :: TermCoder (Type)
type_ :: TermCoder Type
type_ = Type -> Coder Graph Graph Term Type -> TermCoder Type
forall x. Type -> Coder Graph Graph Term x -> TermCoder x
TermCoder (Type -> Type -> Type
Types.apply (Name -> Type
TypeVariable Name
_Type) (String -> Type
Types.var String
"a")) (Coder Graph Graph Term Type -> TermCoder Type)
-> Coder Graph Graph Term Type -> TermCoder Type
forall a b. (a -> b) -> a -> b
$ (Term -> Flow Graph Type)
-> (Type -> Flow Graph Term) -> Coder Graph Graph Term Type
forall s1 s2 v1 v2.
(v1 -> Flow s1 v2) -> (v2 -> Flow s2 v1) -> Coder s1 s2 v1 v2
Coder Term -> Flow Graph Type
encode Type -> Flow Graph Term
decode
  where
    encode :: Term -> Flow Graph Type
encode = Term -> Flow Graph Type
coreDecodeType
    decode :: Type -> Flow Graph Term
decode = Term -> Flow Graph Term
forall a. a -> Flow Graph a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Term -> Flow Graph Term)
-> (Type -> Term) -> Type -> Flow Graph Term
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Type -> Term
coreEncodeType

uint8 :: TermCoder Int16
uint8 :: TermCoder Int16
uint8 = Type -> Coder Graph Graph Term Int16 -> TermCoder Int16
forall x. Type -> Coder Graph Graph Term x -> TermCoder x
TermCoder Type
Types.uint8 (Coder Graph Graph Term Int16 -> TermCoder Int16)
-> Coder Graph Graph Term Int16 -> TermCoder Int16
forall a b. (a -> b) -> a -> b
$ (Term -> Flow Graph Int16)
-> (Int16 -> Flow Graph Term) -> Coder Graph Graph Term Int16
forall s1 s2 v1 v2.
(v1 -> Flow s1 v2) -> (v2 -> Flow s2 v1) -> Coder s1 s2 v1 v2
Coder Term -> Flow Graph Int16
forall {s}. Term -> Flow s Int16
encode Int16 -> Flow Graph Term
decode
  where
    encode :: Term -> Flow s Int16
encode = Term -> Flow s Int16
forall {s}. Term -> Flow s Int16
Expect.uint8
    decode :: Int16 -> Flow Graph Term
decode = Term -> Flow Graph Term
forall a. a -> Flow Graph a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Term -> Flow Graph Term)
-> (Int16 -> Term) -> Int16 -> Flow Graph Term
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int16 -> Term
Terms.uint8

uint16 :: TermCoder Int
uint16 :: TermCoder Int
uint16 = Type -> Coder Graph Graph Term Int -> TermCoder Int
forall x. Type -> Coder Graph Graph Term x -> TermCoder x
TermCoder Type
Types.uint16 (Coder Graph Graph Term Int -> TermCoder Int)
-> Coder Graph Graph Term Int -> TermCoder Int
forall a b. (a -> b) -> a -> b
$ (Term -> Flow Graph Int)
-> (Int -> Flow Graph Term) -> Coder Graph Graph Term Int
forall s1 s2 v1 v2.
(v1 -> Flow s1 v2) -> (v2 -> Flow s2 v1) -> Coder s1 s2 v1 v2
Coder Term -> Flow Graph Int
forall {s}. Term -> Flow s Int
encode Int -> Flow Graph Term
decode
  where
    encode :: Term -> Flow s Int
encode = Term -> Flow s Int
forall {s}. Term -> Flow s Int
Expect.uint16
    decode :: Int -> Flow Graph Term
decode = Term -> Flow Graph Term
forall a. a -> Flow Graph a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Term -> Flow Graph Term)
-> (Int -> Term) -> Int -> Flow Graph Term
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Term
Terms.uint16

uint32 :: TermCoder Int64
uint32 :: TermCoder Int64
uint32 = Type -> Coder Graph Graph Term Int64 -> TermCoder Int64
forall x. Type -> Coder Graph Graph Term x -> TermCoder x
TermCoder Type
Types.uint32 (Coder Graph Graph Term Int64 -> TermCoder Int64)
-> Coder Graph Graph Term Int64 -> TermCoder Int64
forall a b. (a -> b) -> a -> b
$ (Term -> Flow Graph Int64)
-> (Int64 -> Flow Graph Term) -> Coder Graph Graph Term Int64
forall s1 s2 v1 v2.
(v1 -> Flow s1 v2) -> (v2 -> Flow s2 v1) -> Coder s1 s2 v1 v2
Coder Term -> Flow Graph Int64
forall {s}. Term -> Flow s Int64
encode Int64 -> Flow Graph Term
decode
  where
    encode :: Term -> Flow s Int64
encode = Term -> Flow s Int64
forall {s}. Term -> Flow s Int64
Expect.uint32
    decode :: Int64 -> Flow Graph Term
decode = Term -> Flow Graph Term
forall a. a -> Flow Graph a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Term -> Flow Graph Term)
-> (Int64 -> Term) -> Int64 -> Flow Graph Term
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int64 -> Term
Terms.uint32

uint64 :: TermCoder Integer
uint64 :: TermCoder Integer
uint64 = Type -> Coder Graph Graph Term Integer -> TermCoder Integer
forall x. Type -> Coder Graph Graph Term x -> TermCoder x
TermCoder Type
Types.uint64 (Coder Graph Graph Term Integer -> TermCoder Integer)
-> Coder Graph Graph Term Integer -> TermCoder Integer
forall a b. (a -> b) -> a -> b
$ (Term -> Flow Graph Integer)
-> (Integer -> Flow Graph Term) -> Coder Graph Graph Term Integer
forall s1 s2 v1 v2.
(v1 -> Flow s1 v2) -> (v2 -> Flow s2 v1) -> Coder s1 s2 v1 v2
Coder Term -> Flow Graph Integer
forall {s}. Term -> Flow s Integer
encode Integer -> Flow Graph Term
decode
  where
    encode :: Term -> Flow s Integer
encode = Term -> Flow s Integer
forall {s}. Term -> Flow s Integer
Expect.uint64
    decode :: Integer -> Flow Graph Term
decode = Term -> Flow Graph Term
forall a. a -> Flow Graph a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Term -> Flow Graph Term)
-> (Integer -> Term) -> Integer -> Flow Graph Term
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Term
Terms.uint64

variable :: String -> TermCoder (Term)
variable :: String -> TermCoder Term
variable String
v = Type -> Coder Graph Graph Term Term -> TermCoder Term
forall x. Type -> Coder Graph Graph Term x -> TermCoder x
TermCoder (String -> Type
Types.var String
v) (Coder Graph Graph Term Term -> TermCoder Term)
-> Coder Graph Graph Term Term -> TermCoder Term
forall a b. (a -> b) -> a -> b
$ (Term -> Flow Graph Term)
-> (Term -> Flow Graph Term) -> Coder Graph Graph Term Term
forall s1 s2 v1 v2.
(v1 -> Flow s1 v2) -> (v2 -> Flow s2 v1) -> Coder s1 s2 v1 v2
Coder Term -> Flow Graph Term
forall a. a -> Flow Graph a
encode Term -> Flow Graph Term
forall a. a -> Flow Graph a
decode
  where
    encode :: a -> Flow Graph a
encode = a -> Flow Graph a
forall a. a -> Flow Graph a
forall (f :: * -> *) a. Applicative f => a -> f a
pure
    decode :: a -> Flow Graph a
decode = a -> Flow Graph a
forall a. a -> Flow Graph a
forall (f :: * -> *) a. Applicative f => a -> f a
pure