{- |
    Module      : $Header$
    Description : Representation of annotated FlatCurry.
    Copyright   : (c) 2016 - 2017 Finn Teegen
                      2018        Kai-Oliver Prott
    License     : BSD-3-clause

    Maintainer  : fte@informatik.uni-kiel.de
    Stability   : experimental
    Portability : portable

    This library contains a version of FlatCurry's abstract syntax tree
    modified with type information

    For more information about the abstract syntax tree of `FlatCurry`,
    see the documentation of the respective module.
-}

module Curry.FlatCurry.Typed.Type
  ( module Curry.FlatCurry.Typed.Type
  , module Curry.FlatCurry.Typeable
  , module Curry.FlatCurry.Type
  ) where

import Data.Binary
import Control.Monad

import Curry.FlatCurry.Typeable
import Curry.FlatCurry.Type ( QName, VarIndex, Visibility (..), TVarIndex
                            , TypeDecl (..), Kind (..), OpDecl (..), Fixity (..)
                            , TypeExpr (..), ConsDecl (..), NewConsDecl (..)
                            , Literal (..), CombType (..), CaseType (..)
                            )

data TProg = TProg String [String] [TypeDecl] [TFuncDecl] [OpDecl]
  deriving (TProg -> TProg -> Bool
(TProg -> TProg -> Bool) -> (TProg -> TProg -> Bool) -> Eq TProg
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TProg -> TProg -> Bool
$c/= :: TProg -> TProg -> Bool
== :: TProg -> TProg -> Bool
$c== :: TProg -> TProg -> Bool
Eq, ReadPrec [TProg]
ReadPrec TProg
Int -> ReadS TProg
ReadS [TProg]
(Int -> ReadS TProg)
-> ReadS [TProg]
-> ReadPrec TProg
-> ReadPrec [TProg]
-> Read TProg
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [TProg]
$creadListPrec :: ReadPrec [TProg]
readPrec :: ReadPrec TProg
$creadPrec :: ReadPrec TProg
readList :: ReadS [TProg]
$creadList :: ReadS [TProg]
readsPrec :: Int -> ReadS TProg
$creadsPrec :: Int -> ReadS TProg
Read, Int -> TProg -> ShowS
[TProg] -> ShowS
TProg -> String
(Int -> TProg -> ShowS)
-> (TProg -> String) -> ([TProg] -> ShowS) -> Show TProg
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TProg] -> ShowS
$cshowList :: [TProg] -> ShowS
show :: TProg -> String
$cshow :: TProg -> String
showsPrec :: Int -> TProg -> ShowS
$cshowsPrec :: Int -> TProg -> ShowS
Show)

data TFuncDecl = TFunc QName Int Visibility TypeExpr TRule
  deriving (TFuncDecl -> TFuncDecl -> Bool
(TFuncDecl -> TFuncDecl -> Bool)
-> (TFuncDecl -> TFuncDecl -> Bool) -> Eq TFuncDecl
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TFuncDecl -> TFuncDecl -> Bool
$c/= :: TFuncDecl -> TFuncDecl -> Bool
== :: TFuncDecl -> TFuncDecl -> Bool
$c== :: TFuncDecl -> TFuncDecl -> Bool
Eq, ReadPrec [TFuncDecl]
ReadPrec TFuncDecl
Int -> ReadS TFuncDecl
ReadS [TFuncDecl]
(Int -> ReadS TFuncDecl)
-> ReadS [TFuncDecl]
-> ReadPrec TFuncDecl
-> ReadPrec [TFuncDecl]
-> Read TFuncDecl
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [TFuncDecl]
$creadListPrec :: ReadPrec [TFuncDecl]
readPrec :: ReadPrec TFuncDecl
$creadPrec :: ReadPrec TFuncDecl
readList :: ReadS [TFuncDecl]
$creadList :: ReadS [TFuncDecl]
readsPrec :: Int -> ReadS TFuncDecl
$creadsPrec :: Int -> ReadS TFuncDecl
Read, Int -> TFuncDecl -> ShowS
[TFuncDecl] -> ShowS
TFuncDecl -> String
(Int -> TFuncDecl -> ShowS)
-> (TFuncDecl -> String)
-> ([TFuncDecl] -> ShowS)
-> Show TFuncDecl
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TFuncDecl] -> ShowS
$cshowList :: [TFuncDecl] -> ShowS
show :: TFuncDecl -> String
$cshow :: TFuncDecl -> String
showsPrec :: Int -> TFuncDecl -> ShowS
$cshowsPrec :: Int -> TFuncDecl -> ShowS
Show)

