module Type.Ord.SpineSerialize
(module Type.Ord.SpineSerialize,
module Type.Spine, module Type.Serialize, module Type.Ord) where
import Type.Spine
import Type.Serialize
import Type.Ord hiding (Compare)
import qualified Type.Ord as Ord
import Language.Haskell.TH (Name, Q, Dec)
type SpineCompare l r = Ord.Compare (Spine l) (Spine r)
type Compare l r = SpineCompare l r
type instance Ord.Compare (Atom l) (Atom r) =
Ord.Compare (Serialize l) (Serialize r)
type instance Ord.Compare (lx :@ ly) (rx :@ ry) =
OrdCase (Ord.Compare (Spine lx) (Spine rx))
LT
(Ord.Compare (Spine ly) (Spine ry))
GT
type instance Ord.Compare (Atom l) (rx :@ ry) = LT
type instance Ord.Compare (lx :@ ly) (Atom r) = GT
spineSerializeType :: Name -> Q [Dec]
spineSerializeType n = do
x <- serializeType_data n
y <- spineType_d n
return $ x ++ y
spineSerializeTypeAsHash :: Name -> Q [Dec]
spineSerializeTypeAsHash n = do
x <- serializeTypeAsHash_data n
y <- spineType_d n
return $ x ++ y
spineSerializeType_pro :: Name -> Q [Dec]
spineSerializeType_pro n = do
x <- serializeType_pro n
y <- spineType_pro n
return $ x ++ y
spineSerializeTypeAsHash_pro :: Name -> Q [Dec]
spineSerializeTypeAsHash_pro n = do
x <- serializeTypeAsHash_pro n
y <- spineType_pro n
return $ x ++ y