data TRule
  = TRule     [(VarIndex, TypeExpr)] TExpr
  | TExternal TypeExpr String
  deriving (TRule -> TRule -> Bool
(TRule -> TRule -> Bool) -> (TRule -> TRule -> Bool) -> Eq TRule
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TRule -> TRule -> Bool
$c/= :: TRule -> TRule -> Bool
== :: TRule -> TRule -> Bool
$c== :: TRule -> TRule -> Bool
Eq, ReadPrec [TRule]
ReadPrec TRule
Int -> ReadS TRule
ReadS [TRule]
(Int -> ReadS TRule)
-> ReadS [TRule]
-> ReadPrec TRule
-> ReadPrec [TRule]
-> Read TRule
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [TRule]
$creadListPrec :: ReadPrec [TRule]
readPrec :: ReadPrec TRule
$creadPrec :: ReadPrec TRule
readList :: ReadS [TRule]
$creadList :: ReadS [TRule]
readsPrec :: Int -> ReadS TRule
$creadsPrec :: Int -> ReadS TRule
Read, Int -> TRule -> ShowS
[TRule] -> ShowS
TRule -> String
(Int -> TRule -> ShowS)
-> (TRule -> String) -> ([TRule] -> ShowS) -> Show TRule
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TRule] -> ShowS
$cshowList :: [TRule] -> ShowS
show :: TRule -> String
$cshow :: TRule -> String
showsPrec :: Int -> TRule -> ShowS
$cshowsPrec :: Int -> TRule -> ShowS
Show)

data TExpr
  = TVarE  TypeExpr VarIndex -- otherwise name clash with TypeExpr's TVar
  | TLit   TypeExpr Literal
  | TComb  TypeExpr CombType QName [TExpr]
  | TLet   [((VarIndex, TypeExpr), TExpr)] TExpr
  | TFree  [(VarIndex, TypeExpr)] TExpr
  | TOr    TExpr TExpr
  | TCase  CaseType TExpr [TBranchExpr]
  | TTyped TExpr TypeExpr
  deriving (TExpr -> TExpr -> Bool
(TExpr -> TExpr -> Bool) -> (TExpr -> TExpr -> Bool) -> Eq TExpr
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TExpr -> TExpr -> Bool
$c/= :: TExpr -> TExpr -> Bool
== :: TExpr -> TExpr -> Bool
$c== :: TExpr -> TExpr -> Bool
Eq, ReadPrec [TExpr]
ReadPrec TExpr
Int -> ReadS TExpr
ReadS [TExpr]
(Int -> ReadS TExpr)
-> ReadS [TExpr]
-> ReadPrec TExpr
-> ReadPrec [TExpr]
-> Read TExpr
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [TExpr]
$creadListPrec :: ReadPrec [TExpr]
readPrec :: ReadPrec TExpr
$creadPrec :: ReadPrec TExpr
readList :: ReadS [TExpr]
$creadList :: ReadS [TExpr]
readsPrec :: Int -> ReadS TExpr
$creadsPrec :: Int -> ReadS TExpr
Read, Int -> TExpr -> ShowS
[TExpr] -> ShowS
TExpr -> String
(Int -> TExpr -> ShowS)
-> (TExpr -> String) -> ([TExpr] -> ShowS) -> Show TExpr
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TExpr] -> ShowS
$cshowList :: [TExpr] -> ShowS
show :: TExpr -> String
$cshow :: TExpr -> String
showsPrec :: Int -> TExpr -> ShowS
$cshowsPrec :: Int -> TExpr -> ShowS
Show)

data TBranchExpr = TBranch TPattern TExpr
  deriving (TBranchExpr -> TBranchExpr -> Bool
(TBranchExpr -> TBranchExpr -> Bool)
-> (TBranchExpr -> TBranchExpr -> Bool) -> Eq TBranchExpr
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TBranchExpr -> TBranchExpr -> Bool
$c/= :: TBranchExpr -> TBranchExpr -> Bool
== :: TBranchExpr -> TBranchExpr -> Bool
$c== :: TBranchExpr -> TBranchExpr -> Bool
Eq, ReadPrec [TBranchExpr]
ReadPrec TBranchExpr
Int -> ReadS TBranchExpr
ReadS [TBranchExpr]
(Int -> ReadS TBranchExpr)
-> ReadS [TBranchExpr]
-> ReadPrec TBranchExpr
-> ReadPrec [TBranchExpr]
-> Read TBranchExpr
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [TBranchExpr]
$creadListPrec :: ReadPrec [TBranchExpr]
readPrec :: ReadPrec TBranchExpr
$creadPrec :: ReadPrec TBranchExpr
readList :: ReadS [TBranchExpr]
$creadList :: ReadS [TBranchExpr]
readsPrec :: Int -> ReadS TBranchExpr
$creadsPrec :: Int -> ReadS TBranchExpr
Read, Int -> TBranchExpr -> ShowS
[TBranchExpr] -> ShowS
TBranchExpr -> String
(Int -> TBranchExpr -> ShowS)
-> (TBranchExpr -> String)
-> ([TBranchExpr] -> ShowS)
-> Show TBranchExpr
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TBranchExpr] -> ShowS
$cshowList :: [TBranchExpr] -> ShowS
show :: TBranchExpr -> String
$cshow :: TBranchExpr -> String
showsPrec :: Int -> TBranchExpr -> ShowS
$cshowsPrec :: Int -> TBranchExpr -> ShowS
Show)

data TPattern
  = TPattern  TypeExpr QName [(VarIndex, TypeExpr)]
  | TLPattern TypeExpr Literal
  deriving (TPattern -> TPattern -> Bool
(TPattern -> TPattern -> Bool)
-> (TPattern -> TPattern -> Bool) -> Eq TPattern
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TPattern -> TPattern -> Bool
$c/= :: TPattern -> TPattern -> Bool
== :: TPattern -> TPattern -> Bool
$c== :: TPattern -> TPattern -> Bool
Eq, ReadPrec [TPattern]
ReadPrec TPattern
Int -> ReadS TPattern
ReadS [TPattern]
(Int -> ReadS TPattern)
-> ReadS [TPattern]
-> ReadPrec TPattern
-> ReadPrec [TPattern]
-> Read TPattern
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [TPattern]
$creadListPrec :: ReadPrec [TPattern]
readPrec :: ReadPrec TPattern
$creadPrec :: ReadPrec TPattern
readList :: ReadS [TPattern]
$creadList :: ReadS [TPattern]
readsPrec :: Int -> ReadS TPattern
$creadsPrec :: Int -> ReadS TPattern
Read, Int -> TPattern -> ShowS
[TPattern] -> ShowS
TPattern -> String
(Int -> TPattern -> ShowS)
-> (TPattern -> String) -> ([TPattern] -> ShowS) -> Show TPattern
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TPattern] -> ShowS
$cshowList :: [TPattern] -> ShowS
show :: TPattern -> String
$cshow :: TPattern -> String
showsPrec :: Int -> TPattern -> ShowS
$cshowsPrec :: Int -> TPattern -> ShowS
Show)

instance Typeable TRule where
  typeOf :: TRule -> TypeExpr
typeOf (TRule args :: [(Int, TypeExpr)]
args e :: TExpr
e) = ((Int, TypeExpr) -> TypeExpr -> TypeExpr)
-> TypeExpr -> [(Int, TypeExpr)] -> TypeExpr
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr (TypeExpr -> TypeExpr -> TypeExpr
FuncType (TypeExpr -> TypeExpr -> TypeExpr)
-> ((Int, TypeExpr) -> TypeExpr)
-> (Int, TypeExpr)
-> TypeExpr
-> TypeExpr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int, TypeExpr) -> TypeExpr
forall a b. (a, b) -> b
snd) (TExpr -> TypeExpr
forall a. Typeable a => a -> TypeExpr
typeOf TExpr
e) [(Int, TypeExpr)]
args
  typeOf (TExternal ty :: TypeExpr
ty _) = TypeExpr
ty

instance Typeable TExpr where
  typeOf :: TExpr -> TypeExpr
typeOf (TVarE ty :: TypeExpr
ty _) = TypeExpr
ty
  typeOf (TLit ty :: TypeExpr
ty _) = TypeExpr
ty
  typeOf (TComb  ty :: TypeExpr
ty _ _ _) = TypeExpr
ty
  typeOf (TLet _ e :: TExpr
e) = TExpr -> TypeExpr
forall a. Typeable a => a -> TypeExpr
typeOf TExpr
e
  typeOf (TFree _ e :: TExpr
e) = TExpr -> TypeExpr
forall a. Typeable a => a -> TypeExpr
typeOf TExpr
e
  typeOf (TOr e :: TExpr
e _) = TExpr -> TypeExpr
forall a. Typeable a => a -> TypeExpr
typeOf TExpr
e
  typeOf (TCase _ _ (e :: TBranchExpr
e:_)) = TBranchExpr -> TypeExpr
forall a. Typeable a => a -> TypeExpr
typeOf TBranchExpr
e
  typeOf (TTyped _ ty :: TypeExpr
ty) = TypeExpr
ty
  typeOf (TCase _ _ []) = String -> TypeExpr
forall a. HasCallStack => String -> a
error (String -> TypeExpr) -> String -> TypeExpr
forall a b. (a -> b) -> a -> b
$ "Curry.FlatCurry.Typed.Type.typeOf: " String -> ShowS
forall a. [a] -> [a] -> [a]
++
                                  "empty list in case expression"

instance Typeable TPattern where
  typeOf :: TPattern -> TypeExpr
typeOf (TPattern ty :: TypeExpr
ty _ _) = TypeExpr
ty
  typeOf (TLPattern ty :: TypeExpr
ty _) = TypeExpr
ty

instance Typeable TBranchExpr where
  typeOf :: TBranchExpr -> TypeExpr
typeOf (TBranch _ e :: TExpr
e) = TExpr -> TypeExpr
forall a. Typeable a => a -> TypeExpr
typeOf TExpr
e

instance Binary TProg where
  put :: TProg -> Put
put (TProg mid :: String
mid im :: [String]
im tys :: [TypeDecl]
tys fus :: [TFuncDecl]
fus ops :: [OpDecl]
ops) =
    String -> Put
forall t. Binary t => t -> Put
put String
mid Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [String] -> Put
forall t. Binary t => t -> Put
put [String]
im Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [TypeDecl] -> Put
forall t. Binary t => t -> Put
put [TypeDecl]
tys Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [TFuncDecl] -> Put
forall t. Binary t => t -> Put
put [TFuncDecl]
fus Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [OpDecl] -> Put
forall t. Binary t => t -> Put
put [OpDecl]
ops
  get :: Get TProg
get = String
-> [String] -> [TypeDecl] -> [TFuncDecl] -> [OpDecl] -> TProg
TProg (String
 -> [String] -> [TypeDecl] -> [TFuncDecl] -> [OpDecl] -> TProg)
-> Get String
-> Get ([String] -> [TypeDecl] -> [TFuncDecl] -> [OpDecl] -> TProg)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Get String
forall t. Binary t => Get t
get Get ([String] -> [TypeDecl] -> [TFuncDecl] -> [OpDecl] -> TProg)
-> Get [String]
-> Get ([TypeDecl] -> [TFuncDecl] -> [OpDecl] -> TProg)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Get [String]
forall t. Binary t => Get t
get Get ([TypeDecl] -> [TFuncDecl] -> [OpDecl] -> TProg)
-> Get [TypeDecl] -> Get ([TFuncDecl] -> [OpDecl] -> TProg)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Get [TypeDecl]
forall t. Binary t => Get t
get Get ([TFuncDecl] -> [OpDecl] -> TProg)
-> Get [TFuncDecl] -> Get ([OpDecl] -> TProg)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Get [TFuncDecl]
forall t. Binary t => Get t
get Get ([OpDecl] -> TProg) -> Get [OpDecl] -> Get TProg
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Get [OpDecl]
forall t. Binary t => Get t
get

instance Binary TFuncDecl where
  put :: TFuncDecl -> Put
put (TFunc qid :: QName
qid arity :: Int
arity vis :: Visibility
vis ty :: TypeExpr
ty r :: TRule
r) =
    QName -> Put
forall t. Binary t => t -> Put
put QName
qid Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Put
forall t. Binary t => t -> Put
put Int
arity Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Visibility -> Put
forall t. Binary t => t -> Put
put Visibility
vis Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> TypeExpr -> Put
forall t. Binary t => t -> Put
put TypeExpr
ty Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> TRule -> Put
forall t. Binary t => t -> Put
put TRule
r
  get :: Get TFuncDecl
get = QName -> Int -> Visibility -> TypeExpr -> TRule -> TFuncDecl
TFunc (QName -> Int -> Visibility -> TypeExpr -> TRule -> TFuncDecl)
-> Get QName
-> Get (Int -> Visibility -> TypeExpr -> TRule -> TFuncDecl)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Get QName
forall t. Binary t => Get t
get Get (Int -> Visibility -> TypeExpr -> TRule -> TFuncDecl)
-> Get Int -> Get (Visibility -> TypeExpr -> TRule -> TFuncDecl)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Get Int
forall t. Binary t => Get t
get Get (Visibility -> TypeExpr -> TRule -> TFuncDecl)
-> Get Visibility -> Get (TypeExpr -> TRule -> TFuncDecl)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Get Visibility
forall t. Binary t => Get t
get Get (TypeExpr -> TRule -> TFuncDecl)
-> Get TypeExpr -> Get (TRule -> TFuncDecl)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Get TypeExpr
forall t. Binary t => Get t
get Get (TRule -> TFuncDecl) -> Get TRule -> Get TFuncDecl
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Get TRule
forall t. Binary t => Get t
get

instance Binary TRule where
  put :: TRule -> Put
put (TRule     alts :: [(Int, TypeExpr)]
alts e :: TExpr
e) = Word8 -> Put
putWord8 0 Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [(Int, TypeExpr)] -> Put
forall t. Binary t => t -> Put
put [(Int, TypeExpr)]
alts Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> TExpr -> Put
forall t. Binary t => t -> Put
put TExpr
e
  put (TExternal ty :: TypeExpr
ty n :: String
n  ) = Word8 -> Put
putWord8 1 Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> TypeExpr -> Put
forall t. Binary t => t -> Put
put TypeExpr
ty   Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> String -> Put
forall t. Binary t => t -> Put
put String
n

  get :: Get TRule
get = do
    Word8
x <- Get Word8
getWord8
    case Word8
x of
      0 -> ([(Int, TypeExpr)] -> TExpr -> TRule)
-> Get [(Int, TypeExpr)] -> Get TExpr -> Get TRule
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 [(Int, TypeExpr)] -> TExpr -> TRule
TRule Get [(Int, TypeExpr)]
forall t. Binary t => Get t
get Get TExpr
forall t. Binary t => Get t
get
      1 -> (TypeExpr -> String -> TRule)
-> Get TypeExpr -> Get String -> Get TRule
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 TypeExpr -> String -> TRule
TExternal Get TypeExpr
forall t. Binary t => Get t
get Get String
forall t. Binary t => Get t
get
      _ -> String -> Get TRule
forall (m :: * -> *) a. MonadFail m => String -> m a
fail "Invalid encoding for TRule"

instance Binary TExpr where
  put :: TExpr -> Put
put (TVarE ty :: TypeExpr
ty v :: Int
v) = Word8 -> Put
putWord8 0 Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> TypeExpr -> Put
forall t. Binary t => t -> Put
put TypeExpr
ty Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Put
forall t. Binary t => t -> Put
put Int
v
  put (TLit  ty :: TypeExpr
ty l :: Literal
l) = Word8 -> Put
putWord8 1 Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> TypeExpr -> Put
forall t. Binary t => t -> Put
put TypeExpr
ty Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Literal -> Put
forall t. Binary t => t -> Put
put Literal
l
  put (TComb ty :: TypeExpr
ty cty :: CombType
cty qid :: QName
qid es :: [TExpr]
es) =
    Word8 -> Put
putWord8 2 Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> TypeExpr -> Put
forall t. Binary t => t -> Put
put TypeExpr
ty Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> CombType -> Put
forall t. Binary t => t -> Put
put CombType
cty Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> QName -> Put
forall t. Binary t => t -> Put
put QName
qid Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [TExpr] -> Put
forall t. Binary t => t -> Put
put [TExpr]
es
  put (TLet  bs :: [((Int, TypeExpr), TExpr)]
bs e :: TExpr
e) = Word8 -> Put
putWord8 3 Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [((Int, TypeExpr), TExpr)] -> Put
forall t. Binary t => t -> Put
put [((Int, TypeExpr), TExpr)]
bs Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> TExpr -> Put
forall t. Binary t => t -> Put
put TExpr
e
  put (TFree vs :: [(Int, TypeExpr)]
vs e :: TExpr
e) = Word8 -> Put
putWord8 4 Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [(Int, TypeExpr)] -> Put
forall t. Binary t => t -> Put
put [(Int, TypeExpr)]
vs Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> TExpr -> Put
forall t. Binary t => t -> Put
put TExpr
e
  put (TOr  e1 :: TExpr
e1 e2 :: TExpr
e2) = Word8 -> Put
putWord8 5 Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> TExpr -> Put
forall t. Binary t => t -> Put
put TExpr
e1 Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> TExpr -> Put
forall t. Binary t => t -> Put
put TExpr
e2
  put (TCase cty :: CaseType
cty ty :: TExpr
ty as :: [TBranchExpr]
as) = Word8 -> Put
putWord8 6 Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> CaseType -> Put
forall t. Binary t => t -> Put
put CaseType
cty Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> TExpr -> Put
forall t. Binary t => t -> Put
put TExpr
ty Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [TBranchExpr] -> Put
forall t. Binary t => t -> Put
put [TBranchExpr]
as
  put (TTyped e :: TExpr
e ty :: TypeExpr
ty) = Word8 -> Put
putWord8 7 Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> TExpr -> Put
forall t. Binary t => t -> Put
put TExpr
e Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> TypeExpr -> Put
forall t. Binary t => t -> Put
put TypeExpr
ty

  get :: Get TExpr
get = do
    Word8
x <- Get Word8
getWord8
    case Word8
x of
      0 -> (TypeExpr -> Int -> TExpr) -> Get TypeExpr -> Get Int -> Get TExpr
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 TypeExpr -> Int -> TExpr
TVarE Get TypeExpr
forall t. Binary t => Get t
get Get Int
forall t. Binary t => Get t
get
      1 -> (TypeExpr -> Literal -> TExpr)
-> Get TypeExpr -> Get Literal -> Get TExpr
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 TypeExpr -> Literal -> TExpr
TLit Get TypeExpr
forall t. Binary t => Get t
get Get Literal
forall t. Binary t => Get t
get
      2 -> (TypeExpr -> CombType -> QName -> [TExpr] -> TExpr)
-> Get TypeExpr
-> Get CombType
-> Get QName
-> Get [TExpr]
-> Get TExpr
forall (m :: * -> *) a1 a2 a3 a4 r.
Monad m =>
(a1 -> a2 -> a3 -> a4 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m r
liftM4 TypeExpr -> CombType -> QName -> [TExpr] -> TExpr
TComb Get TypeExpr
forall t. Binary t => Get t
get Get CombType
forall t. Binary t => Get t
get Get QName
forall t. Binary t => Get t
get Get [TExpr]
forall t. Binary t => Get t
get
      3 -> ([((Int, TypeExpr), TExpr)] -> TExpr -> TExpr)
-> Get [((Int, TypeExpr), TExpr)] -> Get TExpr -> Get TExpr
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 [((Int, TypeExpr), TExpr)] -> TExpr -> TExpr
TLet Get [((Int, TypeExpr), TExpr)]
forall t. Binary t => Get t
get Get TExpr
forall t. Binary t => Get t
get
      4 -> ([(Int, TypeExpr)] -> TExpr -> TExpr)
-> Get [(Int, TypeExpr)] -> Get TExpr -> Get TExpr
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 [(Int, TypeExpr)] -> TExpr -> TExpr
TFree Get [(Int, TypeExpr)]
forall t. Binary t => Get t
get Get TExpr
forall t. Binary t => Get t
get
      5 -> (TExpr -> TExpr -> TExpr) -> Get TExpr -> Get TExpr -> Get TExpr
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 TExpr -> TExpr -> TExpr
TOr Get TExpr
forall t. Binary t => Get t
get Get TExpr
forall t. Binary t => Get t
get
      6 -> (CaseType -> TExpr -> [TBranchExpr] -> TExpr)
-> Get CaseType -> Get TExpr -> Get [TBranchExpr] -> Get TExpr
forall (m :: * -> *) a1 a2 a3 r.
Monad m =>
(a1 -> a2 -> a3 -> r) -> m a1 -> m a2 -> m a3 -> m r
liftM3 CaseType -> TExpr -> [TBranchExpr] -> TExpr
TCase Get CaseType
forall t. Binary t => Get t
get Get TExpr
forall t. Binary t => Get t
get Get [TBranchExpr]
forall t. Binary t => Get t
get
      7 -> (TExpr -> TypeExpr -> TExpr)
-> Get TExpr -> Get TypeExpr -> Get TExpr
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 TExpr -> TypeExpr -> TExpr
TTyped Get TExpr
forall t. Binary t => Get t
get Get TypeExpr
forall t. Binary t => Get t
get
      _ -> String -> Get TExpr
forall (m :: * -> *) a. MonadFail m => String -> m a
fail "Invalid encoding for TExpr"

instance Binary TBranchExpr where
  put :: TBranchExpr -> Put
put (TBranch p :: TPattern
p e :: TExpr
e) = TPattern -> Put
forall t. Binary t => t -> Put
put TPattern
p Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> TExpr -> Put
forall t. Binary t => t -> Put
put TExpr
e
  get :: Get TBranchExpr
get = (TPattern -> TExpr -> TBranchExpr)
-> Get TPattern -> Get TExpr -> Get TBranchExpr
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 TPattern -> TExpr -> TBranchExpr
TBranch Get TPattern
forall t. Binary t => Get t
get Get TExpr
forall t. Binary t => Get t
get

instance Binary TPattern where
  put :: TPattern -> Put
put (TPattern  ty :: TypeExpr
ty qid :: QName
qid vs :: [(Int, TypeExpr)]
vs) = Word8 -> Put
putWord8 0 Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> TypeExpr -> Put
forall t. Binary t => t -> Put
put TypeExpr
ty Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> QName -> Put
forall t. Binary t => t -> Put
put QName
qid Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [(Int, TypeExpr)] -> Put
forall t. Binary t => t -> Put
put [(Int, TypeExpr)]
vs
  put (TLPattern ty :: TypeExpr
ty l :: Literal
l     ) = Word8 -> Put
putWord8 1 Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> TypeExpr -> Put
forall t. Binary t => t -> Put
put TypeExpr
ty Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Literal -> Put
forall t. Binary t => t -> Put
put Literal
l

  get :: Get TPattern
get = do
    Word8
x <- Get Word8
getWord8
    case Word8
x of
      0 -> (TypeExpr -> QName -> [(Int, TypeExpr)] -> TPattern)
-> Get TypeExpr
-> Get QName
-> Get [(Int, TypeExpr)]
-> Get TPattern
forall (m :: * -> *) a1 a2 a3 r.
Monad m =>
(a1 -> a2 -> a3 -> r) -> m a1 -> m a2 -> m a3 -> m r
liftM3 TypeExpr -> QName -> [(Int, TypeExpr)] -> TPattern
TPattern Get TypeExpr
forall t. Binary t => Get t
get Get QName
forall t. Binary t => Get t
get Get [(Int, TypeExpr)]
forall t. Binary t => Get t
get
      1 -> (TypeExpr -> Literal -> TPattern)
-> Get TypeExpr -> Get Literal -> Get TPattern
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 TypeExpr -> Literal -> TPattern
TLPattern Get TypeExpr
forall t. Binary t => Get t
get Get Literal
forall t. Binary t => Get t
get
      _ -> String -> Get TPattern
forall (m :: * -> *) a. MonadFail m => String -> m a
fail "Invalid encoding for TPattern"