module Isabelle.IsaExport where

import Text.XML.HaXml.XmlContent hiding (Const)
import Text.XML.HaXml.OneOfN
import Text.XML.HaXml.Types


{-Type decls-}

newtype Export = Export (List1 Thy)   deriving (Export -> Export -> Bool
(Export -> Export -> Bool)
-> (Export -> Export -> Bool) -> Eq Export
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Export -> Export -> Bool
$c/= :: Export -> Export -> Bool
== :: Export -> Export -> Bool
$c== :: Export -> Export -> Bool
Eq,Int -> Export -> ShowS
[Export] -> ShowS
Export -> String
(Int -> Export -> ShowS)
-> (Export -> String) -> ([Export] -> ShowS) -> Show Export
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Export] -> ShowS
$cshowList :: [Export] -> ShowS
show :: Export -> String
$cshow :: Export -> String
showsPrec :: Int -> Export -> ShowS
$cshowsPrec :: Int -> Export -> ShowS
Show)
data Thy = Thy Thy_Attrs (List1 Import) [Keyword] [UseFile] Body
         deriving (Thy -> Thy -> Bool
(Thy -> Thy -> Bool) -> (Thy -> Thy -> Bool) -> Eq Thy
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Thy -> Thy -> Bool
$c/= :: Thy -> Thy -> Bool
== :: Thy -> Thy -> Bool
$c== :: Thy -> Thy -> Bool
Eq,Int -> Thy -> ShowS
[Thy] -> ShowS
Thy -> String
(Int -> Thy -> ShowS)
-> (Thy -> String) -> ([Thy] -> ShowS) -> Show Thy
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Thy] -> ShowS
$cshowList :: [Thy] -> ShowS
show :: Thy -> String
$cshow :: Thy -> String
showsPrec :: Int -> Thy -> ShowS
$cshowsPrec :: Int -> Thy -> ShowS
Show)
data Thy_Attrs = Thy_Attrs
    { Thy_Attrs -> String
thyName :: String
    , Thy_Attrs -> Maybe String
thyHeader :: (Maybe String)
    } deriving (Thy_Attrs -> Thy_Attrs -> Bool
(Thy_Attrs -> Thy_Attrs -> Bool)
-> (Thy_Attrs -> Thy_Attrs -> Bool) -> Eq Thy_Attrs
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Thy_Attrs -> Thy_Attrs -> Bool
$c/= :: Thy_Attrs -> Thy_Attrs -> Bool
== :: Thy_Attrs -> Thy_Attrs -> Bool
$c== :: Thy_Attrs -> Thy_Attrs -> Bool
Eq,Int -> Thy_Attrs -> ShowS
[Thy_Attrs] -> ShowS
Thy_Attrs -> String
(Int -> Thy_Attrs -> ShowS)
-> (Thy_Attrs -> String)
-> ([Thy_Attrs] -> ShowS)
-> Show Thy_Attrs
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Thy_Attrs] -> ShowS
$cshowList :: [Thy_Attrs] -> ShowS
show :: Thy_Attrs -> String
$cshow :: Thy_Attrs -> String
showsPrec :: Int -> Thy_Attrs -> ShowS
$cshowsPrec :: Int -> Thy_Attrs -> ShowS
Show)
data Keyword = Keyword
    { Keyword -> String
keywordName :: String
    } deriving (Keyword -> Keyword -> Bool
(Keyword -> Keyword -> Bool)
-> (Keyword -> Keyword -> Bool) -> Eq Keyword
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Keyword -> Keyword -> Bool
$c/= :: Keyword -> Keyword -> Bool
== :: Keyword -> Keyword -> Bool
$c== :: Keyword -> Keyword -> Bool
Eq,Int -> Keyword -> ShowS
[Keyword] -> ShowS
Keyword -> String
(Int -> Keyword -> ShowS)
-> (Keyword -> String) -> ([Keyword] -> ShowS) -> Show Keyword
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Keyword] -> ShowS
$cshowList :: [Keyword] -> ShowS
show :: Keyword -> String
$cshow :: Keyword -> String
showsPrec :: Int -> Keyword -> ShowS
$cshowsPrec :: Int -> Keyword -> ShowS
Show)
data Import = Import
    { Import -> String
importName :: String
    } deriving (Import -> Import -> Bool
(Import -> Import -> Bool)
-> (Import -> Import -> Bool) -> Eq Import
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Import -> Import -> Bool
$c/= :: Import -> Import -> Bool
== :: Import -> Import -> Bool
$c== :: Import -> Import -> Bool
Eq,Int -> Import -> ShowS
[Import] -> ShowS
Import -> String
(Int -> Import -> ShowS)
-> (Import -> String) -> ([Import] -> ShowS) -> Show Import
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Import] -> ShowS
$cshowList :: [Import] -> ShowS
show :: Import -> String
$cshow :: Import -> String
showsPrec :: Int -> Import -> ShowS
$cshowsPrec :: Int -> Import -> ShowS
Show)
data UseFile = UseFile
    { UseFile -> String
useFileName :: String
    } deriving (UseFile -> UseFile -> Bool
(UseFile -> UseFile -> Bool)
-> (UseFile -> UseFile -> Bool) -> Eq UseFile
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UseFile -> UseFile -> Bool
$c/= :: UseFile -> UseFile -> Bool
== :: UseFile -> UseFile -> Bool
$c== :: UseFile -> UseFile -> Bool
Eq,Int -> UseFile -> ShowS
[UseFile] -> ShowS
UseFile -> String
(Int -> UseFile -> ShowS)
-> (UseFile -> String) -> ([UseFile] -> ShowS) -> Show UseFile
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [UseFile] -> ShowS
$cshowList :: [UseFile] -> ShowS
show :: UseFile -> String
$cshow :: UseFile -> String
showsPrec :: Int -> UseFile -> ShowS
$cshowsPrec :: Int -> UseFile -> ShowS
Show)
newtype Body = Body [Body_]   deriving (Body -> Body -> Bool
(Body -> Body -> Bool) -> (Body -> Body -> Bool) -> Eq Body
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Body -> Body -> Bool
$c/= :: Body -> Body -> Bool
== :: Body -> Body -> Bool
$c== :: Body -> Body -> Bool
Eq,Int -> Body -> ShowS
[Body] -> ShowS
Body -> String
(Int -> Body -> ShowS)
-> (Body -> String) -> ([Body] -> ShowS) -> Show Body
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Body] -> ShowS
$cshowList :: [Body] -> ShowS
show :: Body -> String
$cshow :: Body -> String
showsPrec :: Int -> Body -> ShowS
$cshowsPrec :: Int -> Body -> ShowS
Show)
data Body_ = Body_Locale Locale
           | Body_Cls Cls
           | Body_TypeSynonym TypeSynonym
           | Body_Datatypes Datatypes
           | Body_Domains Domains
           | Body_Consts Consts
           | Body_Axioms Axioms
           | Body_Lemma Lemma
           | Body_Definition Definition
           | Body_Funs Funs
           | Body_Primrec Primrec
           | Body_Fixrec Fixrec
           | Body_Instantiation Instantiation
           | Body_Instance Instance
           | Body_Subclass Subclass
           | Body_Typedef Typedef
           | Body_Defs Defs
           deriving (Body_ -> Body_ -> Bool
(Body_ -> Body_ -> Bool) -> (Body_ -> Body_ -> Bool) -> Eq Body_
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Body_ -> Body_ -> Bool
$c/= :: Body_ -> Body_ -> Bool
== :: Body_ -> Body_ -> Bool
$c== :: Body_ -> Body_ -> Bool
Eq,Int -> Body_ -> ShowS
[Body_] -> ShowS
Body_ -> String
(Int -> Body_ -> ShowS)
-> (Body_ -> String) -> ([Body_] -> ShowS) -> Show Body_
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Body_] -> ShowS
$cshowList :: [Body_] -> ShowS
show :: Body_ -> String
$cshow :: Body_ -> String
showsPrec :: Int -> Body_ -> ShowS
$cshowsPrec :: Int -> Body_ -> ShowS
Show)
data Locale = Locale Locale_Attrs Ctxt [Parent] Body
            deriving (Locale -> Locale -> Bool
(Locale -> Locale -> Bool)
-> (Locale -> Locale -> Bool) -> Eq Locale
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Locale -> Locale -> Bool
$c/= :: Locale -> Locale -> Bool
== :: Locale -> Locale -> Bool
$c== :: Locale -> Locale -> Bool
Eq,Int -> Locale -> ShowS
[Locale] -> ShowS
Locale -> String
(Int -> Locale -> ShowS)
-> (Locale -> String) -> ([Locale] -> ShowS) -> Show Locale
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Locale] -> ShowS
$cshowList :: [Locale] -> ShowS
show :: Locale -> String
$cshow :: Locale -> String
showsPrec :: Int -> Locale -> ShowS
$cshowsPrec :: Int -> Locale -> ShowS
Show)
data Locale_Attrs = Locale_Attrs
    { Locale_Attrs -> String
localeName :: String
    } deriving (Locale_Attrs -> Locale_Attrs -> Bool
(Locale_Attrs -> Locale_Attrs -> Bool)
-> (Locale_Attrs -> Locale_Attrs -> Bool) -> Eq Locale_Attrs
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Locale_Attrs -> Locale_Attrs -> Bool
$c/= :: Locale_Attrs -> Locale_Attrs -> Bool
== :: Locale_Attrs -> Locale_Attrs -> Bool
$c== :: Locale_Attrs -> Locale_Attrs -> Bool
Eq,Int -> Locale_Attrs -> ShowS
[Locale_Attrs] -> ShowS
Locale_Attrs -> String
(Int -> Locale_Attrs -> ShowS)
-> (Locale_Attrs -> String)
-> ([Locale_Attrs] -> ShowS)
-> Show Locale_Attrs
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Locale_Attrs] -> ShowS
$cshowList :: [Locale_Attrs] -> ShowS
show :: Locale_Attrs -> String
$cshow :: Locale_Attrs -> String
showsPrec :: Int -> Locale_Attrs -> ShowS
$cshowsPrec :: Int -> Locale_Attrs -> ShowS
Show)
data Cls = Cls Cls_Attrs Ctxt [Parent] Body
         deriving (Cls -> Cls -> Bool
(Cls -> Cls -> Bool) -> (Cls -> Cls -> Bool) -> Eq Cls
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Cls -> Cls -> Bool
$c/= :: Cls -> Cls -> Bool
== :: Cls -> Cls -> Bool
$c== :: Cls -> Cls -> Bool
Eq,Int -> Cls -> ShowS
[Cls] -> ShowS
Cls -> String
(Int -> Cls -> ShowS)
-> (Cls -> String) -> ([Cls] -> ShowS) -> Show Cls
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Cls] -> ShowS
$cshowList :: [Cls] -> ShowS
show :: Cls -> String
$cshow :: Cls -> String
showsPrec :: Int -> Cls -> ShowS
$cshowsPrec :: Int -> Cls -> ShowS
Show)
data Cls_Attrs = Cls_Attrs
    { Cls_Attrs -> String
clsName :: String
    } deriving (Cls_Attrs -> Cls_Attrs -> Bool
(Cls_Attrs -> Cls_Attrs -> Bool)
-> (Cls_Attrs -> Cls_Attrs -> Bool) -> Eq Cls_Attrs
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Cls_Attrs -> Cls_Attrs -> Bool
$c/= :: Cls_Attrs -> Cls_Attrs -> Bool
== :: Cls_Attrs -> Cls_Attrs -> Bool
$c== :: Cls_Attrs -> Cls_Attrs -> Bool
Eq,Int -> Cls_Attrs -> ShowS
[Cls_Attrs] -> ShowS
Cls_Attrs -> String
(Int -> Cls_Attrs -> ShowS)
-> (Cls_Attrs -> String)
-> ([Cls_Attrs] -> ShowS)
-> Show Cls_Attrs
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Cls_Attrs] -> ShowS
$cshowList :: [Cls_Attrs] -> ShowS
show :: Cls_Attrs -> String
$cshow :: Cls_Attrs -> String
showsPrec :: Int -> Cls_Attrs -> ShowS
$cshowsPrec :: Int -> Cls_Attrs -> ShowS
Show)
data TypeSynonym = TypeSynonym TypeSynonym_Attrs (Maybe Mixfix)
                               Vars (OneOf3 TVar TFree Type)
                 deriving (TypeSynonym -> TypeSynonym -> Bool
(TypeSynonym -> TypeSynonym -> Bool)
-> (TypeSynonym -> TypeSynonym -> Bool) -> Eq TypeSynonym
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TypeSynonym -> TypeSynonym -> Bool
$c/= :: TypeSynonym -> TypeSynonym -> Bool
== :: TypeSynonym -> TypeSynonym -> Bool
$c== :: TypeSynonym -> TypeSynonym -> Bool
Eq,Int -> TypeSynonym -> ShowS
[TypeSynonym] -> ShowS
TypeSynonym -> String
(Int -> TypeSynonym -> ShowS)
-> (TypeSynonym -> String)
-> ([TypeSynonym] -> ShowS)
-> Show TypeSynonym
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TypeSynonym] -> ShowS
$cshowList :: [TypeSynonym] -> ShowS
show :: TypeSynonym -> String
$cshow :: TypeSynonym -> String
showsPrec :: Int -> TypeSynonym -> ShowS
$cshowsPrec :: Int -> TypeSynonym -> ShowS
Show)
data TypeSynonym_Attrs = TypeSynonym_Attrs
    { TypeSynonym_Attrs -> String
typeSynonymName :: String
    , TypeSynonym_Attrs -> Maybe String
typeSynonymTarget :: (Maybe String)
    } deriving (TypeSynonym_Attrs -> TypeSynonym_Attrs -> Bool
(TypeSynonym_Attrs -> TypeSynonym_Attrs -> Bool)
-> (TypeSynonym_Attrs -> TypeSynonym_Attrs -> Bool)
-> Eq TypeSynonym_Attrs
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TypeSynonym_Attrs -> TypeSynonym_Attrs -> Bool
$c/= :: TypeSynonym_Attrs -> TypeSynonym_Attrs -> Bool
== :: TypeSynonym_Attrs -> TypeSynonym_Attrs -> Bool
$c== :: TypeSynonym_Attrs -> TypeSynonym_Attrs -> Bool
Eq,Int -> TypeSynonym_Attrs -> ShowS
[TypeSynonym_Attrs] -> ShowS
TypeSynonym_Attrs -> String
(Int -> TypeSynonym_Attrs -> ShowS)
-> (TypeSynonym_Attrs -> String)
-> ([TypeSynonym_Attrs] -> ShowS)
-> Show TypeSynonym_Attrs
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TypeSynonym_Attrs] -> ShowS
$cshowList :: [TypeSynonym_Attrs] -> ShowS
show :: TypeSynonym_Attrs -> String
$cshow :: TypeSynonym_Attrs -> String
showsPrec :: Int -> TypeSynonym_Attrs -> ShowS
$cshowsPrec :: Int -> TypeSynonym_Attrs -> ShowS
Show)
newtype Datatypes = Datatypes (List1 Datatype)   deriving (Datatypes -> Datatypes -> Bool
(Datatypes -> Datatypes -> Bool)
-> (Datatypes -> Datatypes -> Bool) -> Eq Datatypes
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Datatypes -> Datatypes -> Bool
$c/= :: Datatypes -> Datatypes -> Bool
== :: Datatypes -> Datatypes -> Bool
$c== :: Datatypes -> Datatypes -> Bool
Eq,Int -> Datatypes -> ShowS
[Datatypes] -> ShowS
Datatypes -> String
(Int -> Datatypes -> ShowS)
-> (Datatypes -> String)
-> ([Datatypes] -> ShowS)
-> Show Datatypes
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Datatypes] -> ShowS
$cshowList :: [Datatypes] -> ShowS
show :: Datatypes -> String
$cshow :: Datatypes -> String
showsPrec :: Int -> Datatypes -> ShowS
$cshowsPrec :: Int -> Datatypes -> ShowS
Show)
data Datatype = Datatype Datatype_Attrs (Maybe Mixfix)
                         (List1 Constructor) [TFree]
              deriving (Datatype -> Datatype -> Bool
(Datatype -> Datatype -> Bool)
-> (Datatype -> Datatype -> Bool) -> Eq Datatype
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Datatype -> Datatype -> Bool
$c/= :: Datatype -> Datatype -> Bool
== :: Datatype -> Datatype -> Bool
$c== :: Datatype -> Datatype -> Bool
Eq,Int -> Datatype -> ShowS
[Datatype] -> ShowS
Datatype -> String
(Int -> Datatype -> ShowS)
-> (Datatype -> String) -> ([Datatype] -> ShowS) -> Show Datatype
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Datatype] -> ShowS
$cshowList :: [Datatype] -> ShowS
show :: Datatype -> String
$cshow :: Datatype -> String
showsPrec :: Int -> Datatype -> ShowS
$cshowsPrec :: Int -> Datatype -> ShowS
Show)
data Datatype_Attrs = Datatype_Attrs
    { Datatype_Attrs -> String
datatypeName :: String
    } deriving (Datatype_Attrs -> Datatype_Attrs -> Bool
(Datatype_Attrs -> Datatype_Attrs -> Bool)
-> (Datatype_Attrs -> Datatype_Attrs -> Bool) -> Eq Datatype_Attrs
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Datatype_Attrs -> Datatype_Attrs -> Bool
$c/= :: Datatype_Attrs -> Datatype_Attrs -> Bool
== :: Datatype_Attrs -> Datatype_Attrs -> Bool
$c== :: Datatype_Attrs -> Datatype_Attrs -> Bool
Eq,Int -> Datatype_Attrs -> ShowS
[Datatype_Attrs] -> ShowS
Datatype_Attrs -> String
(Int -> Datatype_Attrs -> ShowS)
-> (Datatype_Attrs -> String)
-> ([Datatype_Attrs] -> ShowS)
-> Show Datatype_Attrs
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Datatype_Attrs] -> ShowS
$cshowList :: [Datatype_Attrs] -> ShowS
show :: Datatype_Attrs -> String
$cshow :: Datatype_Attrs -> String
showsPrec :: Int -> Datatype_Attrs -> ShowS
$cshowsPrec :: Int -> Datatype_Attrs -> ShowS
Show)
data Constructor = Constructor Constructor_Attrs (Maybe Mixfix)
                               (OneOf3 TVar TFree Type) [(OneOf3 TVar TFree Type)]
                 deriving (Constructor -> Constructor -> Bool
(Constructor -> Constructor -> Bool)
-> (Constructor -> Constructor -> Bool) -> Eq Constructor
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Constructor -> Constructor -> Bool
$c/= :: Constructor -> Constructor -> Bool
== :: Constructor -> Constructor -> Bool
$c== :: Constructor -> Constructor -> Bool
Eq,Int -> Constructor -> ShowS
[Constructor] -> ShowS
Constructor -> String
(Int -> Constructor -> ShowS)
-> (Constructor -> String)
-> ([Constructor] -> ShowS)
-> Show Constructor
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Constructor] -> ShowS
$cshowList :: [Constructor] -> ShowS
show :: Constructor -> String
$cshow :: Constructor -> String
showsPrec :: Int -> Constructor -> ShowS
$cshowsPrec :: Int -> Constructor -> ShowS
Show)
data Constructor_Attrs = Constructor_Attrs
    { Constructor_Attrs -> Maybe String
constructorName :: (Maybe String)
    } deriving (Constructor_Attrs -> Constructor_Attrs -> Bool
(Constructor_Attrs -> Constructor_Attrs -> Bool)
-> (Constructor_Attrs -> Constructor_Attrs -> Bool)
-> Eq Constructor_Attrs
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Constructor_Attrs -> Constructor_Attrs -> Bool
$c/= :: Constructor_Attrs -> Constructor_Attrs -> Bool
== :: Constructor_Attrs -> Constructor_Attrs -> Bool
$c== :: Constructor_Attrs -> Constructor_Attrs -> Bool
Eq,Int -> Constructor_Attrs -> ShowS
[Constructor_Attrs] -> ShowS
Constructor_Attrs -> String
(Int -> Constructor_Attrs -> ShowS)
-> (Constructor_Attrs -> String)
-> ([Constructor_Attrs] -> ShowS)
-> Show Constructor_Attrs
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Constructor_Attrs] -> ShowS
$cshowList :: [Constructor_Attrs] -> ShowS
show :: Constructor_Attrs -> String
$cshow :: Constructor_Attrs -> String
showsPrec :: Int -> Constructor_Attrs -> ShowS
$cshowsPrec :: Int -> Constructor_Attrs -> ShowS
Show)
newtype Domains = Domains (List1 Domain)   deriving (Domains -> Domains -> Bool
(Domains -> Domains -> Bool)
-> (Domains -> Domains -> Bool) -> Eq Domains
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Domains -> Domains -> Bool
$c/= :: Domains -> Domains -> Bool
== :: Domains -> Domains -> Bool
$c== :: Domains -> Domains -> Bool
Eq,Int -> Domains -> ShowS
[Domains] -> ShowS
Domains -> String
(Int -> Domains -> ShowS)
-> (Domains -> String) -> ([Domains] -> ShowS) -> Show Domains
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Domains] -> ShowS
$cshowList :: [Domains] -> ShowS
show :: Domains -> String
$cshow :: Domains -> String
showsPrec :: Int -> Domains -> ShowS
$cshowsPrec :: Int -> Domains -> ShowS
Show)
data Domain = Domain Domain_Attrs (Maybe Mixfix) [TFree]
                     (List1 DomainConstructor)
            deriving (Domain -> Domain -> Bool
(Domain -> Domain -> Bool)
-> (Domain -> Domain -> Bool) -> Eq Domain
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Domain -> Domain -> Bool
$c/= :: Domain -> Domain -> Bool
== :: Domain -> Domain -> Bool
$c== :: Domain -> Domain -> Bool
Eq,Int -> Domain -> ShowS
[Domain] -> ShowS
Domain -> String
(Int -> Domain -> ShowS)
-> (Domain -> String) -> ([Domain] -> ShowS) -> Show Domain
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Domain] -> ShowS
$cshowList :: [Domain] -> ShowS
show :: Domain -> String
$cshow :: Domain -> String
showsPrec :: Int -> Domain -> ShowS
$cshowsPrec :: Int -> Domain -> ShowS
Show)
data Domain_Attrs = Domain_Attrs
    { Domain_Attrs -> String
domainName :: String
    } deriving (Domain_Attrs -> Domain_Attrs -> Bool
(Domain_Attrs -> Domain_Attrs -> Bool)
-> (Domain_Attrs -> Domain_Attrs -> Bool) -> Eq Domain_Attrs
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Domain_Attrs -> Domain_Attrs -> Bool
$c/= :: Domain_Attrs -> Domain_Attrs -> Bool
== :: Domain_Attrs -> Domain_Attrs -> Bool
$c== :: Domain_Attrs -> Domain_Attrs -> Bool
Eq,Int -> Domain_Attrs -> ShowS
[Domain_Attrs] -> ShowS
Domain_Attrs -> String
(Int -> Domain_Attrs -> ShowS)
-> (Domain_Attrs -> String)
-> ([Domain_Attrs] -> ShowS)
-> Show Domain_Attrs
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Domain_Attrs] -> ShowS
$cshowList :: [Domain_Attrs] -> ShowS
show :: Domain_Attrs -> String
$cshow :: Domain_Attrs -> String
showsPrec :: Int -> Domain_Attrs -> ShowS
$cshowsPrec :: Int -> Domain_Attrs -> ShowS
Show)
data DomainConstructor = DomainConstructor DomainConstructor_Attrs
                                           (OneOf3 TVar TFree Type) [DomainConstructorArg]
                       deriving (DomainConstructor -> DomainConstructor -> Bool
(DomainConstructor -> DomainConstructor -> Bool)
-> (DomainConstructor -> DomainConstructor -> Bool)
-> Eq DomainConstructor
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DomainConstructor -> DomainConstructor -> Bool
$c/= :: DomainConstructor -> DomainConstructor -> Bool
== :: DomainConstructor -> DomainConstructor -> Bool
$c== :: DomainConstructor -> DomainConstructor -> Bool
Eq,Int -> DomainConstructor -> ShowS
[DomainConstructor] -> ShowS
DomainConstructor -> String
(Int -> DomainConstructor -> ShowS)
-> (DomainConstructor -> String)
-> ([DomainConstructor] -> ShowS)
-> Show DomainConstructor
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DomainConstructor] -> ShowS
$cshowList :: [DomainConstructor] -> ShowS
show :: DomainConstructor -> String
$cshow :: DomainConstructor -> String
showsPrec :: Int -> DomainConstructor -> ShowS
$cshowsPrec :: Int -> DomainConstructor -> ShowS
Show)
data DomainConstructor_Attrs = DomainConstructor_Attrs
    { DomainConstructor_Attrs -> String
domainConstructorName :: String
    } deriving (DomainConstructor_Attrs -> DomainConstructor_Attrs -> Bool
(DomainConstructor_Attrs -> DomainConstructor_Attrs -> Bool)
-> (DomainConstructor_Attrs -> DomainConstructor_Attrs -> Bool)
-> Eq DomainConstructor_Attrs
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DomainConstructor_Attrs -> DomainConstructor_Attrs -> Bool
$c/= :: DomainConstructor_Attrs -> DomainConstructor_Attrs -> Bool
== :: DomainConstructor_Attrs -> DomainConstructor_Attrs -> Bool
$c== :: DomainConstructor_Attrs -> DomainConstructor_Attrs -> Bool
Eq,Int -> DomainConstructor_Attrs -> ShowS
[DomainConstructor_Attrs] -> ShowS
DomainConstructor_Attrs -> String
(Int -> DomainConstructor_Attrs -> ShowS)
-> (DomainConstructor_Attrs -> String)
-> ([DomainConstructor_Attrs] -> ShowS)
-> Show DomainConstructor_Attrs
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DomainConstructor_Attrs] -> ShowS
$cshowList :: [DomainConstructor_Attrs] -> ShowS
show :: DomainConstructor_Attrs -> String
$cshow :: DomainConstructor_Attrs -> String
showsPrec :: Int -> DomainConstructor_Attrs -> ShowS
$cshowsPrec :: Int -> DomainConstructor_Attrs -> ShowS
Show)
data DomainConstructorArg = DomainConstructorArg DomainConstructorArg_Attrs
                                                 (OneOf3 TVar TFree Type)
                          deriving (DomainConstructorArg -> DomainConstructorArg -> Bool
(DomainConstructorArg -> DomainConstructorArg -> Bool)
-> (DomainConstructorArg -> DomainConstructorArg -> Bool)
-> Eq DomainConstructorArg
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DomainConstructorArg -> DomainConstructorArg -> Bool
$c/= :: DomainConstructorArg -> DomainConstructorArg -> Bool
== :: DomainConstructorArg -> DomainConstructorArg -> Bool
$c== :: DomainConstructorArg -> DomainConstructorArg -> Bool
Eq,Int -> DomainConstructorArg -> ShowS
[DomainConstructorArg] -> ShowS
DomainConstructorArg -> String
(Int -> DomainConstructorArg -> ShowS)
-> (DomainConstructorArg -> String)
-> ([DomainConstructorArg] -> ShowS)
-> Show DomainConstructorArg
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DomainConstructorArg] -> ShowS
$cshowList :: [DomainConstructorArg] -> ShowS
show :: DomainConstructorArg -> String
$cshow :: DomainConstructorArg -> String
showsPrec :: Int -> DomainConstructorArg -> ShowS
$cshowsPrec :: Int -> DomainConstructorArg -> ShowS
Show)
data DomainConstructorArg_Attrs = DomainConstructorArg_Attrs
    { DomainConstructorArg_Attrs -> Maybe String
domainConstructorArgLazy :: (Maybe String)
    , DomainConstructorArg_Attrs -> Maybe String
domainConstructorArgName :: (Maybe String)
    } deriving (DomainConstructorArg_Attrs -> DomainConstructorArg_Attrs -> Bool
(DomainConstructorArg_Attrs -> DomainConstructorArg_Attrs -> Bool)
-> (DomainConstructorArg_Attrs
    -> DomainConstructorArg_Attrs -> Bool)
-> Eq DomainConstructorArg_Attrs
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DomainConstructorArg_Attrs -> DomainConstructorArg_Attrs -> Bool
$c/= :: DomainConstructorArg_Attrs -> DomainConstructorArg_Attrs -> Bool
== :: DomainConstructorArg_Attrs -> DomainConstructorArg_Attrs -> Bool
$c== :: DomainConstructorArg_Attrs -> DomainConstructorArg_Attrs -> Bool
Eq,Int -> DomainConstructorArg_Attrs -> ShowS
[DomainConstructorArg_Attrs] -> ShowS
DomainConstructorArg_Attrs -> String
(Int -> DomainConstructorArg_Attrs -> ShowS)
-> (DomainConstructorArg_Attrs -> String)
-> ([DomainConstructorArg_Attrs] -> ShowS)
-> Show DomainConstructorArg_Attrs
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DomainConstructorArg_Attrs] -> ShowS
$cshowList :: [DomainConstructorArg_Attrs] -> ShowS
show :: DomainConstructorArg_Attrs -> String
$cshow :: DomainConstructorArg_Attrs -> String
showsPrec :: Int -> DomainConstructorArg_Attrs -> ShowS
$cshowsPrec :: Int -> DomainConstructorArg_Attrs -> ShowS
Show)
newtype Consts = Consts (List1 ConstDef)   deriving (Consts -> Consts -> Bool
(Consts -> Consts -> Bool)
-> (Consts -> Consts -> Bool) -> Eq Consts
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Consts -> Consts -> Bool
$c/= :: Consts -> Consts -> Bool
== :: Consts -> Consts -> Bool
$c== :: Consts -> Consts -> Bool
Eq,Int -> Consts -> ShowS
[Consts] -> ShowS
Consts -> String
(Int -> Consts -> ShowS)
-> (Consts -> String) -> ([Consts] -> ShowS) -> Show Consts
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Consts] -> ShowS
$cshowList :: [Consts] -> ShowS
show :: Consts -> String
$cshow :: Consts -> String
showsPrec :: Int -> Consts -> ShowS
$cshowsPrec :: Int -> Consts -> ShowS
Show)
data ConstDef = ConstDef ConstDef_Attrs (Maybe Mixfix)
                         (OneOf3 TVar TFree Type)
              deriving (ConstDef -> ConstDef -> Bool
(ConstDef -> ConstDef -> Bool)
-> (ConstDef -> ConstDef -> Bool) -> Eq ConstDef
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ConstDef -> ConstDef -> Bool
$c/= :: ConstDef -> ConstDef -> Bool
== :: ConstDef -> ConstDef -> Bool
$c== :: ConstDef -> ConstDef -> Bool
Eq,Int -> ConstDef -> ShowS
[ConstDef] -> ShowS
ConstDef -> String
(Int -> ConstDef -> ShowS)
-> (ConstDef -> String) -> ([ConstDef] -> ShowS) -> Show ConstDef
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ConstDef] -> ShowS
$cshowList :: [ConstDef] -> ShowS
show :: ConstDef -> String
$cshow :: ConstDef -> String
showsPrec :: Int -> ConstDef -> ShowS
$cshowsPrec :: Int -> ConstDef -> ShowS
Show)
data ConstDef_Attrs = ConstDef_Attrs
    { ConstDef_Attrs -> String
constDefName :: String
    } deriving (ConstDef_Attrs -> ConstDef_Attrs -> Bool
(ConstDef_Attrs -> ConstDef_Attrs -> Bool)
-> (ConstDef_Attrs -> ConstDef_Attrs -> Bool) -> Eq ConstDef_Attrs
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ConstDef_Attrs -> ConstDef_Attrs -> Bool
$c/= :: ConstDef_Attrs -> ConstDef_Attrs -> Bool
== :: ConstDef_Attrs -> ConstDef_Attrs -> Bool
$c== :: ConstDef_Attrs -> ConstDef_Attrs -> Bool
Eq,Int -> ConstDef_Attrs -> ShowS
[ConstDef_Attrs] -> ShowS
ConstDef_Attrs -> String
(Int -> ConstDef_Attrs -> ShowS)
-> (ConstDef_Attrs -> String)
-> ([ConstDef_Attrs] -> ShowS)
-> Show ConstDef_Attrs
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ConstDef_Attrs] -> ShowS
$cshowList :: [ConstDef_Attrs] -> ShowS
show :: ConstDef_Attrs -> String
$cshow :: ConstDef_Attrs -> String
showsPrec :: Int -> ConstDef_Attrs -> ShowS
$cshowsPrec :: Int -> ConstDef_Attrs -> ShowS
Show)
newtype Axioms = Axioms (List1 Axiom)   deriving (Axioms -> Axioms -> Bool
(Axioms -> Axioms -> Bool)
-> (Axioms -> Axioms -> Bool) -> Eq Axioms
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Axioms -> Axioms -> Bool
$c/= :: Axioms -> Axioms -> Bool
== :: Axioms -> Axioms -> Bool
$c== :: Axioms -> Axioms -> Bool
Eq,Int -> Axioms -> ShowS
[Axioms] -> ShowS
Axioms -> String
(Int -> Axioms -> ShowS)
-> (Axioms -> String) -> ([Axioms] -> ShowS) -> Show Axioms
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Axioms] -> ShowS
$cshowList :: [Axioms] -> ShowS
show :: Axioms -> String
$cshow :: Axioms -> String
showsPrec :: Int -> Axioms -> ShowS
$cshowsPrec :: Int -> Axioms -> ShowS
Show)
data Axiom = Axiom Axiom_Attrs
                   (OneOf6 Bound Free Var Const App Abs)
           deriving (Axiom -> Axiom -> Bool
(Axiom -> Axiom -> Bool) -> (Axiom -> Axiom -> Bool) -> Eq Axiom
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Axiom -> Axiom -> Bool
$c/= :: Axiom -> Axiom -> Bool
== :: Axiom -> Axiom -> Bool
$c== :: Axiom -> Axiom -> Bool
Eq,Int -> Axiom -> ShowS
[Axiom] -> ShowS
Axiom -> String
(Int -> Axiom -> ShowS)
-> (Axiom -> String) -> ([Axiom] -> ShowS) -> Show Axiom
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Axiom] -> ShowS
$cshowList :: [Axiom] -> ShowS
show :: Axiom -> String
$cshow :: Axiom -> String
showsPrec :: Int -> Axiom -> ShowS
$cshowsPrec :: Int -> Axiom -> ShowS
Show)
data Axiom_Attrs = Axiom_Attrs
    { Axiom_Attrs -> String
axiomName :: String
    , Axiom_Attrs -> String
axiomArgs :: String
    } deriving (Axiom_Attrs -> Axiom_Attrs -> Bool
(Axiom_Attrs -> Axiom_Attrs -> Bool)
-> (Axiom_Attrs -> Axiom_Attrs -> Bool) -> Eq Axiom_Attrs
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Axiom_Attrs -> Axiom_Attrs -> Bool
$c/= :: Axiom_Attrs -> Axiom_Attrs -> Bool
== :: Axiom_Attrs -> Axiom_Attrs -> Bool
$c== :: Axiom_Attrs -> Axiom_Attrs -> Bool
Eq,Int -> Axiom_Attrs -> ShowS
[Axiom_Attrs] -> ShowS
Axiom_Attrs -> String
(Int -> Axiom_Attrs -> ShowS)
-> (Axiom_Attrs -> String)
-> ([Axiom_Attrs] -> ShowS)
-> Show Axiom_Attrs
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Axiom_Attrs] -> ShowS
$cshowList :: [Axiom_Attrs] -> ShowS
show :: Axiom_Attrs -> String
$cshow :: Axiom_Attrs -> String
showsPrec :: Int -> Axiom_Attrs -> ShowS
$cshowsPrec :: Int -> Axiom_Attrs -> ShowS
Show)
data Lemma = Lemma Lemma_Attrs Ctxt Proof (List1 (Shows))
           deriving (Lemma -> Lemma -> Bool
(Lemma -> Lemma -> Bool) -> (Lemma -> Lemma -> Bool) -> Eq Lemma
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Lemma -> Lemma -> Bool
$c/= :: Lemma -> Lemma -> Bool
== :: Lemma -> Lemma -> Bool
$c== :: Lemma -> Lemma -> Bool
Eq,Int -> Lemma -> ShowS
[Lemma] -> ShowS
Lemma -> String
(Int -> Lemma -> ShowS)
-> (Lemma -> String) -> ([Lemma] -> ShowS) -> Show Lemma
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Lemma] -> ShowS
$cshowList :: [Lemma] -> ShowS
show :: Lemma -> String
$cshow :: Lemma -> String
showsPrec :: Int -> Lemma -> ShowS
$cshowsPrec :: Int -> Lemma -> ShowS
Show)
data Lemma_Attrs = Lemma_Attrs
    { Lemma_Attrs -> Maybe String
lemmaTarget :: (Maybe String)
    } deriving (Lemma_Attrs -> Lemma_Attrs -> Bool
(Lemma_Attrs -> Lemma_Attrs -> Bool)
-> (Lemma_Attrs -> Lemma_Attrs -> Bool) -> Eq Lemma_Attrs
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Lemma_Attrs -> Lemma_Attrs -> Bool
$c/= :: Lemma_Attrs -> Lemma_Attrs -> Bool
== :: Lemma_Attrs -> Lemma_Attrs -> Bool
$c== :: Lemma_Attrs -> Lemma_Attrs -> Bool
Eq,Int -> Lemma_Attrs -> ShowS
[Lemma_Attrs] -> ShowS
Lemma_Attrs -> String
(Int -> Lemma_Attrs -> ShowS)
-> (Lemma_Attrs -> String)
-> ([Lemma_Attrs] -> ShowS)
-> Show Lemma_Attrs
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Lemma_Attrs] -> ShowS
$cshowList :: [Lemma_Attrs] -> ShowS
show :: Lemma_Attrs -> String
$cshow :: Lemma_Attrs -> String
showsPrec :: Int -> Lemma_Attrs -> ShowS
$cshowsPrec :: Int -> Lemma_Attrs -> ShowS
Show)
data Definition = Definition Definition_Attrs (Maybe Mixfix)
                             (OneOf3 TVar TFree Type)
                             (List1 (OneOf6 Bound Free Var Const App Abs))
                deriving (Definition -> Definition -> Bool
(Definition -> Definition -> Bool)
-> (Definition -> Definition -> Bool) -> Eq Definition
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Definition -> Definition -> Bool
$c/= :: Definition -> Definition -> Bool
== :: Definition -> Definition -> Bool
$c== :: Definition -> Definition -> Bool
Eq,Int -> Definition -> ShowS
[Definition] -> ShowS
Definition -> String
(Int -> Definition -> ShowS)
-> (Definition -> String)
-> ([Definition] -> ShowS)
-> Show Definition
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Definition] -> ShowS
$cshowList :: [Definition] -> ShowS
show :: Definition -> String
$cshow :: Definition -> String
showsPrec :: Int -> Definition -> ShowS
$cshowsPrec :: Int -> Definition -> ShowS
Show)
data Definition_Attrs = Definition_Attrs
    { Definition_Attrs -> String
definitionName :: String
    , Definition_Attrs -> Maybe String
definitionTarget :: (Maybe String)
    } deriving (Definition_Attrs -> Definition_Attrs -> Bool
(Definition_Attrs -> Definition_Attrs -> Bool)
-> (Definition_Attrs -> Definition_Attrs -> Bool)
-> Eq Definition_Attrs
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Definition_Attrs -> Definition_Attrs -> Bool
$c/= :: Definition_Attrs -> Definition_Attrs -> Bool
== :: Definition_Attrs -> Definition_Attrs -> Bool
$c== :: Definition_Attrs -> Definition_Attrs -> Bool
Eq,Int -> Definition_Attrs -> ShowS
[Definition_Attrs] -> ShowS
Definition_Attrs -> String
(Int -> Definition_Attrs -> ShowS)
-> (Definition_Attrs -> String)
-> ([Definition_Attrs] -> ShowS)
-> Show Definition_Attrs
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Definition_Attrs] -> ShowS
$cshowList :: [Definition_Attrs] -> ShowS
show :: Definition_Attrs -> String
$cshow :: Definition_Attrs -> String
showsPrec :: Int -> Definition_Attrs -> ShowS
$cshowsPrec :: Int -> Definition_Attrs -> ShowS
Show)
data Funs = Funs Funs_Attrs (List1 Fun)
          deriving (Funs -> Funs -> Bool
(Funs -> Funs -> Bool) -> (Funs -> Funs -> Bool) -> Eq Funs
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Funs -> Funs -> Bool
$c/= :: Funs -> Funs -> Bool
== :: Funs -> Funs -> Bool
$c== :: Funs -> Funs -> Bool
Eq,Int -> Funs -> ShowS
[Funs] -> ShowS
Funs -> String
(Int -> Funs -> ShowS)
-> (Funs -> String) -> ([Funs] -> ShowS) -> Show Funs
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Funs] -> ShowS
$cshowList :: [Funs] -> ShowS
show :: Funs -> String
$cshow :: Funs -> String
showsPrec :: Int -> Funs -> ShowS
$cshowsPrec :: Int -> Funs -> ShowS
Show)
data Funs_Attrs = Funs_Attrs
    { Funs_Attrs -> Maybe String
funsTarget :: (Maybe String)
    , Funs_Attrs -> Maybe String
funsSequential :: (Maybe String)
    , Funs_Attrs -> Maybe String
funsDefault :: (Maybe String)
    , Funs_Attrs -> Maybe String
funsDomintros :: (Maybe String)
    , Funs_Attrs -> Maybe String
funsPartials :: (Maybe String)
    } deriving (Funs_Attrs -> Funs_Attrs -> Bool
(Funs_Attrs -> Funs_Attrs -> Bool)
-> (Funs_Attrs -> Funs_Attrs -> Bool) -> Eq Funs_Attrs
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Funs_Attrs -> Funs_Attrs -> Bool
$c/= :: Funs_Attrs -> Funs_Attrs -> Bool
== :: Funs_Attrs -> Funs_Attrs -> Bool
$c== :: Funs_Attrs -> Funs_Attrs -> Bool
Eq,Int -> Funs_Attrs -> ShowS
[Funs_Attrs] -> ShowS
Funs_Attrs -> String
(Int -> Funs_Attrs -> ShowS)
-> (Funs_Attrs -> String)
-> ([Funs_Attrs] -> ShowS)
-> Show Funs_Attrs
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Funs_Attrs] -> ShowS
$cshowList :: [Funs_Attrs] -> ShowS
show :: Funs_Attrs -> String
$cshow :: Funs_Attrs -> String
showsPrec :: Int -> Funs_Attrs -> ShowS
$cshowsPrec :: Int -> Funs_Attrs -> ShowS
Show)
data Fun = Fun Fun_Attrs (Maybe Mixfix) (OneOf3 TVar TFree Type)
               (List1 Equation)
         deriving (Fun -> Fun -> Bool
(Fun -> Fun -> Bool) -> (Fun -> Fun -> Bool) -> Eq Fun
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Fun -> Fun -> Bool
$c/= :: Fun -> Fun -> Bool
== :: Fun -> Fun -> Bool
$c== :: Fun -> Fun -> Bool
Eq,Int -> Fun -> ShowS
[Fun] -> ShowS
Fun -> String
(Int -> Fun -> ShowS)
-> (Fun -> String) -> ([Fun] -> ShowS) -> Show Fun
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Fun] -> ShowS
$cshowList :: [Fun] -> ShowS
show :: Fun -> String
$cshow :: Fun -> String
showsPrec :: Int -> Fun -> ShowS
$cshowsPrec :: Int -> Fun -> ShowS
Show)
data Fun_Attrs = Fun_Attrs
    { Fun_Attrs -> String
funName :: String
    } deriving (Fun_Attrs -> Fun_Attrs -> Bool
(Fun_Attrs -> Fun_Attrs -> Bool)
-> (Fun_Attrs -> Fun_Attrs -> Bool) -> Eq Fun_Attrs
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Fun_Attrs -> Fun_Attrs -> Bool
$c/= :: Fun_Attrs -> Fun_Attrs -> Bool
== :: Fun_Attrs -> Fun_Attrs -> Bool
$c== :: Fun_Attrs -> Fun_Attrs -> Bool
Eq,Int -> Fun_Attrs -> ShowS
[Fun_Attrs] -> ShowS
Fun_Attrs -> String
(Int -> Fun_Attrs -> ShowS)
-> (Fun_Attrs -> String)
-> ([Fun_Attrs] -> ShowS)
-> Show Fun_Attrs
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Fun_Attrs] -> ShowS
$cshowList :: [Fun_Attrs] -> ShowS
show :: Fun_Attrs -> String
$cshow :: Fun_Attrs -> String
showsPrec :: Int -> Fun_Attrs -> ShowS
$cshowsPrec :: Int -> Fun_Attrs -> ShowS
Show)
newtype Equation = Equation (List1 (OneOf6 Bound Free Var Const App Abs))   deriving (Equation -> Equation -> Bool
(Equation -> Equation -> Bool)
-> (Equation -> Equation -> Bool) -> Eq Equation
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Equation -> Equation -> Bool
$c/= :: Equation -> Equation -> Bool
== :: Equation -> Equation -> Bool
$c== :: Equation -> Equation -> Bool
Eq,Int -> Equation -> ShowS
[Equation] -> ShowS
Equation -> String
(Int -> Equation -> ShowS)
-> (Equation -> String) -> ([Equation] -> ShowS) -> Show Equation
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Equation] -> ShowS
$cshowList :: [Equation] -> ShowS
show :: Equation -> String
$cshow :: Equation -> String
showsPrec :: Int -> Equation -> ShowS
$cshowsPrec :: Int -> Equation -> ShowS
Show)
data Primrec = Primrec Primrec_Attrs (List1 Fun)
             deriving (Primrec -> Primrec -> Bool
(Primrec -> Primrec -> Bool)
-> (Primrec -> Primrec -> Bool) -> Eq Primrec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Primrec -> Primrec -> Bool
$c/= :: Primrec -> Primrec -> Bool
== :: Primrec -> Primrec -> Bool
$c== :: Primrec -> Primrec -> Bool
Eq,Int -> Primrec -> ShowS
[Primrec] -> ShowS
Primrec -> String
(Int -> Primrec -> ShowS)
-> (Primrec -> String) -> ([Primrec] -> ShowS) -> Show Primrec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Primrec] -> ShowS
$cshowList :: [Primrec] -> ShowS
show :: Primrec -> String
$cshow :: Primrec -> String
showsPrec :: Int -> Primrec -> ShowS
$cshowsPrec :: Int -> Primrec -> ShowS
Show)
data Primrec_Attrs = Primrec_Attrs
    { Primrec_Attrs -> Maybe String
primrecTarget :: (Maybe String)
    } deriving (Primrec_Attrs -> Primrec_Attrs -> Bool
(Primrec_Attrs -> Primrec_Attrs -> Bool)
-> (Primrec_Attrs -> Primrec_Attrs -> Bool) -> Eq Primrec_Attrs
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Primrec_Attrs -> Primrec_Attrs -> Bool
$c/= :: Primrec_Attrs -> Primrec_Attrs -> Bool
== :: Primrec_Attrs -> Primrec_Attrs -> Bool
$c== :: Primrec_Attrs -> Primrec_Attrs -> Bool
Eq,Int -> Primrec_Attrs -> ShowS
[Primrec_Attrs] -> ShowS
Primrec_Attrs -> String
(Int -> Primrec_Attrs -> ShowS)
-> (Primrec_Attrs -> String)
-> ([Primrec_Attrs] -> ShowS)
-> Show Primrec_Attrs
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Primrec_Attrs] -> ShowS
$cshowList :: [Primrec_Attrs] -> ShowS
show :: Primrec_Attrs -> String
$cshow :: Primrec_Attrs -> String
showsPrec :: Int -> Primrec_Attrs -> ShowS
$cshowsPrec :: Int -> Primrec_Attrs -> ShowS
Show)
newtype Fixrec = Fixrec (List1 FixrecFun)   deriving (Fixrec -> Fixrec -> Bool
(Fixrec -> Fixrec -> Bool)
-> (Fixrec -> Fixrec -> Bool) -> Eq Fixrec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Fixrec -> Fixrec -> Bool
$c/= :: Fixrec -> Fixrec -> Bool
== :: Fixrec -> Fixrec -> Bool
$c== :: Fixrec -> Fixrec -> Bool
Eq,Int -> Fixrec -> ShowS
[Fixrec] -> ShowS
Fixrec -> String
(Int -> Fixrec -> ShowS)
-> (Fixrec -> String) -> ([Fixrec] -> ShowS) -> Show Fixrec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Fixrec] -> ShowS
$cshowList :: [Fixrec] -> ShowS
show :: Fixrec -> String
$cshow :: Fixrec -> String
showsPrec :: Int -> Fixrec -> ShowS
$cshowsPrec :: Int -> Fixrec -> ShowS
Show)
data FixrecFun = FixrecFun FixrecFun_Attrs (Maybe Mixfix)
                           (OneOf3 TVar TFree Type) (List1 FixrecEquation)
               deriving (FixrecFun -> FixrecFun -> Bool
(FixrecFun -> FixrecFun -> Bool)
-> (FixrecFun -> FixrecFun -> Bool) -> Eq FixrecFun
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FixrecFun -> FixrecFun -> Bool
$c/= :: FixrecFun -> FixrecFun -> Bool
== :: FixrecFun -> FixrecFun -> Bool
$c== :: FixrecFun -> FixrecFun -> Bool
Eq,Int -> FixrecFun -> ShowS
[FixrecFun] -> ShowS
FixrecFun -> String
(Int -> FixrecFun -> ShowS)
-> (FixrecFun -> String)
-> ([FixrecFun] -> ShowS)
-> Show FixrecFun
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FixrecFun] -> ShowS
$cshowList :: [FixrecFun] -> ShowS
show :: FixrecFun -> String
$cshow :: FixrecFun -> String
showsPrec :: Int -> FixrecFun -> ShowS
$cshowsPrec :: Int -> FixrecFun -> ShowS
Show)
data FixrecFun_Attrs = FixrecFun_Attrs
    { FixrecFun_Attrs -> String
fixrecFunName :: String
    } deriving (FixrecFun_Attrs -> FixrecFun_Attrs -> Bool
(FixrecFun_Attrs -> FixrecFun_Attrs -> Bool)
-> (FixrecFun_Attrs -> FixrecFun_Attrs -> Bool)
-> Eq FixrecFun_Attrs
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FixrecFun_Attrs -> FixrecFun_Attrs -> Bool
$c/= :: FixrecFun_Attrs -> FixrecFun_Attrs -> Bool
== :: FixrecFun_Attrs -> FixrecFun_Attrs -> Bool
$c== :: FixrecFun_Attrs -> FixrecFun_Attrs -> Bool
Eq,Int -> FixrecFun_Attrs -> ShowS
[FixrecFun_Attrs] -> ShowS
FixrecFun_Attrs -> String
(Int -> FixrecFun_Attrs -> ShowS)
-> (FixrecFun_Attrs -> String)
-> ([FixrecFun_Attrs] -> ShowS)
-> Show FixrecFun_Attrs
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FixrecFun_Attrs] -> ShowS
$cshowList :: [FixrecFun_Attrs] -> ShowS
show :: FixrecFun_Attrs -> String
$cshow :: FixrecFun_Attrs -> String
showsPrec :: Int -> FixrecFun_Attrs -> ShowS
$cshowsPrec :: Int -> FixrecFun_Attrs -> ShowS
Show)
data FixrecEquation = FixrecEquation FixrecEquation_Attrs Premises
                                     (List1 (OneOf6 Bound Free Var Const App Abs))
                    deriving (FixrecEquation -> FixrecEquation -> Bool
(FixrecEquation -> FixrecEquation -> Bool)
-> (FixrecEquation -> FixrecEquation -> Bool) -> Eq FixrecEquation
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FixrecEquation -> FixrecEquation -> Bool
$c/= :: FixrecEquation -> FixrecEquation -> Bool
== :: FixrecEquation -> FixrecEquation -> Bool
$c== :: FixrecEquation -> FixrecEquation -> Bool
Eq,Int -> FixrecEquation -> ShowS
[FixrecEquation] -> ShowS
FixrecEquation -> String
(Int -> FixrecEquation -> ShowS)
-> (FixrecEquation -> String)
-> ([FixrecEquation] -> ShowS)
-> Show FixrecEquation
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FixrecEquation] -> ShowS
$cshowList :: [FixrecEquation] -> ShowS
show :: FixrecEquation -> String
$cshow :: FixrecEquation -> String
showsPrec :: Int -> FixrecEquation -> ShowS
$cshowsPrec :: Int -> FixrecEquation -> ShowS
Show)
data FixrecEquation_Attrs = FixrecEquation_Attrs
    { FixrecEquation_Attrs -> Maybe String
fixrecEquationUnchecked :: (Maybe String)
    } deriving (FixrecEquation_Attrs -> FixrecEquation_Attrs -> Bool
(FixrecEquation_Attrs -> FixrecEquation_Attrs -> Bool)
-> (FixrecEquation_Attrs -> FixrecEquation_Attrs -> Bool)
-> Eq FixrecEquation_Attrs
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FixrecEquation_Attrs -> FixrecEquation_Attrs -> Bool
$c/= :: FixrecEquation_Attrs -> FixrecEquation_Attrs -> Bool
== :: FixrecEquation_Attrs -> FixrecEquation_Attrs -> Bool
$c== :: FixrecEquation_Attrs -> FixrecEquation_Attrs -> Bool
Eq,Int -> FixrecEquation_Attrs -> ShowS
[FixrecEquation_Attrs] -> ShowS
FixrecEquation_Attrs -> String
(Int -> FixrecEquation_Attrs -> ShowS)
-> (FixrecEquation_Attrs -> String)
-> ([FixrecEquation_Attrs] -> ShowS)
-> Show FixrecEquation_Attrs
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FixrecEquation_Attrs] -> ShowS
$cshowList :: [FixrecEquation_Attrs] -> ShowS
show :: FixrecEquation_Attrs -> String
$cshow :: FixrecEquation_Attrs -> String
showsPrec :: Int -> FixrecEquation_Attrs -> ShowS
$cshowsPrec :: Int -> FixrecEquation_Attrs -> ShowS
Show)
newtype Premises = Premises [(OneOf6 Bound Free Var Const App Abs)]   deriving (Premises -> Premises -> Bool
(Premises -> Premises -> Bool)
-> (Premises -> Premises -> Bool) -> Eq Premises
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Premises -> Premises -> Bool
$c/= :: Premises -> Premises -> Bool
== :: Premises -> Premises -> Bool
$c== :: Premises -> Premises -> Bool
Eq,Int -> Premises -> ShowS
[Premises] -> ShowS
Premises -> String
(Int -> Premises -> ShowS)
-> (Premises -> String) -> ([Premises] -> ShowS) -> Show Premises
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Premises] -> ShowS
$cshowList :: [Premises] -> ShowS
show :: Premises -> String
$cshow :: Premises -> String
showsPrec :: Int -> Premises -> ShowS
$cshowsPrec :: Int -> Premises -> ShowS
Show)
data Instantiation = Instantiation Instantiation_Attrs Arity Body
                   deriving (Instantiation -> Instantiation -> Bool
(Instantiation -> Instantiation -> Bool)
-> (Instantiation -> Instantiation -> Bool) -> Eq Instantiation
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Instantiation -> Instantiation -> Bool
$c/= :: Instantiation -> Instantiation -> Bool
== :: Instantiation -> Instantiation -> Bool
$c== :: Instantiation -> Instantiation -> Bool
Eq,Int -> Instantiation -> ShowS
[Instantiation] -> ShowS
Instantiation -> String
(Int -> Instantiation -> ShowS)
-> (Instantiation -> String)
-> ([Instantiation] -> ShowS)
-> Show Instantiation
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Instantiation] -> ShowS
$cshowList :: [Instantiation] -> ShowS
show :: Instantiation -> String
$cshow :: Instantiation -> String
showsPrec :: Int -> Instantiation -> ShowS
$cshowsPrec :: Int -> Instantiation -> ShowS
Show)
data Instantiation_Attrs = Instantiation_Attrs
    { Instantiation_Attrs -> String
instantiationType :: String
    } deriving (Instantiation_Attrs -> Instantiation_Attrs -> Bool
(Instantiation_Attrs -> Instantiation_Attrs -> Bool)
-> (Instantiation_Attrs -> Instantiation_Attrs -> Bool)
-> Eq Instantiation_Attrs
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Instantiation_Attrs -> Instantiation_Attrs -> Bool
$c/= :: Instantiation_Attrs -> Instantiation_Attrs -> Bool
== :: Instantiation_Attrs -> Instantiation_Attrs -> Bool
$c== :: Instantiation_Attrs -> Instantiation_Attrs -> Bool
Eq,Int -> Instantiation_Attrs -> ShowS
[Instantiation_Attrs] -> ShowS
Instantiation_Attrs -> String
(Int -> Instantiation_Attrs -> ShowS)
-> (Instantiation_Attrs -> String)
-> ([Instantiation_Attrs] -> ShowS)
-> Show Instantiation_Attrs
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Instantiation_Attrs] -> ShowS
$cshowList :: [Instantiation_Attrs] -> ShowS
show :: Instantiation_Attrs -> String
$cshow :: Instantiation_Attrs -> String
showsPrec :: Int -> Instantiation_Attrs -> ShowS
$cshowsPrec :: Int -> Instantiation_Attrs -> ShowS
Show)
data Instance = Instance Instance_Attrs Proof (Maybe (Vars,Arity))
              deriving (Instance -> Instance -> Bool
(Instance -> Instance -> Bool)
-> (Instance -> Instance -> Bool) -> Eq Instance
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Instance -> Instance -> Bool
$c/= :: Instance -> Instance -> Bool
== :: Instance -> Instance -> Bool
$c== :: Instance -> Instance -> Bool
Eq,Int -> Instance -> ShowS
[Instance] -> ShowS
Instance -> String
(Int -> Instance -> ShowS)
-> (Instance -> String) -> ([Instance] -> ShowS) -> Show Instance
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Instance] -> ShowS
$cshowList :: [Instance] -> ShowS
show :: Instance -> String
$cshow :: Instance -> String
showsPrec :: Int -> Instance -> ShowS
$cshowsPrec :: Int -> Instance -> ShowS
Show)
data Instance_Attrs = Instance_Attrs
    { Instance_Attrs -> Maybe String
instanceClass :: (Maybe String)
    , Instance_Attrs -> Maybe String
instanceRel :: (Maybe String)
    , Instance_Attrs -> Maybe String
instanceClass1 :: (Maybe String)
    } deriving (Instance_Attrs -> Instance_Attrs -> Bool
(Instance_Attrs -> Instance_Attrs -> Bool)
-> (Instance_Attrs -> Instance_Attrs -> Bool) -> Eq Instance_Attrs
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Instance_Attrs -> Instance_Attrs -> Bool
$c/= :: Instance_Attrs -> Instance_Attrs -> Bool
== :: Instance_Attrs -> Instance_Attrs -> Bool
$c== :: Instance_Attrs -> Instance_Attrs -> Bool
Eq,Int -> Instance_Attrs -> ShowS
[Instance_Attrs] -> ShowS
Instance_Attrs -> String
(Int -> Instance_Attrs -> ShowS)
-> (Instance_Attrs -> String)
-> ([Instance_Attrs] -> ShowS)
-> Show Instance_Attrs
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Instance_Attrs] -> ShowS
$cshowList :: [Instance_Attrs] -> ShowS
show :: Instance_Attrs -> String
$cshow :: Instance_Attrs -> String
showsPrec :: Int -> Instance_Attrs -> ShowS
$cshowsPrec :: Int -> Instance_Attrs -> ShowS
Show)
data Subclass = Subclass Subclass_Attrs Proof
              deriving (Subclass -> Subclass -> Bool
(Subclass -> Subclass -> Bool)
-> (Subclass -> Subclass -> Bool) -> Eq Subclass
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Subclass -> Subclass -> Bool
$c/= :: Subclass -> Subclass -> Bool
== :: Subclass -> Subclass -> Bool
$c== :: Subclass -> Subclass -> Bool
Eq,Int -> Subclass -> ShowS
[Subclass] -> ShowS
Subclass -> String
(Int -> Subclass -> ShowS)
-> (Subclass -> String) -> ([Subclass] -> ShowS) -> Show Subclass
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Subclass] -> ShowS
$cshowList :: [Subclass] -> ShowS
show :: Subclass -> String
$cshow :: Subclass -> String
showsPrec :: Int -> Subclass -> ShowS
$cshowsPrec :: Int -> Subclass -> ShowS
Show)
data Subclass_Attrs = Subclass_Attrs
    { Subclass_Attrs -> String
subclassClass :: String
    , Subclass_Attrs -> Maybe String
subclassTarget :: (Maybe String)
    } deriving (Subclass_Attrs -> Subclass_Attrs -> Bool
(Subclass_Attrs -> Subclass_Attrs -> Bool)
-> (Subclass_Attrs -> Subclass_Attrs -> Bool) -> Eq Subclass_Attrs
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Subclass_Attrs -> Subclass_Attrs -> Bool
$c/= :: Subclass_Attrs -> Subclass_Attrs -> Bool
== :: Subclass_Attrs -> Subclass_Attrs -> Bool
$c== :: Subclass_Attrs -> Subclass_Attrs -> Bool
Eq,Int -> Subclass_Attrs -> ShowS
[Subclass_Attrs] -> ShowS
Subclass_Attrs -> String
(Int -> Subclass_Attrs -> ShowS)
-> (Subclass_Attrs -> String)
-> ([Subclass_Attrs] -> ShowS)
-> Show Subclass_Attrs
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Subclass_Attrs] -> ShowS
$cshowList :: [Subclass_Attrs] -> ShowS
show :: Subclass_Attrs -> String
$cshow :: Subclass_Attrs -> String
showsPrec :: Int -> Subclass_Attrs -> ShowS
$cshowsPrec :: Int -> Subclass_Attrs -> ShowS
Show)
data Typedef = Typedef Typedef_Attrs (Maybe Mixfix) Proof
                       (OneOf6 Bound Free Var Const App Abs) [TFree]
             deriving (Typedef -> Typedef -> Bool
(Typedef -> Typedef -> Bool)
-> (Typedef -> Typedef -> Bool) -> Eq Typedef
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Typedef -> Typedef -> Bool
$c/= :: Typedef -> Typedef -> Bool
== :: Typedef -> Typedef -> Bool
$c== :: Typedef -> Typedef -> Bool
Eq,Int -> Typedef -> ShowS
[Typedef] -> ShowS
Typedef -> String
(Int -> Typedef -> ShowS)
-> (Typedef -> String) -> ([Typedef] -> ShowS) -> Show Typedef
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Typedef] -> ShowS
$cshowList :: [Typedef] -> ShowS
show :: Typedef -> String
$cshow :: Typedef -> String
showsPrec :: Int -> Typedef -> ShowS
$cshowsPrec :: Int -> Typedef -> ShowS
Show)
data Typedef_Attrs = Typedef_Attrs
    { Typedef_Attrs -> String
typedefType :: String
    , Typedef_Attrs -> Maybe String
typedefM1 :: (Maybe String)
    , Typedef_Attrs -> Maybe String
typedefM2 :: (Maybe String)
    } deriving (Typedef_Attrs -> Typedef_Attrs -> Bool
(Typedef_Attrs -> Typedef_Attrs -> Bool)
-> (Typedef_Attrs -> Typedef_Attrs -> Bool) -> Eq Typedef_Attrs
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Typedef_Attrs -> Typedef_Attrs -> Bool
$c/= :: Typedef_Attrs -> Typedef_Attrs -> Bool
== :: Typedef_Attrs -> Typedef_Attrs -> Bool
$c== :: Typedef_Attrs -> Typedef_Attrs -> Bool
Eq,Int -> Typedef_Attrs -> ShowS
[Typedef_Attrs] -> ShowS
Typedef_Attrs -> String
(Int -> Typedef_Attrs -> ShowS)
-> (Typedef_Attrs -> String)
-> ([Typedef_Attrs] -> ShowS)
-> Show Typedef_Attrs
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Typedef_Attrs] -> ShowS
$cshowList :: [Typedef_Attrs] -> ShowS
show :: Typedef_Attrs -> String
$cshow :: Typedef_Attrs -> String
showsPrec :: Int -> Typedef_Attrs -> ShowS
$cshowsPrec :: Int -> Typedef_Attrs -> ShowS
Show)
data Defs = Defs Defs_Attrs (List1 Def)
          deriving (Defs -> Defs -> Bool
(Defs -> Defs -> Bool) -> (Defs -> Defs -> Bool) -> Eq Defs
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Defs -> Defs -> Bool
$c/= :: Defs -> Defs -> Bool
== :: Defs -> Defs -> Bool
$c== :: Defs -> Defs -> Bool
Eq,Int -> Defs -> ShowS
[Defs] -> ShowS
Defs -> String
(Int -> Defs -> ShowS)
-> (Defs -> String) -> ([Defs] -> ShowS) -> Show Defs
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Defs] -> ShowS
$cshowList :: [Defs] -> ShowS
show :: Defs -> String
$cshow :: Defs -> String
showsPrec :: Int -> Defs -> ShowS
$cshowsPrec :: Int -> Defs -> ShowS
Show)
data Defs_Attrs = Defs_Attrs
    { Defs_Attrs -> Maybe String
defsUnchecked :: (Maybe String)
    , Defs_Attrs -> Maybe String
defsOverloaded :: (Maybe String)
    } deriving (Defs_Attrs -> Defs_Attrs -> Bool
(Defs_Attrs -> Defs_Attrs -> Bool)
-> (Defs_Attrs -> Defs_Attrs -> Bool) -> Eq Defs_Attrs
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Defs_Attrs -> Defs_Attrs -> Bool
$c/= :: Defs_Attrs -> Defs_Attrs -> Bool
== :: Defs_Attrs -> Defs_Attrs -> Bool
$c== :: Defs_Attrs -> Defs_Attrs -> Bool
Eq,Int -> Defs_Attrs -> ShowS
[Defs_Attrs] -> ShowS
Defs_Attrs -> String
(Int -> Defs_Attrs -> ShowS)
-> (Defs_Attrs -> String)
-> ([Defs_Attrs] -> ShowS)
-> Show Defs_Attrs
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Defs_Attrs] -> ShowS
$cshowList :: [Defs_Attrs] -> ShowS
show :: Defs_Attrs -> String
$cshow :: Defs_Attrs -> String
showsPrec :: Int -> Defs_Attrs -> ShowS
$cshowsPrec :: Int -> Defs_Attrs -> ShowS
Show)
data Def = Def Def_Attrs (OneOf3 TVar TFree Type)
               (OneOf6 Bound Free Var Const App Abs)
         deriving (Def -> Def -> Bool
(Def -> Def -> Bool) -> (Def -> Def -> Bool) -> Eq Def
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Def -> Def -> Bool
$c/= :: Def -> Def -> Bool
== :: Def -> Def -> Bool
$c== :: Def -> Def -> Bool
Eq,Int -> Def -> ShowS
[Def] -> ShowS
Def -> String
(Int -> Def -> ShowS)
-> (Def -> String) -> ([Def] -> ShowS) -> Show Def
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Def] -> ShowS
$cshowList :: [Def] -> ShowS
show :: Def -> String
$cshow :: Def -> String
showsPrec :: Int -> Def -> ShowS
$cshowsPrec :: Int -> Def -> ShowS
Show)
data Def_Attrs = Def_Attrs
    { Def_Attrs -> String
defName :: String
    , Def_Attrs -> String
defArgs :: String
    , Def_Attrs -> String
defConst :: String
    } deriving (Def_Attrs -> Def_Attrs -> Bool
(Def_Attrs -> Def_Attrs -> Bool)
-> (Def_Attrs -> Def_Attrs -> Bool) -> Eq Def_Attrs
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Def_Attrs -> Def_Attrs -> Bool
$c/= :: Def_Attrs -> Def_Attrs -> Bool
== :: Def_Attrs -> Def_Attrs -> Bool
$c== :: Def_Attrs -> Def_Attrs -> Bool
Eq,Int -> Def_Attrs -> ShowS
[Def_Attrs] -> ShowS
Def_Attrs -> String
(Int -> Def_Attrs -> ShowS)
-> (Def_Attrs -> String)
-> ([Def_Attrs] -> ShowS)
-> Show Def_Attrs
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Def_Attrs] -> ShowS
$cshowList :: [Def_Attrs] -> ShowS
show :: Def_Attrs -> String
$cshow :: Def_Attrs -> String
showsPrec :: Int -> Def_Attrs -> ShowS
$cshowsPrec :: Int -> Def_Attrs -> ShowS
Show)
newtype Sort = Sort (List1 Class)   deriving (Sort -> Sort -> Bool
(Sort -> Sort -> Bool) -> (Sort -> Sort -> Bool) -> Eq Sort
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Sort -> Sort -> Bool
$c/= :: Sort -> Sort -> Bool
== :: Sort -> Sort -> Bool
$c== :: Sort -> Sort -> Bool
Eq,Int -> Sort -> ShowS
[Sort] -> ShowS
Sort -> String
(Int -> Sort -> ShowS)
-> (Sort -> String) -> ([Sort] -> ShowS) -> Show Sort
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Sort] -> ShowS
$cshowList :: [Sort] -> ShowS
show :: Sort -> String
$cshow :: Sort -> String
showsPrec :: Int -> Sort -> ShowS
$cshowsPrec :: Int -> Sort -> ShowS
Show)
data Arity = Arity Sort [Sort]
           deriving (Arity -> Arity -> Bool
(Arity -> Arity -> Bool) -> (Arity -> Arity -> Bool) -> Eq Arity
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Arity -> Arity -> Bool
$c/= :: Arity -> Arity -> Bool
== :: Arity -> Arity -> Bool
$c== :: Arity -> Arity -> Bool
Eq,Int -> Arity -> ShowS
[Arity] -> ShowS
Arity -> String
(Int -> Arity -> ShowS)
-> (Arity -> String) -> ([Arity] -> ShowS) -> Show Arity
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Arity] -> ShowS
$cshowList :: [Arity] -> ShowS
show :: Arity -> String
$cshow :: Arity -> String
showsPrec :: Int -> Arity -> ShowS
$cshowsPrec :: Int -> Arity -> ShowS
Show)
newtype Vars = Vars [TFree]   deriving (Vars -> Vars -> Bool
(Vars -> Vars -> Bool) -> (Vars -> Vars -> Bool) -> Eq Vars
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Vars -> Vars -> Bool
$c/= :: Vars -> Vars -> Bool
== :: Vars -> Vars -> Bool
$c== :: Vars -> Vars -> Bool
Eq,Int -> Vars -> ShowS
[Vars] -> ShowS
Vars -> String
(Int -> Vars -> ShowS)
-> (Vars -> String) -> ([Vars] -> ShowS) -> Show Vars
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Vars] -> ShowS
$cshowList :: [Vars] -> ShowS
show :: Vars -> String
$cshow :: Vars -> String
showsPrec :: Int -> Vars -> ShowS
$cshowsPrec :: Int -> Vars -> ShowS
Show)
data Parent = Parent
    { Parent -> String
parentName :: String
    } deriving (Parent -> Parent -> Bool
(Parent -> Parent -> Bool)
-> (Parent -> Parent -> Bool) -> Eq Parent
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Parent -> Parent -> Bool
$c/= :: Parent -> Parent -> Bool
== :: Parent -> Parent -> Bool
$c== :: Parent -> Parent -> Bool
Eq,Int -> Parent -> ShowS
[Parent] -> ShowS
Parent -> String
(Int -> Parent -> ShowS)
-> (Parent -> String) -> ([Parent] -> ShowS) -> Show Parent
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Parent] -> ShowS
$cshowList :: [Parent] -> ShowS
show :: Parent -> String
$cshow :: Parent -> String
showsPrec :: Int -> Parent -> ShowS
$cshowsPrec :: Int -> Parent -> ShowS
Show)
newtype Fixes = Fixes [Fix]   deriving (Fixes -> Fixes -> Bool
(Fixes -> Fixes -> Bool) -> (Fixes -> Fixes -> Bool) -> Eq Fixes
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Fixes -> Fixes -> Bool
$c/= :: Fixes -> Fixes -> Bool
== :: Fixes -> Fixes -> Bool
$c== :: Fixes -> Fixes -> Bool
Eq,Int -> Fixes -> ShowS
[Fixes] -> ShowS
Fixes -> String
(Int -> Fixes -> ShowS)
-> (Fixes -> String) -> ([Fixes] -> ShowS) -> Show Fixes
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Fixes] -> ShowS
$cshowList :: [Fixes] -> ShowS
show :: Fixes -> String
$cshow :: Fixes -> String
showsPrec :: Int -> Fixes -> ShowS
$cshowsPrec :: Int -> Fixes -> ShowS
Show)
data Fix = Fix Fix_Attrs (OneOf3 TVar TFree Type) (Maybe Mixfix)
         deriving (Fix -> Fix -> Bool
(Fix -> Fix -> Bool) -> (Fix -> Fix -> Bool) -> Eq Fix
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Fix -> Fix -> Bool
$c/= :: Fix -> Fix -> Bool
== :: Fix -> Fix -> Bool
$c== :: Fix -> Fix -> Bool
Eq,Int -> Fix -> ShowS
[Fix] -> ShowS
Fix -> String
(Int -> Fix -> ShowS)
-> (Fix -> String) -> ([Fix] -> ShowS) -> Show Fix
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Fix] -> ShowS
$cshowList :: [Fix] -> ShowS
show :: Fix -> String
$cshow :: Fix -> String
showsPrec :: Int -> Fix -> ShowS
$cshowsPrec :: Int -> Fix -> ShowS
Show)
data Fix_Attrs = Fix_Attrs
    { Fix_Attrs -> String
fixName :: String
    } deriving (Fix_Attrs -> Fix_Attrs -> Bool
(Fix_Attrs -> Fix_Attrs -> Bool)
-> (Fix_Attrs -> Fix_Attrs -> Bool) -> Eq Fix_Attrs
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Fix_Attrs -> Fix_Attrs -> Bool
$c/= :: Fix_Attrs -> Fix_Attrs -> Bool
== :: Fix_Attrs -> Fix_Attrs -> Bool
$c== :: Fix_Attrs -> Fix_Attrs -> Bool
Eq,Int -> Fix_Attrs -> ShowS
[Fix_Attrs] -> ShowS
Fix_Attrs -> String
(Int -> Fix_Attrs -> ShowS)
-> (Fix_Attrs -> String)
-> ([Fix_Attrs] -> ShowS)
-> Show Fix_Attrs
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Fix_Attrs] -> ShowS
$cshowList :: [Fix_Attrs] -> ShowS
show :: Fix_Attrs -> String
$cshow :: Fix_Attrs -> String
showsPrec :: Int -> Fix_Attrs -> ShowS
$cshowsPrec :: Int -> Fix_Attrs -> ShowS
Show)
newtype Assumes = Assumes [Assumption]   deriving (Assumes -> Assumes -> Bool
(Assumes -> Assumes -> Bool)
-> (Assumes -> Assumes -> Bool) -> Eq Assumes
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Assumes -> Assumes -> Bool
$c/= :: Assumes -> Assumes -> Bool
== :: Assumes -> Assumes -> Bool
$c== :: Assumes -> Assumes -> Bool
Eq,Int -> Assumes -> ShowS
[Assumes] -> ShowS
Assumes -> String
(Int -> Assumes -> ShowS)
-> (Assumes -> String) -> ([Assumes] -> ShowS) -> Show Assumes
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Assumes] -> ShowS
$cshowList :: [Assumes] -> ShowS
show :: Assumes -> String
$cshow :: Assumes -> String
showsPrec :: Int -> Assumes -> ShowS
$cshowsPrec :: Int -> Assumes -> ShowS
Show)
data Assumption = Assumption Assumption_Attrs
                             (OneOf6 Bound Free Var Const App Abs)
                deriving (Assumption -> Assumption -> Bool
(Assumption -> Assumption -> Bool)
-> (Assumption -> Assumption -> Bool) -> Eq Assumption
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Assumption -> Assumption -> Bool
$c/= :: Assumption -> Assumption -> Bool
== :: Assumption -> Assumption -> Bool
$c== :: Assumption -> Assumption -> Bool
Eq,Int -> Assumption -> ShowS
[Assumption] -> ShowS
Assumption -> String
(Int -> Assumption -> ShowS)
-> (Assumption -> String)
-> ([Assumption] -> ShowS)
-> Show Assumption
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Assumption] -> ShowS
$cshowList :: [Assumption] -> ShowS
show :: Assumption -> String
$cshow :: Assumption -> String
showsPrec :: Int -> Assumption -> ShowS
$cshowsPrec :: Int -> Assumption -> ShowS
Show)
data Assumption_Attrs = Assumption_Attrs
    { Assumption_Attrs -> String
assumptionName :: String
    , Assumption_Attrs -> String
assumptionArgs :: String
    } deriving (Assumption_Attrs -> Assumption_Attrs -> Bool
(Assumption_Attrs -> Assumption_Attrs -> Bool)
-> (Assumption_Attrs -> Assumption_Attrs -> Bool)
-> Eq Assumption_Attrs
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Assumption_Attrs -> Assumption_Attrs -> Bool
$c/= :: Assumption_Attrs -> Assumption_Attrs -> Bool
== :: Assumption_Attrs -> Assumption_Attrs -> Bool
$c== :: Assumption_Attrs -> Assumption_Attrs -> Bool
Eq,Int -> Assumption_Attrs -> ShowS
[Assumption_Attrs] -> ShowS
Assumption_Attrs -> String
(Int -> Assumption_Attrs -> ShowS)
-> (Assumption_Attrs -> String)
-> ([Assumption_Attrs] -> ShowS)
-> Show Assumption_Attrs
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Assumption_Attrs] -> ShowS
$cshowList :: [Assumption_Attrs] -> ShowS
show :: Assumption_Attrs -> String
$cshow :: Assumption_Attrs -> String
showsPrec :: Int -> Assumption_Attrs -> ShowS
$cshowsPrec :: Int -> Assumption_Attrs -> ShowS
Show)
newtype Ctxt = Ctxt [(OneOf2 Fixes Assumes)]   deriving (Ctxt -> Ctxt -> Bool
(Ctxt -> Ctxt -> Bool) -> (Ctxt -> Ctxt -> Bool) -> Eq Ctxt
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Ctxt -> Ctxt -> Bool
$c/= :: Ctxt -> Ctxt -> Bool
== :: Ctxt -> Ctxt -> Bool
$c== :: Ctxt -> Ctxt -> Bool
Eq,Int -> Ctxt -> ShowS
[Ctxt] -> ShowS
Ctxt -> String
(Int -> Ctxt -> ShowS)
-> (Ctxt -> String) -> ([Ctxt] -> ShowS) -> Show Ctxt
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Ctxt] -> ShowS
$cshowList :: [Ctxt] -> ShowS
show :: Ctxt -> String
$cshow :: Ctxt -> String
showsPrec :: Int -> Ctxt -> ShowS
$cshowsPrec :: Int -> Ctxt -> ShowS
Show)
data Mixfix = Mixfix Mixfix_Attrs
                     [(OneOf4 Arg AString Break Block)]
            deriving (Mixfix -> Mixfix -> Bool
(Mixfix -> Mixfix -> Bool)
-> (Mixfix -> Mixfix -> Bool) -> Eq Mixfix
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Mixfix -> Mixfix -> Bool
$c/= :: Mixfix -> Mixfix -> Bool
== :: Mixfix -> Mixfix -> Bool
$c== :: Mixfix -> Mixfix -> Bool
Eq,Int -> Mixfix -> ShowS
[Mixfix] -> ShowS
Mixfix -> String
(Int -> Mixfix -> ShowS)
-> (Mixfix -> String) -> ([Mixfix] -> ShowS) -> Show Mixfix
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Mixfix] -> ShowS
$cshowList :: [Mixfix] -> ShowS
show :: Mixfix -> String
$cshow :: Mixfix -> String
showsPrec :: Int -> Mixfix -> ShowS
$cshowsPrec :: Int -> Mixfix -> ShowS
Show)
data Mixfix_Attrs = Mixfix_Attrs
    { Mixfix_Attrs -> String
mixfixNargs :: String
    , Mixfix_Attrs -> String
mixfixPrio :: String
    , Mixfix_Attrs -> String
mixfixPretty :: String
    } deriving (Mixfix_Attrs -> Mixfix_Attrs -> Bool
(Mixfix_Attrs -> Mixfix_Attrs -> Bool)
-> (Mixfix_Attrs -> Mixfix_Attrs -> Bool) -> Eq Mixfix_Attrs
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Mixfix_Attrs -> Mixfix_Attrs -> Bool
$c/= :: Mixfix_Attrs -> Mixfix_Attrs -> Bool
== :: Mixfix_Attrs -> Mixfix_Attrs -> Bool
$c== :: Mixfix_Attrs -> Mixfix_Attrs -> Bool
Eq,Int -> Mixfix_Attrs -> ShowS
[Mixfix_Attrs] -> ShowS
Mixfix_Attrs -> String
(Int -> Mixfix_Attrs -> ShowS)
-> (Mixfix_Attrs -> String)
-> ([Mixfix_Attrs] -> ShowS)
-> Show Mixfix_Attrs
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Mixfix_Attrs] -> ShowS
$cshowList :: [Mixfix_Attrs] -> ShowS
show :: Mixfix_Attrs -> String
$cshow :: Mixfix_Attrs -> String
showsPrec :: Int -> Mixfix_Attrs -> ShowS
$cshowsPrec :: Int -> Mixfix_Attrs -> ShowS
Show)
data Arg = Arg
    { Arg -> String
argPrio :: String
    } deriving (Arg -> Arg -> Bool
(Arg -> Arg -> Bool) -> (Arg -> Arg -> Bool) -> Eq Arg
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Arg -> Arg -> Bool
$c/= :: Arg -> Arg -> Bool
== :: Arg -> Arg -> Bool
$c== :: Arg -> Arg -> Bool
Eq,Int -> Arg -> ShowS
[Arg] -> ShowS
Arg -> String
(Int -> Arg -> ShowS)
-> (Arg -> String) -> ([Arg] -> ShowS) -> Show Arg
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Arg] -> ShowS
$cshowList :: [Arg] -> ShowS
show :: Arg -> String
$cshow :: Arg -> String
showsPrec :: Int -> Arg -> ShowS
$cshowsPrec :: Int -> Arg -> ShowS
Show)
data AString = AString
    { AString -> String
stringVal :: String
    } deriving (AString -> AString -> Bool
(AString -> AString -> Bool)
-> (AString -> AString -> Bool) -> Eq AString
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AString -> AString -> Bool
$c/= :: AString -> AString -> Bool
== :: AString -> AString -> Bool
$c== :: AString -> AString -> Bool
Eq,Int -> AString -> ShowS
[AString] -> ShowS
AString -> String
(Int -> AString -> ShowS)
-> (AString -> String) -> ([AString] -> ShowS) -> Show AString
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AString] -> ShowS
$cshowList :: [AString] -> ShowS
show :: AString -> String
$cshow :: AString -> String
showsPrec :: Int -> AString -> ShowS
$cshowsPrec :: Int -> AString -> ShowS
Show)
data Break = Break
    { Break -> String
breakPrio :: String
    } deriving (Break -> Break -> Bool
(Break -> Break -> Bool) -> (Break -> Break -> Bool) -> Eq Break
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Break -> Break -> Bool
$c/= :: Break -> Break -> Bool
== :: Break -> Break -> Bool
$c== :: Break -> Break -> Bool
Eq,Int -> Break -> ShowS
[Break] -> ShowS
Break -> String
(Int -> Break -> ShowS)
-> (Break -> String) -> ([Break] -> ShowS) -> Show Break
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Break] -> ShowS
$cshowList :: [Break] -> ShowS
show :: Break -> String
$cshow :: Break -> String
showsPrec :: Int -> Break -> ShowS
$cshowsPrec :: Int -> Break -> ShowS
Show)
data Block = Block Block_Attrs [(OneOf4 Arg AString Break Block)]
           deriving (Block -> Block -> Bool
(Block -> Block -> Bool) -> (Block -> Block -> Bool) -> Eq Block
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Block -> Block -> Bool
$c/= :: Block -> Block -> Bool
== :: Block -> Block -> Bool
$c== :: Block -> Block -> Bool
Eq,Int -> Block -> ShowS
[Block] -> ShowS
Block -> String
(Int -> Block -> ShowS)
-> (Block -> String) -> ([Block] -> ShowS) -> Show Block
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Block] -> ShowS
$cshowList :: [Block] -> ShowS
show :: Block -> String
$cshow :: Block -> String
showsPrec :: Int -> Block -> ShowS
$cshowsPrec :: Int -> Block -> ShowS
Show)
data Block_Attrs = Block_Attrs
    { Block_Attrs -> String
blockPrio :: String
    } deriving (Block_Attrs -> Block_Attrs -> Bool
(Block_Attrs -> Block_Attrs -> Bool)
-> (Block_Attrs -> Block_Attrs -> Bool) -> Eq Block_Attrs
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Block_Attrs -> Block_Attrs -> Bool
$c/= :: Block_Attrs -> Block_Attrs -> Bool
== :: Block_Attrs -> Block_Attrs -> Bool
$c== :: Block_Attrs -> Block_Attrs -> Bool
Eq,Int -> Block_Attrs -> ShowS
[Block_Attrs] -> ShowS
Block_Attrs -> String
(Int -> Block_Attrs -> ShowS)
-> (Block_Attrs -> String)
-> ([Block_Attrs] -> ShowS)
-> Show Block_Attrs
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Block_Attrs] -> ShowS
$cshowList :: [Block_Attrs] -> ShowS
show :: Block_Attrs -> String
$cshow :: Block_Attrs -> String
showsPrec :: Int -> Block_Attrs -> ShowS
$cshowsPrec :: Int -> Block_Attrs -> ShowS
Show)
newtype Proof = Proof String   deriving (Proof -> Proof -> Bool
(Proof -> Proof -> Bool) -> (Proof -> Proof -> Bool) -> Eq Proof
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Proof -> Proof -> Bool
$c/= :: Proof -> Proof -> Bool
== :: Proof -> Proof -> Bool
$c== :: Proof -> Proof -> Bool
Eq,Int -> Proof -> ShowS
[Proof] -> ShowS
Proof -> String
(Int -> Proof -> ShowS)
-> (Proof -> String) -> ([Proof] -> ShowS) -> Show Proof
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Proof] -> ShowS
$cshowList :: [Proof] -> ShowS
show :: Proof -> String
$cshow :: Proof -> String
showsPrec :: Int -> Proof -> ShowS
$cshowsPrec :: Int -> Proof -> ShowS
Show)
data Shows = Shows Shows_Attrs (List1 AShow)
           deriving (Shows -> Shows -> Bool
(Shows -> Shows -> Bool) -> (Shows -> Shows -> Bool) -> Eq Shows
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Shows -> Shows -> Bool
$c/= :: Shows -> Shows -> Bool
== :: Shows -> Shows -> Bool
$c== :: Shows -> Shows -> Bool
Eq,Int -> Shows -> ShowS
[Shows] -> ShowS
Shows -> String
(Int -> Shows -> ShowS)
-> (Shows -> String) -> ([Shows] -> ShowS) -> Show Shows
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Shows] -> ShowS
$cshowList :: [Shows] -> ShowS
show :: Shows -> String
$cshow :: Shows -> String
showsPrec :: Int -> Shows -> ShowS
$cshowsPrec :: Int -> Shows -> ShowS
Show)
data Shows_Attrs = Shows_Attrs
    { Shows_Attrs -> String
showsName :: String
    , Shows_Attrs -> Maybe String
showsArgs :: (Maybe String)
    } deriving (Shows_Attrs -> Shows_Attrs -> Bool
(Shows_Attrs -> Shows_Attrs -> Bool)
-> (Shows_Attrs -> Shows_Attrs -> Bool) -> Eq Shows_Attrs
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Shows_Attrs -> Shows_Attrs -> Bool
$c/= :: Shows_Attrs -> Shows_Attrs -> Bool
== :: Shows_Attrs -> Shows_Attrs -> Bool
$c== :: Shows_Attrs -> Shows_Attrs -> Bool
Eq,Int -> Shows_Attrs -> ShowS
[Shows_Attrs] -> ShowS
Shows_Attrs -> String
(Int -> Shows_Attrs -> ShowS)
-> (Shows_Attrs -> String)
-> ([Shows_Attrs] -> ShowS)
-> Show Shows_Attrs
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Shows_Attrs] -> ShowS
$cshowList :: [Shows_Attrs] -> ShowS
show :: Shows_Attrs -> String
$cshow :: Shows_Attrs -> String
showsPrec :: Int -> Shows_Attrs -> ShowS
$cshowsPrec :: Int -> Shows_Attrs -> ShowS
Show)
newtype AShow = AShow (List1 (OneOf6 Bound Free Var Const App Abs))   deriving (AShow -> AShow -> Bool
(AShow -> AShow -> Bool) -> (AShow -> AShow -> Bool) -> Eq AShow
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AShow -> AShow -> Bool
$c/= :: AShow -> AShow -> Bool
== :: AShow -> AShow -> Bool
$c== :: AShow -> AShow -> Bool
Eq,Int -> AShow -> ShowS
[AShow] -> ShowS
AShow -> String
(Int -> AShow -> ShowS)
-> (AShow -> String) -> ([AShow] -> ShowS) -> Show AShow
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AShow] -> ShowS
$cshowList :: [AShow] -> ShowS
show :: AShow -> String
$cshow :: AShow -> String
showsPrec :: Int -> AShow -> ShowS
$cshowsPrec :: Int -> AShow -> ShowS
Show)
data Bound = Bound
    { Bound -> String
boundIndex :: String
    } deriving (Bound -> Bound -> Bool
(Bound -> Bound -> Bool) -> (Bound -> Bound -> Bool) -> Eq Bound
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Bound -> Bound -> Bool
$c/= :: Bound -> Bound -> Bool
== :: Bound -> Bound -> Bool
$c== :: Bound -> Bound -> Bool
Eq,Int -> Bound -> ShowS
[Bound] -> ShowS
Bound -> String
(Int -> Bound -> ShowS)
-> (Bound -> String) -> ([Bound] -> ShowS) -> Show Bound
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Bound] -> ShowS
$cshowList :: [Bound] -> ShowS
show :: Bound -> String
$cshow :: Bound -> String
showsPrec :: Int -> Bound -> ShowS
$cshowsPrec :: Int -> Bound -> ShowS
Show)
data Free = FreeTVar Free_Attrs TVar
          | FreeTFree Free_Attrs TFree
          | FreeType Free_Attrs Type
          deriving (Free -> Free -> Bool
(Free -> Free -> Bool) -> (Free -> Free -> Bool) -> Eq Free
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Free -> Free -> Bool
$c/= :: Free -> Free -> Bool
== :: Free -> Free -> Bool
$c== :: Free -> Free -> Bool
Eq,Int -> Free -> ShowS
[Free] -> ShowS
Free -> String
(Int -> Free -> ShowS)
-> (Free -> String) -> ([Free] -> ShowS) -> Show Free
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Free] -> ShowS
$cshowList :: [Free] -> ShowS
show :: Free -> String
$cshow :: Free -> String
showsPrec :: Int -> Free -> ShowS
$cshowsPrec :: Int -> Free -> ShowS
Show)
data Free_Attrs = Free_Attrs
    { Free_Attrs -> String
freeName :: String
    } deriving (Free_Attrs -> Free_Attrs -> Bool
(Free_Attrs -> Free_Attrs -> Bool)
-> (Free_Attrs -> Free_Attrs -> Bool) -> Eq Free_Attrs
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Free_Attrs -> Free_Attrs -> Bool
$c/= :: Free_Attrs -> Free_Attrs -> Bool
== :: Free_Attrs -> Free_Attrs -> Bool
$c== :: Free_Attrs -> Free_Attrs -> Bool
Eq,Int -> Free_Attrs -> ShowS
[Free_Attrs] -> ShowS
Free_Attrs -> String
(Int -> Free_Attrs -> ShowS)
-> (Free_Attrs -> String)
-> ([Free_Attrs] -> ShowS)
-> Show Free_Attrs
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Free_Attrs] -> ShowS
$cshowList :: [Free_Attrs] -> ShowS
show :: Free_Attrs -> String
$cshow :: Free_Attrs -> String
showsPrec :: Int -> Free_Attrs -> ShowS
$cshowsPrec :: Int -> Free_Attrs -> ShowS
Show)
data Var = VarTVar Var_Attrs TVar
         | VarTFree Var_Attrs TFree
         | VarType Var_Attrs Type
         deriving (Var -> Var -> Bool
(Var -> Var -> Bool) -> (Var -> Var -> Bool) -> Eq Var
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Var -> Var -> Bool
$c/= :: Var -> Var -> Bool
== :: Var -> Var -> Bool
$c== :: Var -> Var -> Bool
Eq,Int -> Var -> ShowS
[Var] -> ShowS
Var -> String
(Int -> Var -> ShowS)
-> (Var -> String) -> ([Var] -> ShowS) -> Show Var
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Var] -> ShowS
$cshowList :: [Var] -> ShowS
show :: Var -> String
$cshow :: Var -> String
showsPrec :: Int -> Var -> ShowS
$cshowsPrec :: Int -> Var -> ShowS
Show)
data Var_Attrs = Var_Attrs
    { Var_Attrs -> String
varName :: String
    , Var_Attrs -> Maybe String
varIndex :: (Maybe String)
    } deriving (Var_Attrs -> Var_Attrs -> Bool
(Var_Attrs -> Var_Attrs -> Bool)
-> (Var_Attrs -> Var_Attrs -> Bool) -> Eq Var_Attrs
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Var_Attrs -> Var_Attrs -> Bool
$c/= :: Var_Attrs -> Var_Attrs -> Bool
== :: Var_Attrs -> Var_Attrs -> Bool
$c== :: Var_Attrs -> Var_Attrs -> Bool
Eq,Int -> Var_Attrs -> ShowS
[Var_Attrs] -> ShowS
Var_Attrs -> String
(Int -> Var_Attrs -> ShowS)
-> (Var_Attrs -> String)
-> ([Var_Attrs] -> ShowS)
-> Show Var_Attrs
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Var_Attrs] -> ShowS
$cshowList :: [Var_Attrs] -> ShowS
show :: Var_Attrs -> String
$cshow :: Var_Attrs -> String
showsPrec :: Int -> Var_Attrs -> ShowS
$cshowsPrec :: Int -> Var_Attrs -> ShowS
Show)
data Const = Const Const_Attrs (OneOf3 TVar TFree Type)
           deriving (Const -> Const -> Bool
(Const -> Const -> Bool) -> (Const -> Const -> Bool) -> Eq Const
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Const -> Const -> Bool
$c/= :: Const -> Const -> Bool
== :: Const -> Const -> Bool
$c== :: Const -> Const -> Bool
Eq,Int -> Const -> ShowS
[Const] -> ShowS
Const -> String
(Int -> Const -> ShowS)
-> (Const -> String) -> ([Const] -> ShowS) -> Show Const
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Const] -> ShowS
$cshowList :: [Const] -> ShowS
show :: Const -> String
$cshow :: Const -> String
showsPrec :: Int -> Const -> ShowS
$cshowsPrec :: Int -> Const -> ShowS
Show)
data Const_Attrs = Const_Attrs
    { Const_Attrs -> String
constName :: String
    } deriving (Const_Attrs -> Const_Attrs -> Bool
(Const_Attrs -> Const_Attrs -> Bool)
-> (Const_Attrs -> Const_Attrs -> Bool) -> Eq Const_Attrs
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Const_Attrs -> Const_Attrs -> Bool
$c/= :: Const_Attrs -> Const_Attrs -> Bool
== :: Const_Attrs -> Const_Attrs -> Bool
$c== :: Const_Attrs -> Const_Attrs -> Bool
Eq,Int -> Const_Attrs -> ShowS
[Const_Attrs] -> ShowS
Const_Attrs -> String
(Int -> Const_Attrs -> ShowS)
-> (Const_Attrs -> String)
-> ([Const_Attrs] -> ShowS)
-> Show Const_Attrs
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Const_Attrs] -> ShowS
$cshowList :: [Const_Attrs] -> ShowS
show :: Const_Attrs -> String
$cshow :: Const_Attrs -> String
showsPrec :: Int -> Const_Attrs -> ShowS
$cshowsPrec :: Int -> Const_Attrs -> ShowS
Show)
data App = App (OneOf6 Bound Free Var Const App Abs)
               (OneOf6 Bound Free Var Const App Abs)
         deriving (App -> App -> Bool
(App -> App -> Bool) -> (App -> App -> Bool) -> Eq App
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: App -> App -> Bool
$c/= :: App -> App -> Bool
== :: App -> App -> Bool
$c== :: App -> App -> Bool
Eq,Int -> App -> ShowS
[App] -> ShowS
App -> String
(Int -> App -> ShowS)
-> (App -> String) -> ([App] -> ShowS) -> Show App
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [App] -> ShowS
$cshowList :: [App] -> ShowS
show :: App -> String
$cshow :: App -> String
showsPrec :: Int -> App -> ShowS
$cshowsPrec :: Int -> App -> ShowS
Show)
data Abs = Abs Abs_Attrs (OneOf3 TVar TFree Type)
               (OneOf6 Bound Free Var Const App Abs)
         deriving (Abs -> Abs -> Bool
(Abs -> Abs -> Bool) -> (Abs -> Abs -> Bool) -> Eq Abs
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Abs -> Abs -> Bool
$c/= :: Abs -> Abs -> Bool
== :: Abs -> Abs -> Bool
$c== :: Abs -> Abs -> Bool
Eq,Int -> Abs -> ShowS
[Abs] -> ShowS
Abs -> String
(Int -> Abs -> ShowS)
-> (Abs -> String) -> ([Abs] -> ShowS) -> Show Abs
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Abs] -> ShowS
$cshowList :: [Abs] -> ShowS
show :: Abs -> String
$cshow :: Abs -> String
showsPrec :: Int -> Abs -> ShowS
$cshowsPrec :: Int -> Abs -> ShowS
Show)
data Abs_Attrs = Abs_Attrs
    { Abs_Attrs -> String
absVname :: String
    } deriving (Abs_Attrs -> Abs_Attrs -> Bool
(Abs_Attrs -> Abs_Attrs -> Bool)
-> (Abs_Attrs -> Abs_Attrs -> Bool) -> Eq Abs_Attrs
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Abs_Attrs -> Abs_Attrs -> Bool
$c/= :: Abs_Attrs -> Abs_Attrs -> Bool
== :: Abs_Attrs -> Abs_Attrs -> Bool
$c== :: Abs_Attrs -> Abs_Attrs -> Bool
Eq,Int -> Abs_Attrs -> ShowS
[Abs_Attrs] -> ShowS
Abs_Attrs -> String
(Int -> Abs_Attrs -> ShowS)
-> (Abs_Attrs -> String)
-> ([Abs_Attrs] -> ShowS)
-> Show Abs_Attrs
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Abs_Attrs] -> ShowS
$cshowList :: [Abs_Attrs] -> ShowS
show :: Abs_Attrs -> String
$cshow :: Abs_Attrs -> String
showsPrec :: Int -> Abs_Attrs -> ShowS
$cshowsPrec :: Int -> Abs_Attrs -> ShowS
Show)
data TVar = TVar TVar_Attrs [Class]
          deriving (TVar -> TVar -> Bool
(TVar -> TVar -> Bool) -> (TVar -> TVar -> Bool) -> Eq TVar
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TVar -> TVar -> Bool
$c/= :: TVar -> TVar -> Bool
== :: TVar -> TVar -> Bool
$c== :: TVar -> TVar -> Bool
Eq,Int -> TVar -> ShowS
[TVar] -> ShowS
TVar -> String
(Int -> TVar -> ShowS)
-> (TVar -> String) -> ([TVar] -> ShowS) -> Show TVar
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TVar] -> ShowS
$cshowList :: [TVar] -> ShowS
show :: TVar -> String
$cshow :: TVar -> String
showsPrec :: Int -> TVar -> ShowS
$cshowsPrec :: Int -> TVar -> ShowS
Show)
data TVar_Attrs = TVar_Attrs
    { TVar_Attrs -> String
tVarName :: String
    , TVar_Attrs -> Maybe String
tVarIndex :: (Maybe String)
    } deriving (TVar_Attrs -> TVar_Attrs -> Bool
(TVar_Attrs -> TVar_Attrs -> Bool)
-> (TVar_Attrs -> TVar_Attrs -> Bool) -> Eq TVar_Attrs
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TVar_Attrs -> TVar_Attrs -> Bool
$c/= :: TVar_Attrs -> TVar_Attrs -> Bool
== :: TVar_Attrs -> TVar_Attrs -> Bool
$c== :: TVar_Attrs -> TVar_Attrs -> Bool
Eq,Int -> TVar_Attrs -> ShowS
[TVar_Attrs] -> ShowS
TVar_Attrs -> String
(Int -> TVar_Attrs -> ShowS)
-> (TVar_Attrs -> String)
-> ([TVar_Attrs] -> ShowS)
-> Show TVar_Attrs
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TVar_Attrs] -> ShowS
$cshowList :: [TVar_Attrs] -> ShowS
show :: TVar_Attrs -> String
$cshow :: TVar_Attrs -> String
showsPrec :: Int -> TVar_Attrs -> ShowS
$cshowsPrec :: Int -> TVar_Attrs -> ShowS
Show)
data TFree = TFree TFree_Attrs [Class]
           deriving (TFree -> TFree -> Bool
(TFree -> TFree -> Bool) -> (TFree -> TFree -> Bool) -> Eq TFree
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TFree -> TFree -> Bool
$c/= :: TFree -> TFree -> Bool
== :: TFree -> TFree -> Bool
$c== :: TFree -> TFree -> Bool
Eq,Int -> TFree -> ShowS
[TFree] -> ShowS
TFree -> String
(Int -> TFree -> ShowS)
-> (TFree -> String) -> ([TFree] -> ShowS) -> Show TFree
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TFree] -> ShowS
$cshowList :: [TFree] -> ShowS
show :: TFree -> String
$cshow :: TFree -> String
showsPrec :: Int -> TFree -> ShowS
$cshowsPrec :: Int -> TFree -> ShowS
Show)
data TFree_Attrs = TFree_Attrs
    { TFree_Attrs -> String
tFreeName :: String
    } deriving (TFree_Attrs -> TFree_Attrs -> Bool
(TFree_Attrs -> TFree_Attrs -> Bool)
-> (TFree_Attrs -> TFree_Attrs -> Bool) -> Eq TFree_Attrs
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TFree_Attrs -> TFree_Attrs -> Bool
$c/= :: TFree_Attrs -> TFree_Attrs -> Bool
== :: TFree_Attrs -> TFree_Attrs -> Bool
$c== :: TFree_Attrs -> TFree_Attrs -> Bool
Eq,Int -> TFree_Attrs -> ShowS
[TFree_Attrs] -> ShowS
TFree_Attrs -> String
(Int -> TFree_Attrs -> ShowS)
-> (TFree_Attrs -> String)
-> ([TFree_Attrs] -> ShowS)
-> Show TFree_Attrs
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TFree_Attrs] -> ShowS
$cshowList :: [TFree_Attrs] -> ShowS
show :: TFree_Attrs -> String
$cshow :: TFree_Attrs -> String
showsPrec :: Int -> TFree_Attrs -> ShowS
$cshowsPrec :: Int -> TFree_Attrs -> ShowS
Show)
data Type = Type Type_Attrs [(OneOf3 TVar TFree Type)]
          deriving (Type -> Type -> Bool
(Type -> Type -> Bool) -> (Type -> Type -> Bool) -> Eq Type
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Type -> Type -> Bool
$c/= :: Type -> Type -> Bool
== :: Type -> Type -> Bool
$c== :: Type -> Type -> Bool
Eq,Int -> Type -> ShowS
[Type] -> ShowS
Type -> String
(Int -> Type -> ShowS)
-> (Type -> String) -> ([Type] -> ShowS) -> Show Type
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Type] -> ShowS
$cshowList :: [Type] -> ShowS
show :: Type -> String
$cshow :: Type -> String
showsPrec :: Int -> Type -> ShowS
$cshowsPrec :: Int -> Type -> ShowS
Show)
data Type_Attrs = Type_Attrs
    { Type_Attrs -> String
typeName :: String
    } deriving (Type_Attrs -> Type_Attrs -> Bool
(Type_Attrs -> Type_Attrs -> Bool)
-> (Type_Attrs -> Type_Attrs -> Bool) -> Eq Type_Attrs
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Type_Attrs -> Type_Attrs -> Bool
$c/= :: Type_Attrs -> Type_Attrs -> Bool
== :: Type_Attrs -> Type_Attrs -> Bool
$c== :: Type_Attrs -> Type_Attrs -> Bool
Eq,Int -> Type_Attrs -> ShowS
[Type_Attrs] -> ShowS
Type_Attrs -> String
(Int -> Type_Attrs -> ShowS)
-> (Type_Attrs -> String)
-> ([Type_Attrs] -> ShowS)
-> Show Type_Attrs
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Type_Attrs] -> ShowS
$cshowList :: [Type_Attrs] -> ShowS
show :: Type_Attrs -> String
$cshow :: Type_Attrs -> String
showsPrec :: Int -> Type_Attrs -> ShowS
$cshowsPrec :: Int -> Type_Attrs -> ShowS
Show)
data Class = Class
    { Class -> String
className :: String
    } deriving (Class -> Class -> Bool
(Class -> Class -> Bool) -> (Class -> Class -> Bool) -> Eq Class
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Class -> Class -> Bool
$c/= :: Class -> Class -> Bool
== :: Class -> Class -> Bool
$c== :: Class -> Class -> Bool
Eq,Int -> Class -> ShowS
[Class] -> ShowS
Class -> String
(Int -> Class -> ShowS)
-> (Class -> String) -> ([Class] -> ShowS) -> Show Class
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Class] -> ShowS
$cshowList :: [Class] -> ShowS
show :: Class -> String
$cshow :: Class -> String
showsPrec :: Int -> Class -> ShowS
$cshowsPrec :: Int -> Class -> ShowS
Show)


{-Instance decls-}

instance HTypeable Export where
    toHType :: Export -> HType
toHType _ = String -> [HType] -> [Constr] -> HType
Defined "Export" [] []
instance XmlContent Export where
    toContents :: Export -> [Content ()]
toContents (Export a :: List1 Thy
a) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N "Export") [] (List1 Thy -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents List1 Thy
a)) ()]
    parseContents :: XMLParser Export
parseContents = do
        { e :: Element Posn
e@(Elem _ [] _) <- [String] -> XMLParser (Element Posn)
element ["Export"]
        ; Element Posn -> XMLParser Export -> XMLParser Export
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (XMLParser Export -> XMLParser Export)
-> XMLParser Export -> XMLParser Export
forall a b. (a -> b) -> a -> b
$ (List1 Thy -> Export)
-> Parser (Content Posn) (List1 Thy -> Export)
forall (m :: * -> *) a. Monad m => a -> m a
return (List1 Thy -> Export
Export) Parser (Content Posn) (List1 Thy -> Export)
-> Parser (Content Posn) (List1 Thy) -> XMLParser Export
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) (List1 Thy)
forall a. XmlContent a => XMLParser a
parseContents
        } XMLParser Export -> ShowS -> XMLParser Export
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <Export>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)

instance HTypeable Thy where
    toHType :: Thy -> HType
toHType _ = String -> [HType] -> [Constr] -> HType
Defined "Thy" [] []
instance XmlContent Thy where
    toContents :: Thy -> [Content ()]
toContents (Thy as :: Thy_Attrs
as a :: List1 Import
a b :: [Keyword]
b c :: [UseFile]
c d :: Body
d) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N "Thy") (Thy_Attrs -> [Attribute]
forall a. XmlAttributes a => a -> [Attribute]
toAttrs Thy_Attrs
as) (List1 Import -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents List1 Import
a [Content ()] -> [Content ()] -> [Content ()]
forall a. [a] -> [a] -> [a]
++
                                             (Keyword -> [Content ()]) -> [Keyword] -> [Content ()]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap Keyword -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents [Keyword]
b [Content ()] -> [Content ()] -> [Content ()]
forall a. [a] -> [a] -> [a]
++ (UseFile -> [Content ()]) -> [UseFile] -> [Content ()]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap UseFile -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents [UseFile]
c [Content ()] -> [Content ()] -> [Content ()]
forall a. [a] -> [a] -> [a]
++
                                             Body -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents Body
d)) ()]
    parseContents :: XMLParser Thy
parseContents = do
        { e :: Element Posn
e@(Elem _ as :: [Attribute]
as _) <- [String] -> XMLParser (Element Posn)
element ["Thy"]
        ; Element Posn -> XMLParser Thy -> XMLParser Thy
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (XMLParser Thy -> XMLParser Thy) -> XMLParser Thy -> XMLParser Thy
forall a b. (a -> b) -> a -> b
$ (List1 Import -> [Keyword] -> [UseFile] -> Body -> Thy)
-> Parser
     (Content Posn)
     (List1 Import -> [Keyword] -> [UseFile] -> Body -> Thy)
forall (m :: * -> *) a. Monad m => a -> m a
return (Thy_Attrs -> List1 Import -> [Keyword] -> [UseFile] -> Body -> Thy
Thy ([Attribute] -> Thy_Attrs
forall a. XmlAttributes a => [Attribute] -> a
fromAttrs [Attribute]
as)) Parser
  (Content Posn)
  (List1 Import -> [Keyword] -> [UseFile] -> Body -> Thy)
-> Parser (Content Posn) (List1 Import)
-> Parser (Content Posn) ([Keyword] -> [UseFile] -> Body -> Thy)
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) (List1 Import)
forall a. XmlContent a => XMLParser a
parseContents
                       Parser (Content Posn) ([Keyword] -> [UseFile] -> Body -> Thy)
-> Parser (Content Posn) [Keyword]
-> Parser (Content Posn) ([UseFile] -> Body -> Thy)
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) Keyword -> Parser (Content Posn) [Keyword]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many Parser (Content Posn) Keyword
forall a. XmlContent a => XMLParser a
parseContents Parser (Content Posn) ([UseFile] -> Body -> Thy)
-> Parser (Content Posn) [UseFile]
-> Parser (Content Posn) (Body -> Thy)
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) UseFile -> Parser (Content Posn) [UseFile]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many Parser (Content Posn) UseFile
forall a. XmlContent a => XMLParser a
parseContents
                       Parser (Content Posn) (Body -> Thy)
-> Parser (Content Posn) Body -> XMLParser Thy
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) Body
forall a. XmlContent a => XMLParser a
parseContents
        } XMLParser Thy -> ShowS -> XMLParser Thy
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <Thy>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)
instance XmlAttributes Thy_Attrs where
    fromAttrs :: [Attribute] -> Thy_Attrs
fromAttrs as :: [Attribute]
as =
        Thy_Attrs :: String -> Maybe String -> Thy_Attrs
Thy_Attrs
          { thyName :: String
thyName = (String -> Attribute -> Maybe String)
-> String -> String -> [Attribute] -> String
forall a.
(String -> Attribute -> Maybe a)
-> String -> String -> [Attribute] -> a
definiteA String -> Attribute -> Maybe String
fromAttrToStr "Thy" "name" [Attribute]
as
          , thyHeader :: Maybe String
thyHeader = (String -> Attribute -> Maybe String)
-> String -> [Attribute] -> Maybe String
forall a.
(String -> Attribute -> Maybe a)
-> String -> [Attribute] -> Maybe a
possibleA String -> Attribute -> Maybe String
fromAttrToStr "header" [Attribute]
as
          }
    toAttrs :: Thy_Attrs -> [Attribute]
toAttrs v :: Thy_Attrs
v = [Maybe Attribute] -> [Attribute]
forall a. [Maybe a] -> [a]
catMaybes 
        [ String -> String -> Maybe Attribute
toAttrFrStr "name" (Thy_Attrs -> String
thyName Thy_Attrs
v)
        , (String -> String -> Maybe Attribute)
-> String -> Maybe String -> Maybe Attribute
forall a.
(String -> a -> Maybe Attribute)
-> String -> Maybe a -> Maybe Attribute
maybeToAttr String -> String -> Maybe Attribute
toAttrFrStr "header" (Thy_Attrs -> Maybe String
thyHeader Thy_Attrs
v)
        ]

instance HTypeable Keyword where
    toHType :: Keyword -> HType
toHType _ = String -> [HType] -> [Constr] -> HType
Defined "Keyword" [] []
instance XmlContent Keyword where
    toContents :: Keyword -> [Content ()]
toContents as :: Keyword
as =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N "Keyword") (Keyword -> [Attribute]
forall a. XmlAttributes a => a -> [Attribute]
toAttrs Keyword
as) []) ()]
    parseContents :: Parser (Content Posn) Keyword
parseContents = do
        { (Elem _ as :: [Attribute]
as []) <- [String] -> XMLParser (Element Posn)
element ["Keyword"]
        ; Keyword -> Parser (Content Posn) Keyword
forall (m :: * -> *) a. Monad m => a -> m a
return ([Attribute] -> Keyword
forall a. XmlAttributes a => [Attribute] -> a
fromAttrs [Attribute]
as)
        } Parser (Content Posn) Keyword
-> ShowS -> Parser (Content Posn) Keyword
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <Keyword>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)
instance XmlAttributes Keyword where
    fromAttrs :: [Attribute] -> Keyword
fromAttrs as :: [Attribute]
as =
        Keyword :: String -> Keyword
Keyword
          { keywordName :: String
keywordName = (String -> Attribute -> Maybe String)
-> String -> String -> [Attribute] -> String
forall a.
(String -> Attribute -> Maybe a)
-> String -> String -> [Attribute] -> a
definiteA String -> Attribute -> Maybe String
fromAttrToStr "Keyword" "name" [Attribute]
as
          }
    toAttrs :: Keyword -> [Attribute]
toAttrs v :: Keyword
v = [Maybe Attribute] -> [Attribute]
forall a. [Maybe a] -> [a]
catMaybes 
        [ String -> String -> Maybe Attribute
toAttrFrStr "name" (Keyword -> String
keywordName Keyword
v)
        ]

instance HTypeable Import where
    toHType :: Import -> HType
toHType _ = String -> [HType] -> [Constr] -> HType
Defined "Import" [] []
instance XmlContent Import where
    toContents :: Import -> [Content ()]
toContents as :: Import
as =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N "Import") (Import -> [Attribute]
forall a. XmlAttributes a => a -> [Attribute]
toAttrs Import
as) []) ()]
    parseContents :: XMLParser Import
parseContents = do
        { (Elem _ as :: [Attribute]
as []) <- [String] -> XMLParser (Element Posn)
element ["Import"]
        ; Import -> XMLParser Import
forall (m :: * -> *) a. Monad m => a -> m a
return ([Attribute] -> Import
forall a. XmlAttributes a => [Attribute] -> a
fromAttrs [Attribute]
as)
        } XMLParser Import -> ShowS -> XMLParser Import
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <Import>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)
instance XmlAttributes Import where
    fromAttrs :: [Attribute] -> Import
fromAttrs as :: [Attribute]
as =
        Import :: String -> Import
Import
          { importName :: String
importName = (String -> Attribute -> Maybe String)
-> String -> String -> [Attribute] -> String
forall a.
(String -> Attribute -> Maybe a)
-> String -> String -> [Attribute] -> a
definiteA String -> Attribute -> Maybe String
fromAttrToStr "Import" "name" [Attribute]
as
          }
    toAttrs :: Import -> [Attribute]
toAttrs v :: Import
v = [Maybe Attribute] -> [Attribute]
forall a. [Maybe a] -> [a]
catMaybes 
        [ String -> String -> Maybe Attribute
toAttrFrStr "name" (Import -> String
importName Import
v)
        ]

instance HTypeable UseFile where
    toHType :: UseFile -> HType
toHType _ = String -> [HType] -> [Constr] -> HType
Defined "UseFile" [] []
instance XmlContent UseFile where
    toContents :: UseFile -> [Content ()]
toContents as :: UseFile
as =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N "UseFile") (UseFile -> [Attribute]
forall a. XmlAttributes a => a -> [Attribute]
toAttrs UseFile
as) []) ()]
    parseContents :: Parser (Content Posn) UseFile
parseContents = do
        { (Elem _ as :: [Attribute]
as []) <- [String] -> XMLParser (Element Posn)
element ["UseFile"]
        ; UseFile -> Parser (Content Posn) UseFile
forall (m :: * -> *) a. Monad m => a -> m a
return ([Attribute] -> UseFile
forall a. XmlAttributes a => [Attribute] -> a
fromAttrs [Attribute]
as)
        } Parser (Content Posn) UseFile
-> ShowS -> Parser (Content Posn) UseFile
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <UseFile>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)
instance XmlAttributes UseFile where
    fromAttrs :: [Attribute] -> UseFile
fromAttrs as :: [Attribute]
as =
        UseFile :: String -> UseFile
UseFile
          { useFileName :: String
useFileName = (String -> Attribute -> Maybe String)
-> String -> String -> [Attribute] -> String
forall a.
(String -> Attribute -> Maybe a)
-> String -> String -> [Attribute] -> a
definiteA String -> Attribute -> Maybe String
fromAttrToStr "UseFile" "name" [Attribute]
as
          }
    toAttrs :: UseFile -> [Attribute]
toAttrs v :: UseFile
v = [Maybe Attribute] -> [Attribute]
forall a. [Maybe a] -> [a]
catMaybes 
        [ String -> String -> Maybe Attribute
toAttrFrStr "name" (UseFile -> String
useFileName UseFile
v)
        ]

instance HTypeable Body where
    toHType :: Body -> HType
toHType _ = String -> [HType] -> [Constr] -> HType
Defined "Body" [] []
instance XmlContent Body where
    toContents :: Body -> [Content ()]
toContents (Body a :: [Body_]
a) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N "Body") [] ((Body_ -> [Content ()]) -> [Body_] -> [Content ()]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap Body_ -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents [Body_]
a)) ()]
    parseContents :: Parser (Content Posn) Body
parseContents = do
        { e :: Element Posn
e@(Elem _ [] _) <- [String] -> XMLParser (Element Posn)
element ["Body"]
        ; Element Posn
-> Parser (Content Posn) Body -> Parser (Content Posn) Body
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (Parser (Content Posn) Body -> Parser (Content Posn) Body)
-> Parser (Content Posn) Body -> Parser (Content Posn) Body
forall a b. (a -> b) -> a -> b
$ ([Body_] -> Body) -> Parser (Content Posn) ([Body_] -> Body)
forall (m :: * -> *) a. Monad m => a -> m a
return ([Body_] -> Body
Body) Parser (Content Posn) ([Body_] -> Body)
-> Parser (Content Posn) [Body_] -> Parser (Content Posn) Body
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) Body_ -> Parser (Content Posn) [Body_]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many Parser (Content Posn) Body_
forall a. XmlContent a => XMLParser a
parseContents
        } Parser (Content Posn) Body -> ShowS -> Parser (Content Posn) Body
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <Body>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)

instance HTypeable Body_ where
    toHType :: Body_ -> HType
toHType _ = String -> [HType] -> [Constr] -> HType
Defined "Body" [] []
instance XmlContent Body_ where
    toContents :: Body_ -> [Content ()]
toContents (Body_Locale a :: Locale
a) = Locale -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents Locale
a
    toContents (Body_Cls a :: Cls
a) = Cls -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents Cls
a
    toContents (Body_TypeSynonym a :: TypeSynonym
a) = TypeSynonym -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents TypeSynonym
a
    toContents (Body_Datatypes a :: Datatypes
a) = Datatypes -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents Datatypes
a
    toContents (Body_Domains a :: Domains
a) = Domains -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents Domains
a
    toContents (Body_Consts a :: Consts
a) = Consts -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents Consts
a
    toContents (Body_Axioms a :: Axioms
a) = Axioms -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents Axioms
a
    toContents (Body_Lemma a :: Lemma
a) = Lemma -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents Lemma
a
    toContents (Body_Definition a :: Definition
a) = Definition -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents Definition
a
    toContents (Body_Funs a :: Funs
a) = Funs -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents Funs
a
    toContents (Body_Primrec a :: Primrec
a) = Primrec -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents Primrec
a
    toContents (Body_Fixrec a :: Fixrec
a) = Fixrec -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents Fixrec
a
    toContents (Body_Instantiation a :: Instantiation
a) = Instantiation -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents Instantiation
a
    toContents (Body_Instance a :: Instance
a) = Instance -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents Instance
a
    toContents (Body_Subclass a :: Subclass
a) = Subclass -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents Subclass
a
    toContents (Body_Typedef a :: Typedef
a) = Typedef -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents Typedef
a
    toContents (Body_Defs a :: Defs
a) = Defs -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents Defs
a
    parseContents :: Parser (Content Posn) Body_
parseContents = [Parser (Content Posn) Body_] -> Parser (Content Posn) Body_
forall (p :: * -> *) a. PolyParse p => [p a] -> p a
oneOf
        [ (Locale -> Body_) -> Parser (Content Posn) (Locale -> Body_)
forall (m :: * -> *) a. Monad m => a -> m a
return (Locale -> Body_
Body_Locale) Parser (Content Posn) (Locale -> Body_)
-> Parser (Content Posn) Locale -> Parser (Content Posn) Body_
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) Locale
forall a. XmlContent a => XMLParser a
parseContents
        , (Cls -> Body_) -> Parser (Content Posn) (Cls -> Body_)
forall (m :: * -> *) a. Monad m => a -> m a
return (Cls -> Body_
Body_Cls) Parser (Content Posn) (Cls -> Body_)
-> Parser (Content Posn) Cls -> Parser (Content Posn) Body_
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) Cls
forall a. XmlContent a => XMLParser a
parseContents
        , (TypeSynonym -> Body_)
-> Parser (Content Posn) (TypeSynonym -> Body_)
forall (m :: * -> *) a. Monad m => a -> m a
return (TypeSynonym -> Body_
Body_TypeSynonym) Parser (Content Posn) (TypeSynonym -> Body_)
-> Parser (Content Posn) TypeSynonym -> Parser (Content Posn) Body_
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) TypeSynonym
forall a. XmlContent a => XMLParser a
parseContents
        , (Datatypes -> Body_) -> Parser (Content Posn) (Datatypes -> Body_)
forall (m :: * -> *) a. Monad m => a -> m a
return (Datatypes -> Body_
Body_Datatypes) Parser (Content Posn) (Datatypes -> Body_)
-> Parser (Content Posn) Datatypes -> Parser (Content Posn) Body_
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) Datatypes
forall a. XmlContent a => XMLParser a
parseContents
        , (Domains -> Body_) -> Parser (Content Posn) (Domains -> Body_)
forall (m :: * -> *) a. Monad m => a -> m a
return (Domains -> Body_
Body_Domains) Parser (Content Posn) (Domains -> Body_)
-> Parser (Content Posn) Domains -> Parser (Content Posn) Body_
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) Domains
forall a. XmlContent a => XMLParser a
parseContents
        , (Consts -> Body_) -> Parser (Content Posn) (Consts -> Body_)
forall (m :: * -> *) a. Monad m => a -> m a
return (Consts -> Body_
Body_Consts) Parser (Content Posn) (Consts -> Body_)
-> Parser (Content Posn) Consts -> Parser (Content Posn) Body_
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) Consts
forall a. XmlContent a => XMLParser a
parseContents
        , (Axioms -> Body_) -> Parser (Content Posn) (Axioms -> Body_)
forall (m :: * -> *) a. Monad m => a -> m a
return (Axioms -> Body_
Body_Axioms) Parser (Content Posn) (Axioms -> Body_)
-> Parser (Content Posn) Axioms -> Parser (Content Posn) Body_
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) Axioms
forall a. XmlContent a => XMLParser a
parseContents
        , (Lemma -> Body_) -> Parser (Content Posn) (Lemma -> Body_)
forall (m :: * -> *) a. Monad m => a -> m a
return (Lemma -> Body_
Body_Lemma) Parser (Content Posn) (Lemma -> Body_)
-> Parser (Content Posn) Lemma -> Parser (Content Posn) Body_
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) Lemma
forall a. XmlContent a => XMLParser a
parseContents
        , (Definition -> Body_)
-> Parser (Content Posn) (Definition -> Body_)
forall (m :: * -> *) a. Monad m => a -> m a
return (Definition -> Body_
Body_Definition) Parser (Content Posn) (Definition -> Body_)
-> Parser (Content Posn) Definition -> Parser (Content Posn) Body_
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) Definition
forall a. XmlContent a => XMLParser a
parseContents
        , (Funs -> Body_) -> Parser (Content Posn) (Funs -> Body_)
forall (m :: * -> *) a. Monad m => a -> m a
return (Funs -> Body_
Body_Funs) Parser (Content Posn) (Funs -> Body_)
-> Parser (Content Posn) Funs -> Parser (Content Posn) Body_
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) Funs
forall a. XmlContent a => XMLParser a
parseContents
        , (Primrec -> Body_) -> Parser (Content Posn) (Primrec -> Body_)
forall (m :: * -> *) a. Monad m => a -> m a
return (Primrec -> Body_
Body_Primrec) Parser (Content Posn) (Primrec -> Body_)
-> Parser (Content Posn) Primrec -> Parser (Content Posn) Body_
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) Primrec
forall a. XmlContent a => XMLParser a
parseContents
        , (Fixrec -> Body_) -> Parser (Content Posn) (Fixrec -> Body_)
forall (m :: * -> *) a. Monad m => a -> m a
return (Fixrec -> Body_
Body_Fixrec) Parser (Content Posn) (Fixrec -> Body_)
-> Parser (Content Posn) Fixrec -> Parser (Content Posn) Body_
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) Fixrec
forall a. XmlContent a => XMLParser a
parseContents
        , (Instantiation -> Body_)
-> Parser (Content Posn) (Instantiation -> Body_)
forall (m :: * -> *) a. Monad m => a -> m a
return (Instantiation -> Body_
Body_Instantiation) Parser (Content Posn) (Instantiation -> Body_)
-> Parser (Content Posn) Instantiation
-> Parser (Content Posn) Body_
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) Instantiation
forall a. XmlContent a => XMLParser a
parseContents
        , (Instance -> Body_) -> Parser (Content Posn) (Instance -> Body_)
forall (m :: * -> *) a. Monad m => a -> m a
return (Instance -> Body_
Body_Instance) Parser (Content Posn) (Instance -> Body_)
-> Parser (Content Posn) Instance -> Parser (Content Posn) Body_
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) Instance
forall a. XmlContent a => XMLParser a
parseContents
        , (Subclass -> Body_) -> Parser (Content Posn) (Subclass -> Body_)
forall (m :: * -> *) a. Monad m => a -> m a
return (Subclass -> Body_
Body_Subclass) Parser (Content Posn) (Subclass -> Body_)
-> Parser (Content Posn) Subclass -> Parser (Content Posn) Body_
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) Subclass
forall a. XmlContent a => XMLParser a
parseContents
        , (Typedef -> Body_) -> Parser (Content Posn) (Typedef -> Body_)
forall (m :: * -> *) a. Monad m => a -> m a
return (Typedef -> Body_
Body_Typedef) Parser (Content Posn) (Typedef -> Body_)
-> Parser (Content Posn) Typedef -> Parser (Content Posn) Body_
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) Typedef
forall a. XmlContent a => XMLParser a
parseContents
        , (Defs -> Body_) -> Parser (Content Posn) (Defs -> Body_)
forall (m :: * -> *) a. Monad m => a -> m a
return (Defs -> Body_
Body_Defs) Parser (Content Posn) (Defs -> Body_)
-> Parser (Content Posn) Defs -> Parser (Content Posn) Body_
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) Defs
forall a. XmlContent a => XMLParser a
parseContents
        ] Parser (Content Posn) Body_ -> ShowS -> Parser (Content Posn) Body_
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <Body>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)

instance HTypeable Locale where
    toHType :: Locale -> HType
toHType _ = String -> [HType] -> [Constr] -> HType
Defined "Locale" [] []
instance XmlContent Locale where
    toContents :: Locale -> [Content ()]
toContents (Locale as :: Locale_Attrs
as a :: Ctxt
a b :: [Parent]
b c :: Body
c) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N "Locale") (Locale_Attrs -> [Attribute]
forall a. XmlAttributes a => a -> [Attribute]
toAttrs Locale_Attrs
as) (Ctxt -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents Ctxt
a [Content ()] -> [Content ()] -> [Content ()]
forall a. [a] -> [a] -> [a]
++
                                                (Parent -> [Content ()]) -> [Parent] -> [Content ()]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap Parent -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents [Parent]
b [Content ()] -> [Content ()] -> [Content ()]
forall a. [a] -> [a] -> [a]
++ Body -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents Body
c)) ()]
    parseContents :: Parser (Content Posn) Locale
parseContents = do
        { e :: Element Posn
e@(Elem _ as :: [Attribute]
as _) <- [String] -> XMLParser (Element Posn)
element ["Locale"]
        ; Element Posn
-> Parser (Content Posn) Locale -> Parser (Content Posn) Locale
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (Parser (Content Posn) Locale -> Parser (Content Posn) Locale)
-> Parser (Content Posn) Locale -> Parser (Content Posn) Locale
forall a b. (a -> b) -> a -> b
$ (Ctxt -> [Parent] -> Body -> Locale)
-> Parser (Content Posn) (Ctxt -> [Parent] -> Body -> Locale)
forall (m :: * -> *) a. Monad m => a -> m a
return (Locale_Attrs -> Ctxt -> [Parent] -> Body -> Locale
Locale ([Attribute] -> Locale_Attrs
forall a. XmlAttributes a => [Attribute] -> a
fromAttrs [Attribute]
as)) Parser (Content Posn) (Ctxt -> [Parent] -> Body -> Locale)
-> Parser (Content Posn) Ctxt
-> Parser (Content Posn) ([Parent] -> Body -> Locale)
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) Ctxt
forall a. XmlContent a => XMLParser a
parseContents
                       Parser (Content Posn) ([Parent] -> Body -> Locale)
-> Parser (Content Posn) [Parent]
-> Parser (Content Posn) (Body -> Locale)
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) Parent -> Parser (Content Posn) [Parent]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many Parser (Content Posn) Parent
forall a. XmlContent a => XMLParser a
parseContents Parser (Content Posn) (Body -> Locale)
-> Parser (Content Posn) Body -> Parser (Content Posn) Locale
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) Body
forall a. XmlContent a => XMLParser a
parseContents
        } Parser (Content Posn) Locale
-> ShowS -> Parser (Content Posn) Locale
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <Locale>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)
instance XmlAttributes Locale_Attrs where
    fromAttrs :: [Attribute] -> Locale_Attrs
fromAttrs as :: [Attribute]
as =
        Locale_Attrs :: String -> Locale_Attrs
Locale_Attrs
          { localeName :: String
localeName = (String -> Attribute -> Maybe String)
-> String -> String -> [Attribute] -> String
forall a.
(String -> Attribute -> Maybe a)
-> String -> String -> [Attribute] -> a
definiteA String -> Attribute -> Maybe String
fromAttrToStr "Locale" "name" [Attribute]
as
          }
    toAttrs :: Locale_Attrs -> [Attribute]
toAttrs v :: Locale_Attrs
v = [Maybe Attribute] -> [Attribute]
forall a. [Maybe a] -> [a]
catMaybes 
        [ String -> String -> Maybe Attribute
toAttrFrStr "name" (Locale_Attrs -> String
localeName Locale_Attrs
v)
        ]

instance HTypeable Cls where
    toHType :: Cls -> HType
toHType _ = String -> [HType] -> [Constr] -> HType
Defined "Cls" [] []
instance XmlContent Cls where
    toContents :: Cls -> [Content ()]
toContents (Cls as :: Cls_Attrs
as a :: Ctxt
a b :: [Parent]
b c :: Body
c) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N "Cls") (Cls_Attrs -> [Attribute]
forall a. XmlAttributes a => a -> [Attribute]
toAttrs Cls_Attrs
as) (Ctxt -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents Ctxt
a [Content ()] -> [Content ()] -> [Content ()]
forall a. [a] -> [a] -> [a]
++
                                             (Parent -> [Content ()]) -> [Parent] -> [Content ()]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap Parent -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents [Parent]
b [Content ()] -> [Content ()] -> [Content ()]
forall a. [a] -> [a] -> [a]
++ Body -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents Body
c)) ()]
    parseContents :: Parser (Content Posn) Cls
parseContents = do
        { e :: Element Posn
e@(Elem _ as :: [Attribute]
as _) <- [String] -> XMLParser (Element Posn)
element ["Cls"]
        ; Element Posn
-> Parser (Content Posn) Cls -> Parser (Content Posn) Cls
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (Parser (Content Posn) Cls -> Parser (Content Posn) Cls)
-> Parser (Content Posn) Cls -> Parser (Content Posn) Cls
forall a b. (a -> b) -> a -> b
$ (Ctxt -> [Parent] -> Body -> Cls)
-> Parser (Content Posn) (Ctxt -> [Parent] -> Body -> Cls)
forall (m :: * -> *) a. Monad m => a -> m a
return (Cls_Attrs -> Ctxt -> [Parent] -> Body -> Cls
Cls ([Attribute] -> Cls_Attrs
forall a. XmlAttributes a => [Attribute] -> a
fromAttrs [Attribute]
as)) Parser (Content Posn) (Ctxt -> [Parent] -> Body -> Cls)
-> Parser (Content Posn) Ctxt
-> Parser (Content Posn) ([Parent] -> Body -> Cls)
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) Ctxt
forall a. XmlContent a => XMLParser a
parseContents
                       Parser (Content Posn) ([Parent] -> Body -> Cls)
-> Parser (Content Posn) [Parent]
-> Parser (Content Posn) (Body -> Cls)
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) Parent -> Parser (Content Posn) [Parent]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many Parser (Content Posn) Parent
forall a. XmlContent a => XMLParser a
parseContents Parser (Content Posn) (Body -> Cls)
-> Parser (Content Posn) Body -> Parser (Content Posn) Cls
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) Body
forall a. XmlContent a => XMLParser a
parseContents
        } Parser (Content Posn) Cls -> ShowS -> Parser (Content Posn) Cls
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <Cls>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)
instance XmlAttributes Cls_Attrs where
    fromAttrs :: [Attribute] -> Cls_Attrs
fromAttrs as :: [Attribute]
as =
        Cls_Attrs :: String -> Cls_Attrs
Cls_Attrs
          { clsName :: String
clsName = (String -> Attribute -> Maybe String)
-> String -> String -> [Attribute] -> String
forall a.
(String -> Attribute -> Maybe a)
-> String -> String -> [Attribute] -> a
definiteA String -> Attribute -> Maybe String
fromAttrToStr "Cls" "name" [Attribute]
as
          }
    toAttrs :: Cls_Attrs -> [Attribute]
toAttrs v :: Cls_Attrs
v = [Maybe Attribute] -> [Attribute]
forall a. [Maybe a] -> [a]
catMaybes 
        [ String -> String -> Maybe Attribute
toAttrFrStr "name" (Cls_Attrs -> String
clsName Cls_Attrs
v)
        ]

instance HTypeable TypeSynonym where
    toHType :: TypeSynonym -> HType
toHType _ = String -> [HType] -> [Constr] -> HType
Defined "TypeSynonym" [] []
instance XmlContent TypeSynonym where
    toContents :: TypeSynonym -> [Content ()]
toContents (TypeSynonym as :: TypeSynonym_Attrs
as a :: Maybe Mixfix
a b :: Vars
b c :: OneOf3 TVar TFree Type
c) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N "TypeSynonym") (TypeSynonym_Attrs -> [Attribute]
forall a. XmlAttributes a => a -> [Attribute]
toAttrs TypeSynonym_Attrs
as) ([Content ()]
-> (Mixfix -> [Content ()]) -> Maybe Mixfix -> [Content ()]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] Mixfix -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents Maybe Mixfix
a
                                                     [Content ()] -> [Content ()] -> [Content ()]
forall a. [a] -> [a] -> [a]
++ Vars -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents Vars
b [Content ()] -> [Content ()] -> [Content ()]
forall a. [a] -> [a] -> [a]
++ OneOf3 TVar TFree Type -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents OneOf3 TVar TFree Type
c)) ()]
    parseContents :: Parser (Content Posn) TypeSynonym
parseContents = do
        { e :: Element Posn
e@(Elem _ as :: [Attribute]
as _) <- [String] -> XMLParser (Element Posn)
element ["TypeSynonym"]
        ; Element Posn
-> Parser (Content Posn) TypeSynonym
-> Parser (Content Posn) TypeSynonym
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (Parser (Content Posn) TypeSynonym
 -> Parser (Content Posn) TypeSynonym)
-> Parser (Content Posn) TypeSynonym
-> Parser (Content Posn) TypeSynonym
forall a b. (a -> b) -> a -> b
$ (Maybe Mixfix -> Vars -> OneOf3 TVar TFree Type -> TypeSynonym)
-> Parser
     (Content Posn)
     (Maybe Mixfix -> Vars -> OneOf3 TVar TFree Type -> TypeSynonym)
forall (m :: * -> *) a. Monad m => a -> m a
return (TypeSynonym_Attrs
-> Maybe Mixfix -> Vars -> OneOf3 TVar TFree Type -> TypeSynonym
TypeSynonym ([Attribute] -> TypeSynonym_Attrs
forall a. XmlAttributes a => [Attribute] -> a
fromAttrs [Attribute]
as))
                       Parser
  (Content Posn)
  (Maybe Mixfix -> Vars -> OneOf3 TVar TFree Type -> TypeSynonym)
-> Parser (Content Posn) (Maybe Mixfix)
-> Parser
     (Content Posn) (Vars -> OneOf3 TVar TFree Type -> TypeSynonym)
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) Mixfix
-> Parser (Content Posn) (Maybe Mixfix)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser (Content Posn) Mixfix
forall a. XmlContent a => XMLParser a
parseContents Parser
  (Content Posn) (Vars -> OneOf3 TVar TFree Type -> TypeSynonym)
-> Parser (Content Posn) Vars
-> Parser (Content Posn) (OneOf3 TVar TFree Type -> TypeSynonym)
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) Vars
forall a. XmlContent a => XMLParser a
parseContents
                       Parser (Content Posn) (OneOf3 TVar TFree Type -> TypeSynonym)
-> Parser (Content Posn) (OneOf3 TVar TFree Type)
-> Parser (Content Posn) TypeSynonym
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) (OneOf3 TVar TFree Type)
forall a. XmlContent a => XMLParser a
parseContents
        } Parser (Content Posn) TypeSynonym
-> ShowS -> Parser (Content Posn) TypeSynonym
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <TypeSynonym>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)
instance XmlAttributes TypeSynonym_Attrs where
    fromAttrs :: [Attribute] -> TypeSynonym_Attrs
fromAttrs as :: [Attribute]
as =
        TypeSynonym_Attrs :: String -> Maybe String -> TypeSynonym_Attrs
TypeSynonym_Attrs
          { typeSynonymName :: String
typeSynonymName = (String -> Attribute -> Maybe String)
-> String -> String -> [Attribute] -> String
forall a.
(String -> Attribute -> Maybe a)
-> String -> String -> [Attribute] -> a
definiteA String -> Attribute -> Maybe String
fromAttrToStr "TypeSynonym" "name" [Attribute]
as
          , typeSynonymTarget :: Maybe String
typeSynonymTarget = (String -> Attribute -> Maybe String)
-> String -> [Attribute] -> Maybe String
forall a.
(String -> Attribute -> Maybe a)
-> String -> [Attribute] -> Maybe a
possibleA String -> Attribute -> Maybe String
fromAttrToStr "target" [Attribute]
as
          }
    toAttrs :: TypeSynonym_Attrs -> [Attribute]
toAttrs v :: TypeSynonym_Attrs
v = [Maybe Attribute] -> [Attribute]
forall a. [Maybe a] -> [a]
catMaybes 
        [ String -> String -> Maybe Attribute
toAttrFrStr "name" (TypeSynonym_Attrs -> String
typeSynonymName TypeSynonym_Attrs
v)
        , (String -> String -> Maybe Attribute)
-> String -> Maybe String -> Maybe Attribute
forall a.
(String -> a -> Maybe Attribute)
-> String -> Maybe a -> Maybe Attribute
maybeToAttr String -> String -> Maybe Attribute
toAttrFrStr "target" (TypeSynonym_Attrs -> Maybe String
typeSynonymTarget TypeSynonym_Attrs
v)
        ]

instance HTypeable Datatypes where
    toHType :: Datatypes -> HType
toHType _ = String -> [HType] -> [Constr] -> HType
Defined "Datatypes" [] []
instance XmlContent Datatypes where
    toContents :: Datatypes -> [Content ()]
toContents (Datatypes a :: List1 Datatype
a) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N "Datatypes") [] (List1 Datatype -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents List1 Datatype
a)) ()]
    parseContents :: Parser (Content Posn) Datatypes
parseContents = do
        { e :: Element Posn
e@(Elem _ [] _) <- [String] -> XMLParser (Element Posn)
element ["Datatypes"]
        ; Element Posn
-> Parser (Content Posn) Datatypes
-> Parser (Content Posn) Datatypes
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (Parser (Content Posn) Datatypes
 -> Parser (Content Posn) Datatypes)
-> Parser (Content Posn) Datatypes
-> Parser (Content Posn) Datatypes
forall a b. (a -> b) -> a -> b
$ (List1 Datatype -> Datatypes)
-> Parser (Content Posn) (List1 Datatype -> Datatypes)
forall (m :: * -> *) a. Monad m => a -> m a
return (List1 Datatype -> Datatypes
Datatypes) Parser (Content Posn) (List1 Datatype -> Datatypes)
-> Parser (Content Posn) (List1 Datatype)
-> Parser (Content Posn) Datatypes
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) (List1 Datatype)
forall a. XmlContent a => XMLParser a
parseContents
        } Parser (Content Posn) Datatypes
-> ShowS -> Parser (Content Posn) Datatypes
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <Datatypes>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)

instance HTypeable Datatype where
    toHType :: Datatype -> HType
toHType _ = String -> [HType] -> [Constr] -> HType
Defined "Datatype" [] []
instance XmlContent Datatype where
    toContents :: Datatype -> [Content ()]
toContents (Datatype as :: Datatype_Attrs
as a :: Maybe Mixfix
a b :: List1 Constructor
b c :: [TFree]
c) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N "Datatype") (Datatype_Attrs -> [Attribute]
forall a. XmlAttributes a => a -> [Attribute]
toAttrs Datatype_Attrs
as) ([Content ()]
-> (Mixfix -> [Content ()]) -> Maybe Mixfix -> [Content ()]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] Mixfix -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents Maybe Mixfix
a [Content ()] -> [Content ()] -> [Content ()]
forall a. [a] -> [a] -> [a]
++
                                                  List1 Constructor -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents List1 Constructor
b [Content ()] -> [Content ()] -> [Content ()]
forall a. [a] -> [a] -> [a]
++ (TFree -> [Content ()]) -> [TFree] -> [Content ()]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap TFree -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents [TFree]
c)) ()]
    parseContents :: XMLParser Datatype
parseContents = do
        { e :: Element Posn
e@(Elem _ as :: [Attribute]
as _) <- [String] -> XMLParser (Element Posn)
element ["Datatype"]
        ; Element Posn -> XMLParser Datatype -> XMLParser Datatype
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (XMLParser Datatype -> XMLParser Datatype)
-> XMLParser Datatype -> XMLParser Datatype
forall a b. (a -> b) -> a -> b
$ (Maybe Mixfix -> List1 Constructor -> [TFree] -> Datatype)
-> Parser
     (Content Posn)
     (Maybe Mixfix -> List1 Constructor -> [TFree] -> Datatype)
forall (m :: * -> *) a. Monad m => a -> m a
return (Datatype_Attrs
-> Maybe Mixfix -> List1 Constructor -> [TFree] -> Datatype
Datatype ([Attribute] -> Datatype_Attrs
forall a. XmlAttributes a => [Attribute] -> a
fromAttrs [Attribute]
as))
                       Parser
  (Content Posn)
  (Maybe Mixfix -> List1 Constructor -> [TFree] -> Datatype)
-> Parser (Content Posn) (Maybe Mixfix)
-> Parser (Content Posn) (List1 Constructor -> [TFree] -> Datatype)
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) Mixfix
-> Parser (Content Posn) (Maybe Mixfix)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser (Content Posn) Mixfix
forall a. XmlContent a => XMLParser a
parseContents Parser (Content Posn) (List1 Constructor -> [TFree] -> Datatype)
-> Parser (Content Posn) (List1 Constructor)
-> Parser (Content Posn) ([TFree] -> Datatype)
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) (List1 Constructor)
forall a. XmlContent a => XMLParser a
parseContents
                       Parser (Content Posn) ([TFree] -> Datatype)
-> Parser (Content Posn) [TFree] -> XMLParser Datatype
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) TFree -> Parser (Content Posn) [TFree]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many Parser (Content Posn) TFree
forall a. XmlContent a => XMLParser a
parseContents
        } XMLParser Datatype -> ShowS -> XMLParser Datatype
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <Datatype>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)
instance XmlAttributes Datatype_Attrs where
    fromAttrs :: [Attribute] -> Datatype_Attrs
fromAttrs as :: [Attribute]
as =
        Datatype_Attrs :: String -> Datatype_Attrs
Datatype_Attrs
          { datatypeName :: String
datatypeName = (String -> Attribute -> Maybe String)
-> String -> String -> [Attribute] -> String
forall a.
(String -> Attribute -> Maybe a)
-> String -> String -> [Attribute] -> a
definiteA String -> Attribute -> Maybe String
fromAttrToStr "Datatype" "name" [Attribute]
as
          }
    toAttrs :: Datatype_Attrs -> [Attribute]
toAttrs v :: Datatype_Attrs
v = [Maybe Attribute] -> [Attribute]
forall a. [Maybe a] -> [a]
catMaybes 
        [ String -> String -> Maybe Attribute
toAttrFrStr "name" (Datatype_Attrs -> String
datatypeName Datatype_Attrs
v)
        ]

instance HTypeable Constructor where
    toHType :: Constructor -> HType
toHType _ = String -> [HType] -> [Constr] -> HType
Defined "Constructor" [] []
instance XmlContent Constructor where
    toContents :: Constructor -> [Content ()]
toContents (Constructor as :: Constructor_Attrs
as a :: Maybe Mixfix
a b :: OneOf3 TVar TFree Type
b c :: [OneOf3 TVar TFree Type]
c) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N "Constructor") (Constructor_Attrs -> [Attribute]
forall a. XmlAttributes a => a -> [Attribute]
toAttrs Constructor_Attrs
as) ([Content ()]
-> (Mixfix -> [Content ()]) -> Maybe Mixfix -> [Content ()]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] Mixfix -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents Maybe Mixfix
a
                                                     [Content ()] -> [Content ()] -> [Content ()]
forall a. [a] -> [a] -> [a]
++ OneOf3 TVar TFree Type -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents OneOf3 TVar TFree Type
b [Content ()] -> [Content ()] -> [Content ()]
forall a. [a] -> [a] -> [a]
++ (OneOf3 TVar TFree Type -> [Content ()])
-> [OneOf3 TVar TFree Type] -> [Content ()]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap OneOf3 TVar TFree Type -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents [OneOf3 TVar TFree Type]
c)) ()]
    parseContents :: XMLParser Constructor
parseContents = do
        { e :: Element Posn
e@(Elem _ as :: [Attribute]
as _) <- [String] -> XMLParser (Element Posn)
element ["Constructor"]
        ; Element Posn -> XMLParser Constructor -> XMLParser Constructor
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (XMLParser Constructor -> XMLParser Constructor)
-> XMLParser Constructor -> XMLParser Constructor
forall a b. (a -> b) -> a -> b
$ (Maybe Mixfix
 -> OneOf3 TVar TFree Type
 -> [OneOf3 TVar TFree Type]
 -> Constructor)
-> Parser
     (Content Posn)
     (Maybe Mixfix
      -> OneOf3 TVar TFree Type
      -> [OneOf3 TVar TFree Type]
      -> Constructor)
forall (m :: * -> *) a. Monad m => a -> m a
return (Constructor_Attrs
-> Maybe Mixfix
-> OneOf3 TVar TFree Type
-> [OneOf3 TVar TFree Type]
-> Constructor
Constructor ([Attribute] -> Constructor_Attrs
forall a. XmlAttributes a => [Attribute] -> a
fromAttrs [Attribute]
as))
                       Parser
  (Content Posn)
  (Maybe Mixfix
   -> OneOf3 TVar TFree Type
   -> [OneOf3 TVar TFree Type]
   -> Constructor)
-> Parser (Content Posn) (Maybe Mixfix)
-> Parser
     (Content Posn)
     (OneOf3 TVar TFree Type -> [OneOf3 TVar TFree Type] -> Constructor)
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) Mixfix
-> Parser (Content Posn) (Maybe Mixfix)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser (Content Posn) Mixfix
forall a. XmlContent a => XMLParser a
parseContents Parser
  (Content Posn)
  (OneOf3 TVar TFree Type -> [OneOf3 TVar TFree Type] -> Constructor)
-> Parser (Content Posn) (OneOf3 TVar TFree Type)
-> Parser (Content Posn) ([OneOf3 TVar TFree Type] -> Constructor)
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) (OneOf3 TVar TFree Type)
forall a. XmlContent a => XMLParser a
parseContents
                       Parser (Content Posn) ([OneOf3 TVar TFree Type] -> Constructor)
-> Parser (Content Posn) [OneOf3 TVar TFree Type]
-> XMLParser Constructor
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) (OneOf3 TVar TFree Type)
-> Parser (Content Posn) [OneOf3 TVar TFree Type]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many Parser (Content Posn) (OneOf3 TVar TFree Type)
forall a. XmlContent a => XMLParser a
parseContents
        } XMLParser Constructor -> ShowS -> XMLParser Constructor
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <Constructor>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)
instance XmlAttributes Constructor_Attrs where
    fromAttrs :: [Attribute] -> Constructor_Attrs
fromAttrs as :: [Attribute]
as =
        Constructor_Attrs :: Maybe String -> Constructor_Attrs
Constructor_Attrs
          { constructorName :: Maybe String
constructorName = (String -> Attribute -> Maybe String)
-> String -> [Attribute] -> Maybe String
forall a.
(String -> Attribute -> Maybe a)
-> String -> [Attribute] -> Maybe a
possibleA String -> Attribute -> Maybe String
fromAttrToStr "name" [Attribute]
as
          }
    toAttrs :: Constructor_Attrs -> [Attribute]
toAttrs v :: Constructor_Attrs
v = [Maybe Attribute] -> [Attribute]
forall a. [Maybe a] -> [a]
catMaybes 
        [ (String -> String -> Maybe Attribute)
-> String -> Maybe String -> Maybe Attribute
forall a.
(String -> a -> Maybe Attribute)
-> String -> Maybe a -> Maybe Attribute
maybeToAttr String -> String -> Maybe Attribute
toAttrFrStr "name" (Constructor_Attrs -> Maybe String
constructorName Constructor_Attrs
v)
        ]

instance HTypeable Domains where
    toHType :: Domains -> HType
toHType _ = String -> [HType] -> [Constr] -> HType
Defined "Domains" [] []
instance XmlContent Domains where
    toContents :: Domains -> [Content ()]
toContents (Domains a :: List1 Domain
a) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N "Domains") [] (List1 Domain -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents List1 Domain
a)) ()]
    parseContents :: Parser (Content Posn) Domains
parseContents = do
        { e :: Element Posn
e@(Elem _ [] _) <- [String] -> XMLParser (Element Posn)
element ["Domains"]
        ; Element Posn
-> Parser (Content Posn) Domains -> Parser (Content Posn) Domains
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (Parser (Content Posn) Domains -> Parser (Content Posn) Domains)
-> Parser (Content Posn) Domains -> Parser (Content Posn) Domains
forall a b. (a -> b) -> a -> b
$ (List1 Domain -> Domains)
-> Parser (Content Posn) (List1 Domain -> Domains)
forall (m :: * -> *) a. Monad m => a -> m a
return (List1 Domain -> Domains
Domains) Parser (Content Posn) (List1 Domain -> Domains)
-> Parser (Content Posn) (List1 Domain)
-> Parser (Content Posn) Domains
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) (List1 Domain)
forall a. XmlContent a => XMLParser a
parseContents
        } Parser (Content Posn) Domains
-> ShowS -> Parser (Content Posn) Domains
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <Domains>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)

instance HTypeable Domain where
    toHType :: Domain -> HType
toHType _ = String -> [HType] -> [Constr] -> HType
Defined "Domain" [] []
instance XmlContent Domain where
    toContents :: Domain -> [Content ()]
toContents (Domain as :: Domain_Attrs
as a :: Maybe Mixfix
a b :: [TFree]
b c :: List1 DomainConstructor
c) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N "Domain") (Domain_Attrs -> [Attribute]
forall a. XmlAttributes a => a -> [Attribute]
toAttrs Domain_Attrs
as) ([Content ()]
-> (Mixfix -> [Content ()]) -> Maybe Mixfix -> [Content ()]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] Mixfix -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents Maybe Mixfix
a [Content ()] -> [Content ()] -> [Content ()]
forall a. [a] -> [a] -> [a]
++
                                                (TFree -> [Content ()]) -> [TFree] -> [Content ()]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap TFree -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents [TFree]
b [Content ()] -> [Content ()] -> [Content ()]
forall a. [a] -> [a] -> [a]
++ List1 DomainConstructor -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents List1 DomainConstructor
c)) ()]
    parseContents :: XMLParser Domain
parseContents = do
        { e :: Element Posn
e@(Elem _ as :: [Attribute]
as _) <- [String] -> XMLParser (Element Posn)
element ["Domain"]
        ; Element Posn -> XMLParser Domain -> XMLParser Domain
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (XMLParser Domain -> XMLParser Domain)
-> XMLParser Domain -> XMLParser Domain
forall a b. (a -> b) -> a -> b
$ (Maybe Mixfix -> [TFree] -> List1 DomainConstructor -> Domain)
-> Parser
     (Content Posn)
     (Maybe Mixfix -> [TFree] -> List1 DomainConstructor -> Domain)
forall (m :: * -> *) a. Monad m => a -> m a
return (Domain_Attrs
-> Maybe Mixfix -> [TFree] -> List1 DomainConstructor -> Domain
Domain ([Attribute] -> Domain_Attrs
forall a. XmlAttributes a => [Attribute] -> a
fromAttrs [Attribute]
as))
                       Parser
  (Content Posn)
  (Maybe Mixfix -> [TFree] -> List1 DomainConstructor -> Domain)
-> Parser (Content Posn) (Maybe Mixfix)
-> Parser
     (Content Posn) ([TFree] -> List1 DomainConstructor -> Domain)
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) Mixfix
-> Parser (Content Posn) (Maybe Mixfix)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser (Content Posn) Mixfix
forall a. XmlContent a => XMLParser a
parseContents Parser
  (Content Posn) ([TFree] -> List1 DomainConstructor -> Domain)
-> Parser (Content Posn) [TFree]
-> Parser (Content Posn) (List1 DomainConstructor -> Domain)
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) TFree -> Parser (Content Posn) [TFree]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many Parser (Content Posn) TFree
forall a. XmlContent a => XMLParser a
parseContents
                       Parser (Content Posn) (List1 DomainConstructor -> Domain)
-> Parser (Content Posn) (List1 DomainConstructor)
-> XMLParser Domain
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) (List1 DomainConstructor)
forall a. XmlContent a => XMLParser a
parseContents
        } XMLParser Domain -> ShowS -> XMLParser Domain
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <Domain>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)
instance XmlAttributes Domain_Attrs where
    fromAttrs :: [Attribute] -> Domain_Attrs
fromAttrs as :: [Attribute]
as =
        Domain_Attrs :: String -> Domain_Attrs
Domain_Attrs
          { domainName :: String
domainName = (String -> Attribute -> Maybe String)
-> String -> String -> [Attribute] -> String
forall a.
(String -> Attribute -> Maybe a)
-> String -> String -> [Attribute] -> a
definiteA String -> Attribute -> Maybe String
fromAttrToStr "Domain" "name" [Attribute]
as
          }
    toAttrs :: Domain_Attrs -> [Attribute]
toAttrs v :: Domain_Attrs
v = [Maybe Attribute] -> [Attribute]
forall a. [Maybe a] -> [a]
catMaybes 
        [ String -> String -> Maybe Attribute
toAttrFrStr "name" (Domain_Attrs -> String
domainName Domain_Attrs
v)
        ]

instance HTypeable DomainConstructor where
    toHType :: DomainConstructor -> HType
toHType _ = String -> [HType] -> [Constr] -> HType
Defined "DomainConstructor" [] []
instance XmlContent DomainConstructor where
    toContents :: DomainConstructor -> [Content ()]
toContents (DomainConstructor as :: DomainConstructor_Attrs
as a :: OneOf3 TVar TFree Type
a b :: [DomainConstructorArg]
b) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N "DomainConstructor") (DomainConstructor_Attrs -> [Attribute]
forall a. XmlAttributes a => a -> [Attribute]
toAttrs DomainConstructor_Attrs
as) (OneOf3 TVar TFree Type -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents OneOf3 TVar TFree Type
a [Content ()] -> [Content ()] -> [Content ()]
forall a. [a] -> [a] -> [a]
++
                                                           (DomainConstructorArg -> [Content ()])
-> [DomainConstructorArg] -> [Content ()]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap DomainConstructorArg -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents [DomainConstructorArg]
b)) ()]
    parseContents :: XMLParser DomainConstructor
parseContents = do
        { e :: Element Posn
e@(Elem _ as :: [Attribute]
as _) <- [String] -> XMLParser (Element Posn)
element ["DomainConstructor"]
        ; Element Posn
-> XMLParser DomainConstructor -> XMLParser DomainConstructor
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (XMLParser DomainConstructor -> XMLParser DomainConstructor)
-> XMLParser DomainConstructor -> XMLParser DomainConstructor
forall a b. (a -> b) -> a -> b
$ (OneOf3 TVar TFree Type
 -> [DomainConstructorArg] -> DomainConstructor)
-> Parser
     (Content Posn)
     (OneOf3 TVar TFree Type
      -> [DomainConstructorArg] -> DomainConstructor)
forall (m :: * -> *) a. Monad m => a -> m a
return (DomainConstructor_Attrs
-> OneOf3 TVar TFree Type
-> [DomainConstructorArg]
-> DomainConstructor
DomainConstructor ([Attribute] -> DomainConstructor_Attrs
forall a. XmlAttributes a => [Attribute] -> a
fromAttrs [Attribute]
as))
                       Parser
  (Content Posn)
  (OneOf3 TVar TFree Type
   -> [DomainConstructorArg] -> DomainConstructor)
-> Parser (Content Posn) (OneOf3 TVar TFree Type)
-> Parser
     (Content Posn) ([DomainConstructorArg] -> DomainConstructor)
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) (OneOf3 TVar TFree Type)
forall a. XmlContent a => XMLParser a
parseContents Parser (Content Posn) ([DomainConstructorArg] -> DomainConstructor)
-> Parser (Content Posn) [DomainConstructorArg]
-> XMLParser DomainConstructor
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) DomainConstructorArg
-> Parser (Content Posn) [DomainConstructorArg]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many Parser (Content Posn) DomainConstructorArg
forall a. XmlContent a => XMLParser a
parseContents
        } XMLParser DomainConstructor -> ShowS -> XMLParser DomainConstructor
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <DomainConstructor>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)
instance XmlAttributes DomainConstructor_Attrs where
    fromAttrs :: [Attribute] -> DomainConstructor_Attrs
fromAttrs as :: [Attribute]
as =
        DomainConstructor_Attrs :: String -> DomainConstructor_Attrs
DomainConstructor_Attrs
          { domainConstructorName :: String
domainConstructorName = (String -> Attribute -> Maybe String)
-> String -> String -> [Attribute] -> String
forall a.
(String -> Attribute -> Maybe a)
-> String -> String -> [Attribute] -> a
definiteA String -> Attribute -> Maybe String
fromAttrToStr "DomainConstructor" "name" [Attribute]
as
          }
    toAttrs :: DomainConstructor_Attrs -> [Attribute]
toAttrs v :: DomainConstructor_Attrs
v = [Maybe Attribute] -> [Attribute]
forall a. [Maybe a] -> [a]
catMaybes 
        [ String -> String -> Maybe Attribute
toAttrFrStr "name" (DomainConstructor_Attrs -> String
domainConstructorName DomainConstructor_Attrs
v)
        ]

instance HTypeable DomainConstructorArg where
    toHType :: DomainConstructorArg -> HType
toHType _ = String -> [HType] -> [Constr] -> HType
Defined "DomainConstructorArg" [] []
instance XmlContent DomainConstructorArg where
    toContents :: DomainConstructorArg -> [Content ()]
toContents (DomainConstructorArg as :: DomainConstructorArg_Attrs
as a :: OneOf3 TVar TFree Type
a) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N "DomainConstructorArg") (DomainConstructorArg_Attrs -> [Attribute]
forall a. XmlAttributes a => a -> [Attribute]
toAttrs DomainConstructorArg_Attrs
as) (OneOf3 TVar TFree Type -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents OneOf3 TVar TFree Type
a)) ()]
    parseContents :: Parser (Content Posn) DomainConstructorArg
parseContents = do
        { e :: Element Posn
e@(Elem _ as :: [Attribute]
as _) <- [String] -> XMLParser (Element Posn)
element ["DomainConstructorArg"]
        ; Element Posn
-> Parser (Content Posn) DomainConstructorArg
-> Parser (Content Posn) DomainConstructorArg
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (Parser (Content Posn) DomainConstructorArg
 -> Parser (Content Posn) DomainConstructorArg)
-> Parser (Content Posn) DomainConstructorArg
-> Parser (Content Posn) DomainConstructorArg
forall a b. (a -> b) -> a -> b
$ (OneOf3 TVar TFree Type -> DomainConstructorArg)
-> Parser
     (Content Posn) (OneOf3 TVar TFree Type -> DomainConstructorArg)
forall (m :: * -> *) a. Monad m => a -> m a
return (DomainConstructorArg_Attrs
-> OneOf3 TVar TFree Type -> DomainConstructorArg
DomainConstructorArg ([Attribute] -> DomainConstructorArg_Attrs
forall a. XmlAttributes a => [Attribute] -> a
fromAttrs [Attribute]
as))
                       Parser
  (Content Posn) (OneOf3 TVar TFree Type -> DomainConstructorArg)
-> Parser (Content Posn) (OneOf3 TVar TFree Type)
-> Parser (Content Posn) DomainConstructorArg
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) (OneOf3 TVar TFree Type)
forall a. XmlContent a => XMLParser a
parseContents
        } Parser (Content Posn) DomainConstructorArg
-> ShowS -> Parser (Content Posn) DomainConstructorArg
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <DomainConstructorArg>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)
instance XmlAttributes DomainConstructorArg_Attrs where
    fromAttrs :: [Attribute] -> DomainConstructorArg_Attrs
fromAttrs as :: [Attribute]
as =
        DomainConstructorArg_Attrs :: Maybe String -> Maybe String -> DomainConstructorArg_Attrs
DomainConstructorArg_Attrs
          { domainConstructorArgLazy :: Maybe String
domainConstructorArgLazy = (String -> Attribute -> Maybe String)
-> String -> [Attribute] -> Maybe String
forall a.
(String -> Attribute -> Maybe a)
-> String -> [Attribute] -> Maybe a
possibleA String -> Attribute -> Maybe String
fromAttrToStr "lazy" [Attribute]
as
          , domainConstructorArgName :: Maybe String
domainConstructorArgName = (String -> Attribute -> Maybe String)
-> String -> [Attribute] -> Maybe String
forall a.
(String -> Attribute -> Maybe a)
-> String -> [Attribute] -> Maybe a
possibleA String -> Attribute -> Maybe String
fromAttrToStr "name" [Attribute]
as
          }
    toAttrs :: DomainConstructorArg_Attrs -> [Attribute]
toAttrs v :: DomainConstructorArg_Attrs
v = [Maybe Attribute] -> [Attribute]
forall a. [Maybe a] -> [a]
catMaybes 
        [ (String -> String -> Maybe Attribute)
-> String -> Maybe String -> Maybe Attribute
forall a.
(String -> a -> Maybe Attribute)
-> String -> Maybe a -> Maybe Attribute
maybeToAttr String -> String -> Maybe Attribute
toAttrFrStr "lazy" (DomainConstructorArg_Attrs -> Maybe String
domainConstructorArgLazy DomainConstructorArg_Attrs
v)
        , (String -> String -> Maybe Attribute)
-> String -> Maybe String -> Maybe Attribute
forall a.
(String -> a -> Maybe Attribute)
-> String -> Maybe a -> Maybe Attribute
maybeToAttr String -> String -> Maybe Attribute
toAttrFrStr "name" (DomainConstructorArg_Attrs -> Maybe String
domainConstructorArgName DomainConstructorArg_Attrs
v)
        ]

instance HTypeable Consts where
    toHType :: Consts -> HType
toHType _ = String -> [HType] -> [Constr] -> HType
Defined "Consts" [] []
instance XmlContent Consts where
    toContents :: Consts -> [Content ()]
toContents (Consts a :: List1 ConstDef
a) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N "Consts") [] (List1 ConstDef -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents List1 ConstDef
a)) ()]
    parseContents :: Parser (Content Posn) Consts
parseContents = do
        { e :: Element Posn
e@(Elem _ [] _) <- [String] -> XMLParser (Element Posn)
element ["Consts"]
        ; Element Posn
-> Parser (Content Posn) Consts -> Parser (Content Posn) Consts
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (Parser (Content Posn) Consts -> Parser (Content Posn) Consts)
-> Parser (Content Posn) Consts -> Parser (Content Posn) Consts
forall a b. (a -> b) -> a -> b
$ (List1 ConstDef -> Consts)
-> Parser (Content Posn) (List1 ConstDef -> Consts)
forall (m :: * -> *) a. Monad m => a -> m a
return (List1 ConstDef -> Consts
Consts) Parser (Content Posn) (List1 ConstDef -> Consts)
-> Parser (Content Posn) (List1 ConstDef)
-> Parser (Content Posn) Consts
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) (List1 ConstDef)
forall a. XmlContent a => XMLParser a
parseContents
        } Parser (Content Posn) Consts
-> ShowS -> Parser (Content Posn) Consts
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <Consts>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)

instance HTypeable ConstDef where
    toHType :: ConstDef -> HType
toHType _ = String -> [HType] -> [Constr] -> HType
Defined "ConstDef" [] []
instance XmlContent ConstDef where
    toContents :: ConstDef -> [Content ()]
toContents (ConstDef as :: ConstDef_Attrs
as a :: Maybe Mixfix
a b :: OneOf3 TVar TFree Type
b) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N "ConstDef") (ConstDef_Attrs -> [Attribute]
forall a. XmlAttributes a => a -> [Attribute]
toAttrs ConstDef_Attrs
as) ([Content ()]
-> (Mixfix -> [Content ()]) -> Maybe Mixfix -> [Content ()]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] Mixfix -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents Maybe Mixfix
a [Content ()] -> [Content ()] -> [Content ()]
forall a. [a] -> [a] -> [a]
++
                                                  OneOf3 TVar TFree Type -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents OneOf3 TVar TFree Type
b)) ()]
    parseContents :: XMLParser ConstDef
parseContents = do
        { e :: Element Posn
e@(Elem _ as :: [Attribute]
as _) <- [String] -> XMLParser (Element Posn)
element ["ConstDef"]
        ; Element Posn -> XMLParser ConstDef -> XMLParser ConstDef
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (XMLParser ConstDef -> XMLParser ConstDef)
-> XMLParser ConstDef -> XMLParser ConstDef
forall a b. (a -> b) -> a -> b
$ (Maybe Mixfix -> OneOf3 TVar TFree Type -> ConstDef)
-> Parser
     (Content Posn) (Maybe Mixfix -> OneOf3 TVar TFree Type -> ConstDef)
forall (m :: * -> *) a. Monad m => a -> m a
return (ConstDef_Attrs
-> Maybe Mixfix -> OneOf3 TVar TFree Type -> ConstDef
ConstDef ([Attribute] -> ConstDef_Attrs
forall a. XmlAttributes a => [Attribute] -> a
fromAttrs [Attribute]
as))
                       Parser
  (Content Posn) (Maybe Mixfix -> OneOf3 TVar TFree Type -> ConstDef)
-> Parser (Content Posn) (Maybe Mixfix)
-> Parser (Content Posn) (OneOf3 TVar TFree Type -> ConstDef)
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) Mixfix
-> Parser (Content Posn) (Maybe Mixfix)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser (Content Posn) Mixfix
forall a. XmlContent a => XMLParser a
parseContents Parser (Content Posn) (OneOf3 TVar TFree Type -> ConstDef)
-> Parser (Content Posn) (OneOf3 TVar TFree Type)
-> XMLParser ConstDef
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) (OneOf3 TVar TFree Type)
forall a. XmlContent a => XMLParser a
parseContents
        } XMLParser ConstDef -> ShowS -> XMLParser ConstDef
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <ConstDef>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)
instance XmlAttributes ConstDef_Attrs where
    fromAttrs :: [Attribute] -> ConstDef_Attrs
fromAttrs as :: [Attribute]
as =
        ConstDef_Attrs :: String -> ConstDef_Attrs
ConstDef_Attrs
          { constDefName :: String
constDefName = (String -> Attribute -> Maybe String)
-> String -> String -> [Attribute] -> String
forall a.
(String -> Attribute -> Maybe a)
-> String -> String -> [Attribute] -> a
definiteA String -> Attribute -> Maybe String
fromAttrToStr "ConstDef" "name" [Attribute]
as
          }
    toAttrs :: ConstDef_Attrs -> [Attribute]
toAttrs v :: ConstDef_Attrs
v = [Maybe Attribute] -> [Attribute]
forall a. [Maybe a] -> [a]
catMaybes 
        [ String -> String -> Maybe Attribute
toAttrFrStr "name" (ConstDef_Attrs -> String
constDefName ConstDef_Attrs
v)
        ]

instance HTypeable Axioms where
    toHType :: Axioms -> HType
toHType _ = String -> [HType] -> [Constr] -> HType
Defined "Axioms" [] []
instance XmlContent Axioms where
    toContents :: Axioms -> [Content ()]
toContents (Axioms a :: List1 Axiom
a) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N "Axioms") [] (List1 Axiom -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents List1 Axiom
a)) ()]
    parseContents :: Parser (Content Posn) Axioms
parseContents = do
        { e :: Element Posn
e@(Elem _ [] _) <- [String] -> XMLParser (Element Posn)
element ["Axioms"]
        ; Element Posn
-> Parser (Content Posn) Axioms -> Parser (Content Posn) Axioms
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (Parser (Content Posn) Axioms -> Parser (Content Posn) Axioms)
-> Parser (Content Posn) Axioms -> Parser (Content Posn) Axioms
forall a b. (a -> b) -> a -> b
$ (List1 Axiom -> Axioms)
-> Parser (Content Posn) (List1 Axiom -> Axioms)
forall (m :: * -> *) a. Monad m => a -> m a
return (List1 Axiom -> Axioms
Axioms) Parser (Content Posn) (List1 Axiom -> Axioms)
-> Parser (Content Posn) (List1 Axiom)
-> Parser (Content Posn) Axioms
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) (List1 Axiom)
forall a. XmlContent a => XMLParser a
parseContents
        } Parser (Content Posn) Axioms
-> ShowS -> Parser (Content Posn) Axioms
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <Axioms>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)

instance HTypeable Axiom where
    toHType :: Axiom -> HType
toHType _ = String -> [HType] -> [Constr] -> HType
Defined "Axiom" [] []
instance XmlContent Axiom where
    toContents :: Axiom -> [Content ()]
toContents (Axiom as :: Axiom_Attrs
as a :: OneOf6 Bound Free Var Const App Abs
a) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N "Axiom") (Axiom_Attrs -> [Attribute]
forall a. XmlAttributes a => a -> [Attribute]
toAttrs Axiom_Attrs
as) (OneOf6 Bound Free Var Const App Abs -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents OneOf6 Bound Free Var Const App Abs
a)) ()]
    parseContents :: XMLParser Axiom
parseContents = do
        { e :: Element Posn
e@(Elem _ as :: [Attribute]
as _) <- [String] -> XMLParser (Element Posn)
element ["Axiom"]
        ; Element Posn -> XMLParser Axiom -> XMLParser Axiom
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (XMLParser Axiom -> XMLParser Axiom)
-> XMLParser Axiom -> XMLParser Axiom
forall a b. (a -> b) -> a -> b
$ (OneOf6 Bound Free Var Const App Abs -> Axiom)
-> Parser
     (Content Posn) (OneOf6 Bound Free Var Const App Abs -> Axiom)
forall (m :: * -> *) a. Monad m => a -> m a
return (Axiom_Attrs -> OneOf6 Bound Free Var Const App Abs -> Axiom
Axiom ([Attribute] -> Axiom_Attrs
forall a. XmlAttributes a => [Attribute] -> a
fromAttrs [Attribute]
as)) Parser
  (Content Posn) (OneOf6 Bound Free Var Const App Abs -> Axiom)
-> Parser (Content Posn) (OneOf6 Bound Free Var Const App Abs)
-> XMLParser Axiom
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) (OneOf6 Bound Free Var Const App Abs)
forall a. XmlContent a => XMLParser a
parseContents
        } XMLParser Axiom -> ShowS -> XMLParser Axiom
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <Axiom>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)
instance XmlAttributes Axiom_Attrs where
    fromAttrs :: [Attribute] -> Axiom_Attrs
fromAttrs as :: [Attribute]
as =
        Axiom_Attrs :: String -> String -> Axiom_Attrs
Axiom_Attrs
          { axiomName :: String
axiomName = (String -> Attribute -> Maybe String)
-> String -> String -> [Attribute] -> String
forall a.
(String -> Attribute -> Maybe a)
-> String -> String -> [Attribute] -> a
definiteA String -> Attribute -> Maybe String
fromAttrToStr "Axiom" "name" [Attribute]
as
          , axiomArgs :: String
axiomArgs = (String -> Attribute -> Maybe String)
-> String -> String -> [Attribute] -> String
forall a.
(String -> Attribute -> Maybe a)
-> String -> String -> [Attribute] -> a
definiteA String -> Attribute -> Maybe String
fromAttrToStr "Axiom" "args" [Attribute]
as
          }
    toAttrs :: Axiom_Attrs -> [Attribute]
toAttrs v :: Axiom_Attrs
v = [Maybe Attribute] -> [Attribute]
forall a. [Maybe a] -> [a]
catMaybes 
        [ String -> String -> Maybe Attribute
toAttrFrStr "name" (Axiom_Attrs -> String
axiomName Axiom_Attrs
v)
        , String -> String -> Maybe Attribute
toAttrFrStr "args" (Axiom_Attrs -> String
axiomArgs Axiom_Attrs
v)
        ]

instance HTypeable Lemma where
    toHType :: Lemma -> HType
toHType _ = String -> [HType] -> [Constr] -> HType
Defined "Lemma" [] []
instance XmlContent Lemma where
    toContents :: Lemma -> [Content ()]
toContents (Lemma as :: Lemma_Attrs
as a :: Ctxt
a b :: Proof
b c :: List1 Shows
c) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N "Lemma") (Lemma_Attrs -> [Attribute]
forall a. XmlAttributes a => a -> [Attribute]
toAttrs Lemma_Attrs
as) (Ctxt -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents Ctxt
a [Content ()] -> [Content ()] -> [Content ()]
forall a. [a] -> [a] -> [a]
++ Proof -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents Proof
b
                                               [Content ()] -> [Content ()] -> [Content ()]
forall a. [a] -> [a] -> [a]
++ List1 Shows -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents List1 Shows
c)) ()]
    parseContents :: Parser (Content Posn) Lemma
parseContents = do
        { e :: Element Posn
e@(Elem _ as :: [Attribute]
as _) <- [String] -> XMLParser (Element Posn)
element ["Lemma"]
        ; Element Posn
-> Parser (Content Posn) Lemma -> Parser (Content Posn) Lemma
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (Parser (Content Posn) Lemma -> Parser (Content Posn) Lemma)
-> Parser (Content Posn) Lemma -> Parser (Content Posn) Lemma
forall a b. (a -> b) -> a -> b
$ (Ctxt -> Proof -> List1 Shows -> Lemma)
-> Parser (Content Posn) (Ctxt -> Proof -> List1 Shows -> Lemma)
forall (m :: * -> *) a. Monad m => a -> m a
return (Lemma_Attrs -> Ctxt -> Proof -> List1 Shows -> Lemma
Lemma ([Attribute] -> Lemma_Attrs
forall a. XmlAttributes a => [Attribute] -> a
fromAttrs [Attribute]
as)) Parser (Content Posn) (Ctxt -> Proof -> List1 Shows -> Lemma)
-> Parser (Content Posn) Ctxt
-> Parser (Content Posn) (Proof -> List1 Shows -> Lemma)
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) Ctxt
forall a. XmlContent a => XMLParser a
parseContents
                       Parser (Content Posn) (Proof -> List1 Shows -> Lemma)
-> Parser (Content Posn) Proof
-> Parser (Content Posn) (List1 Shows -> Lemma)
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) Proof
forall a. XmlContent a => XMLParser a
parseContents Parser (Content Posn) (List1 Shows -> Lemma)
-> Parser (Content Posn) (List1 Shows)
-> Parser (Content Posn) Lemma
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) (List1 Shows)
forall a. XmlContent a => XMLParser a
parseContents
        } Parser (Content Posn) Lemma -> ShowS -> Parser (Content Posn) Lemma
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <Lemma>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)
instance XmlAttributes Lemma_Attrs where
    fromAttrs :: [Attribute] -> Lemma_Attrs
fromAttrs as :: [Attribute]
as =
        Lemma_Attrs :: Maybe String -> Lemma_Attrs
Lemma_Attrs
          { lemmaTarget :: Maybe String
lemmaTarget = (String -> Attribute -> Maybe String)
-> String -> [Attribute] -> Maybe String
forall a.
(String -> Attribute -> Maybe a)
-> String -> [Attribute] -> Maybe a
possibleA String -> Attribute -> Maybe String
fromAttrToStr "target" [Attribute]
as
          }
    toAttrs :: Lemma_Attrs -> [Attribute]
toAttrs v :: Lemma_Attrs
v = [Maybe Attribute] -> [Attribute]
forall a. [Maybe a] -> [a]
catMaybes 
        [ (String -> String -> Maybe Attribute)
-> String -> Maybe String -> Maybe Attribute
forall a.
(String -> a -> Maybe Attribute)
-> String -> Maybe a -> Maybe Attribute
maybeToAttr String -> String -> Maybe Attribute
toAttrFrStr "target" (Lemma_Attrs -> Maybe String
lemmaTarget Lemma_Attrs
v)
        ]

instance HTypeable Definition where
    toHType :: Definition -> HType
toHType _ = String -> [HType] -> [Constr] -> HType
Defined "Definition" [] []
instance XmlContent Definition where
    toContents :: Definition -> [Content ()]
toContents (Definition as :: Definition_Attrs
as a :: Maybe Mixfix
a b :: OneOf3 TVar TFree Type
b c :: List1 (OneOf6 Bound Free Var Const App Abs)
c) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N "Definition") (Definition_Attrs -> [Attribute]
forall a. XmlAttributes a => a -> [Attribute]
toAttrs Definition_Attrs
as) ([Content ()]
-> (Mixfix -> [Content ()]) -> Maybe Mixfix -> [Content ()]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] Mixfix -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents Maybe Mixfix
a
                                                    [Content ()] -> [Content ()] -> [Content ()]
forall a. [a] -> [a] -> [a]
++ OneOf3 TVar TFree Type -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents OneOf3 TVar TFree Type
b [Content ()] -> [Content ()] -> [Content ()]
forall a. [a] -> [a] -> [a]
++ List1 (OneOf6 Bound Free Var Const App Abs) -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents List1 (OneOf6 Bound Free Var Const App Abs)
c)) ()]
    parseContents :: Parser (Content Posn) Definition
parseContents = do
        { e :: Element Posn
e@(Elem _ as :: [Attribute]
as _) <- [String] -> XMLParser (Element Posn)
element ["Definition"]
        ; Element Posn
-> Parser (Content Posn) Definition
-> Parser (Content Posn) Definition
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (Parser (Content Posn) Definition
 -> Parser (Content Posn) Definition)
-> Parser (Content Posn) Definition
-> Parser (Content Posn) Definition
forall a b. (a -> b) -> a -> b
$ (Maybe Mixfix
 -> OneOf3 TVar TFree Type
 -> List1 (OneOf6 Bound Free Var Const App Abs)
 -> Definition)
-> Parser
     (Content Posn)
     (Maybe Mixfix
      -> OneOf3 TVar TFree Type
      -> List1 (OneOf6 Bound Free Var Const App Abs)
      -> Definition)
forall (m :: * -> *) a. Monad m => a -> m a
return (Definition_Attrs
-> Maybe Mixfix
-> OneOf3 TVar TFree Type
-> List1 (OneOf6 Bound Free Var Const App Abs)
-> Definition
Definition ([Attribute] -> Definition_Attrs
forall a. XmlAttributes a => [Attribute] -> a
fromAttrs [Attribute]
as))
                       Parser
  (Content Posn)
  (Maybe Mixfix
   -> OneOf3 TVar TFree Type
   -> List1 (OneOf6 Bound Free Var Const App Abs)
   -> Definition)
-> Parser (Content Posn) (Maybe Mixfix)
-> Parser
     (Content Posn)
     (OneOf3 TVar TFree Type
      -> List1 (OneOf6 Bound Free Var Const App Abs) -> Definition)
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) Mixfix
-> Parser (Content Posn) (Maybe Mixfix)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser (Content Posn) Mixfix
forall a. XmlContent a => XMLParser a
parseContents Parser
  (Content Posn)
  (OneOf3 TVar TFree Type
   -> List1 (OneOf6 Bound Free Var Const App Abs) -> Definition)
-> Parser (Content Posn) (OneOf3 TVar TFree Type)
-> Parser
     (Content Posn)
     (List1 (OneOf6 Bound Free Var Const App Abs) -> Definition)
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) (OneOf3 TVar TFree Type)
forall a. XmlContent a => XMLParser a
parseContents
                       Parser
  (Content Posn)
  (List1 (OneOf6 Bound Free Var Const App Abs) -> Definition)
-> Parser
     (Content Posn) (List1 (OneOf6 Bound Free Var Const App Abs))
-> Parser (Content Posn) Definition
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) (List1 (OneOf6 Bound Free Var Const App Abs))
forall a. XmlContent a => XMLParser a
parseContents
        } Parser (Content Posn) Definition
-> ShowS -> Parser (Content Posn) Definition
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <Definition>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)
instance XmlAttributes Definition_Attrs where
    fromAttrs :: [Attribute] -> Definition_Attrs
fromAttrs as :: [Attribute]
as =
        Definition_Attrs :: String -> Maybe String -> Definition_Attrs
Definition_Attrs
          { definitionName :: String
definitionName = (String -> Attribute -> Maybe String)
-> String -> String -> [Attribute] -> String
forall a.
(String -> Attribute -> Maybe a)
-> String -> String -> [Attribute] -> a
definiteA String -> Attribute -> Maybe String
fromAttrToStr "Definition" "name" [Attribute]
as
          , definitionTarget :: Maybe String
definitionTarget = (String -> Attribute -> Maybe String)
-> String -> [Attribute] -> Maybe String
forall a.
(String -> Attribute -> Maybe a)
-> String -> [Attribute] -> Maybe a
possibleA String -> Attribute -> Maybe String
fromAttrToStr "target" [Attribute]
as
          }
    toAttrs :: Definition_Attrs -> [Attribute]
toAttrs v :: Definition_Attrs
v = [Maybe Attribute] -> [Attribute]
forall a. [Maybe a] -> [a]
catMaybes 
        [ String -> String -> Maybe Attribute
toAttrFrStr "name" (Definition_Attrs -> String
definitionName Definition_Attrs
v)
        , (String -> String -> Maybe Attribute)
-> String -> Maybe String -> Maybe Attribute
forall a.
(String -> a -> Maybe Attribute)
-> String -> Maybe a -> Maybe Attribute
maybeToAttr String -> String -> Maybe Attribute
toAttrFrStr "target" (Definition_Attrs -> Maybe String
definitionTarget Definition_Attrs
v)
        ]

instance HTypeable Funs where
    toHType :: Funs -> HType
toHType _ = String -> [HType] -> [Constr] -> HType
Defined "Funs" [] []
instance XmlContent Funs where
    toContents :: Funs -> [Content ()]
toContents (Funs as :: Funs_Attrs
as a :: List1 Fun
a) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N "Funs") (Funs_Attrs -> [Attribute]
forall a. XmlAttributes a => a -> [Attribute]
toAttrs Funs_Attrs
as) (List1 Fun -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents List1 Fun
a)) ()]
    parseContents :: Parser (Content Posn) Funs
parseContents = do
        { e :: Element Posn
e@(Elem _ as :: [Attribute]
as _) <- [String] -> XMLParser (Element Posn)
element ["Funs"]
        ; Element Posn
-> Parser (Content Posn) Funs -> Parser (Content Posn) Funs
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (Parser (Content Posn) Funs -> Parser (Content Posn) Funs)
-> Parser (Content Posn) Funs -> Parser (Content Posn) Funs
forall a b. (a -> b) -> a -> b
$ (List1 Fun -> Funs) -> Parser (Content Posn) (List1 Fun -> Funs)
forall (m :: * -> *) a. Monad m => a -> m a
return (Funs_Attrs -> List1 Fun -> Funs
Funs ([Attribute] -> Funs_Attrs
forall a. XmlAttributes a => [Attribute] -> a
fromAttrs [Attribute]
as)) Parser (Content Posn) (List1 Fun -> Funs)
-> Parser (Content Posn) (List1 Fun) -> Parser (Content Posn) Funs
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) (List1 Fun)
forall a. XmlContent a => XMLParser a
parseContents
        } Parser (Content Posn) Funs -> ShowS -> Parser (Content Posn) Funs
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <Funs>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)
instance XmlAttributes Funs_Attrs where
    fromAttrs :: [Attribute] -> Funs_Attrs
fromAttrs as :: [Attribute]
as =
        Funs_Attrs :: Maybe String
-> Maybe String
-> Maybe String
-> Maybe String
-> Maybe String
-> Funs_Attrs
Funs_Attrs
          { funsTarget :: Maybe String
funsTarget = (String -> Attribute -> Maybe String)
-> String -> [Attribute] -> Maybe String
forall a.
(String -> Attribute -> Maybe a)
-> String -> [Attribute] -> Maybe a
possibleA String -> Attribute -> Maybe String
fromAttrToStr "target" [Attribute]
as
          , funsSequential :: Maybe String
funsSequential = (String -> Attribute -> Maybe String)
-> String -> [Attribute] -> Maybe String
forall a.
(String -> Attribute -> Maybe a)
-> String -> [Attribute] -> Maybe a
possibleA String -> Attribute -> Maybe String
fromAttrToStr "sequential" [Attribute]
as
          , funsDefault :: Maybe String
funsDefault = (String -> Attribute -> Maybe String)
-> String -> [Attribute] -> Maybe String
forall a.
(String -> Attribute -> Maybe a)
-> String -> [Attribute] -> Maybe a
possibleA String -> Attribute -> Maybe String
fromAttrToStr "default" [Attribute]
as
          , funsDomintros :: Maybe String
funsDomintros = (String -> Attribute -> Maybe String)
-> String -> [Attribute] -> Maybe String
forall a.
(String -> Attribute -> Maybe a)
-> String -> [Attribute] -> Maybe a
possibleA String -> Attribute -> Maybe String
fromAttrToStr "domintros" [Attribute]
as
          , funsPartials :: Maybe String
funsPartials = (String -> Attribute -> Maybe String)
-> String -> [Attribute] -> Maybe String
forall a.
(String -> Attribute -> Maybe a)
-> String -> [Attribute] -> Maybe a
possibleA String -> Attribute -> Maybe String
fromAttrToStr "partials" [Attribute]
as
          }
    toAttrs :: Funs_Attrs -> [Attribute]
toAttrs v :: Funs_Attrs
v = [Maybe Attribute] -> [Attribute]
forall a. [Maybe a] -> [a]
catMaybes 
        [ (String -> String -> Maybe Attribute)
-> String -> Maybe String -> Maybe Attribute
forall a.
(String -> a -> Maybe Attribute)
-> String -> Maybe a -> Maybe Attribute
maybeToAttr String -> String -> Maybe Attribute
toAttrFrStr "target" (Funs_Attrs -> Maybe String
funsTarget Funs_Attrs
v)
        , (String -> String -> Maybe Attribute)
-> String -> Maybe String -> Maybe Attribute
forall a.
(String -> a -> Maybe Attribute)
-> String -> Maybe a -> Maybe Attribute
maybeToAttr String -> String -> Maybe Attribute
toAttrFrStr "sequential" (Funs_Attrs -> Maybe String
funsSequential Funs_Attrs
v)
        , (String -> String -> Maybe Attribute)
-> String -> Maybe String -> Maybe Attribute
forall a.
(String -> a -> Maybe Attribute)
-> String -> Maybe a -> Maybe Attribute
maybeToAttr String -> String -> Maybe Attribute
toAttrFrStr "default" (Funs_Attrs -> Maybe String
funsDefault Funs_Attrs
v)
        , (String -> String -> Maybe Attribute)
-> String -> Maybe String -> Maybe Attribute
forall a.
(String -> a -> Maybe Attribute)
-> String -> Maybe a -> Maybe Attribute
maybeToAttr String -> String -> Maybe Attribute
toAttrFrStr "domintros" (Funs_Attrs -> Maybe String
funsDomintros Funs_Attrs
v)
        , (String -> String -> Maybe Attribute)
-> String -> Maybe String -> Maybe Attribute
forall a.
(String -> a -> Maybe Attribute)
-> String -> Maybe a -> Maybe Attribute
maybeToAttr String -> String -> Maybe Attribute
toAttrFrStr "partials" (Funs_Attrs -> Maybe String
funsPartials Funs_Attrs
v)
        ]

instance HTypeable Fun where
    toHType :: Fun -> HType
toHType _ = String -> [HType] -> [Constr] -> HType
Defined "Fun" [] []
instance XmlContent Fun where
    toContents :: Fun -> [Content ()]
toContents (Fun as :: Fun_Attrs
as a :: Maybe Mixfix
a b :: OneOf3 TVar TFree Type
b c :: List1 Equation
c) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N "Fun") (Fun_Attrs -> [Attribute]
forall a. XmlAttributes a => a -> [Attribute]
toAttrs Fun_Attrs
as) ([Content ()]
-> (Mixfix -> [Content ()]) -> Maybe Mixfix -> [Content ()]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] Mixfix -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents Maybe Mixfix
a [Content ()] -> [Content ()] -> [Content ()]
forall a. [a] -> [a] -> [a]
++
                                             OneOf3 TVar TFree Type -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents OneOf3 TVar TFree Type
b [Content ()] -> [Content ()] -> [Content ()]
forall a. [a] -> [a] -> [a]
++ List1 Equation -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents List1 Equation
c)) ()]
    parseContents :: XMLParser Fun
parseContents = do
        { e :: Element Posn
e@(Elem _ as :: [Attribute]
as _) <- [String] -> XMLParser (Element Posn)
element ["Fun"]
        ; Element Posn -> XMLParser Fun -> XMLParser Fun
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (XMLParser Fun -> XMLParser Fun) -> XMLParser Fun -> XMLParser Fun
forall a b. (a -> b) -> a -> b
$ (Maybe Mixfix -> OneOf3 TVar TFree Type -> List1 Equation -> Fun)
-> Parser
     (Content Posn)
     (Maybe Mixfix -> OneOf3 TVar TFree Type -> List1 Equation -> Fun)
forall (m :: * -> *) a. Monad m => a -> m a
return (Fun_Attrs
-> Maybe Mixfix -> OneOf3 TVar TFree Type -> List1 Equation -> Fun
Fun ([Attribute] -> Fun_Attrs
forall a. XmlAttributes a => [Attribute] -> a
fromAttrs [Attribute]
as))
                       Parser
  (Content Posn)
  (Maybe Mixfix -> OneOf3 TVar TFree Type -> List1 Equation -> Fun)
-> Parser (Content Posn) (Maybe Mixfix)
-> Parser
     (Content Posn) (OneOf3 TVar TFree Type -> List1 Equation -> Fun)
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) Mixfix
-> Parser (Content Posn) (Maybe Mixfix)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser (Content Posn) Mixfix
forall a. XmlContent a => XMLParser a
parseContents Parser
  (Content Posn) (OneOf3 TVar TFree Type -> List1 Equation -> Fun)
-> Parser (Content Posn) (OneOf3 TVar TFree Type)
-> Parser (Content Posn) (List1 Equation -> Fun)
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) (OneOf3 TVar TFree Type)
forall a. XmlContent a => XMLParser a
parseContents
                       Parser (Content Posn) (List1 Equation -> Fun)
-> Parser (Content Posn) (List1 Equation) -> XMLParser Fun
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) (List1 Equation)
forall a. XmlContent a => XMLParser a
parseContents
        } XMLParser Fun -> ShowS -> XMLParser Fun
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <Fun>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)
instance XmlAttributes Fun_Attrs where
    fromAttrs :: [Attribute] -> Fun_Attrs
fromAttrs as :: [Attribute]
as =
        Fun_Attrs :: String -> Fun_Attrs
Fun_Attrs
          { funName :: String
funName = (String -> Attribute -> Maybe String)
-> String -> String -> [Attribute] -> String
forall a.
(String -> Attribute -> Maybe a)
-> String -> String -> [Attribute] -> a
definiteA String -> Attribute -> Maybe String
fromAttrToStr "Fun" "name" [Attribute]
as
          }
    toAttrs :: Fun_Attrs -> [Attribute]
toAttrs v :: Fun_Attrs
v = [Maybe Attribute] -> [Attribute]
forall a. [Maybe a] -> [a]
catMaybes 
        [ String -> String -> Maybe Attribute
toAttrFrStr "name" (Fun_Attrs -> String
funName Fun_Attrs
v)
        ]

instance HTypeable Equation where
    toHType :: Equation -> HType
toHType _ = String -> [HType] -> [Constr] -> HType
Defined "Equation" [] []
instance XmlContent Equation where
    toContents :: Equation -> [Content ()]
toContents (Equation a :: List1 (OneOf6 Bound Free Var Const App Abs)
a) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N "Equation") [] (List1 (OneOf6 Bound Free Var Const App Abs) -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents List1 (OneOf6 Bound Free Var Const App Abs)
a)) ()]
    parseContents :: XMLParser Equation
parseContents = do
        { e :: Element Posn
e@(Elem _ [] _) <- [String] -> XMLParser (Element Posn)
element ["Equation"]
        ; Element Posn -> XMLParser Equation -> XMLParser Equation
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (XMLParser Equation -> XMLParser Equation)
-> XMLParser Equation -> XMLParser Equation
forall a b. (a -> b) -> a -> b
$ (List1 (OneOf6 Bound Free Var Const App Abs) -> Equation)
-> Parser
     (Content Posn)
     (List1 (OneOf6 Bound Free Var Const App Abs) -> Equation)
forall (m :: * -> *) a. Monad m => a -> m a
return (List1 (OneOf6 Bound Free Var Const App Abs) -> Equation
Equation) Parser
  (Content Posn)
  (List1 (OneOf6 Bound Free Var Const App Abs) -> Equation)
-> Parser
     (Content Posn) (List1 (OneOf6 Bound Free Var Const App Abs))
-> XMLParser Equation
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) (List1 (OneOf6 Bound Free Var Const App Abs))
forall a. XmlContent a => XMLParser a
parseContents
        } XMLParser Equation -> ShowS -> XMLParser Equation
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <Equation>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)

instance HTypeable Primrec where
    toHType :: Primrec -> HType
toHType _ = String -> [HType] -> [Constr] -> HType
Defined "Primrec" [] []
instance XmlContent Primrec where
    toContents :: Primrec -> [Content ()]
toContents (Primrec as :: Primrec_Attrs
as a :: List1 Fun
a) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N "Primrec") (Primrec_Attrs -> [Attribute]
forall a. XmlAttributes a => a -> [Attribute]
toAttrs Primrec_Attrs
as) (List1 Fun -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents List1 Fun
a)) ()]
    parseContents :: Parser (Content Posn) Primrec
parseContents = do
        { e :: Element Posn
e@(Elem _ as :: [Attribute]
as _) <- [String] -> XMLParser (Element Posn)
element ["Primrec"]
        ; Element Posn
-> Parser (Content Posn) Primrec -> Parser (Content Posn) Primrec
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (Parser (Content Posn) Primrec -> Parser (Content Posn) Primrec)
-> Parser (Content Posn) Primrec -> Parser (Content Posn) Primrec
forall a b. (a -> b) -> a -> b
$ (List1 Fun -> Primrec)
-> Parser (Content Posn) (List1 Fun -> Primrec)
forall (m :: * -> *) a. Monad m => a -> m a
return (Primrec_Attrs -> List1 Fun -> Primrec
Primrec ([Attribute] -> Primrec_Attrs
forall a. XmlAttributes a => [Attribute] -> a
fromAttrs [Attribute]
as))
                       Parser (Content Posn) (List1 Fun -> Primrec)
-> Parser (Content Posn) (List1 Fun)
-> Parser (Content Posn) Primrec
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) (List1 Fun)
forall a. XmlContent a => XMLParser a
parseContents
        } Parser (Content Posn) Primrec
-> ShowS -> Parser (Content Posn) Primrec
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <Primrec>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)
instance XmlAttributes Primrec_Attrs where
    fromAttrs :: [Attribute] -> Primrec_Attrs
fromAttrs as :: [Attribute]
as =
        Primrec_Attrs :: Maybe String -> Primrec_Attrs
Primrec_Attrs
          { primrecTarget :: Maybe String
primrecTarget = (String -> Attribute -> Maybe String)
-> String -> [Attribute] -> Maybe String
forall a.
(String -> Attribute -> Maybe a)
-> String -> [Attribute] -> Maybe a
possibleA String -> Attribute -> Maybe String
fromAttrToStr "target" [Attribute]
as
          }
    toAttrs :: Primrec_Attrs -> [Attribute]
toAttrs v :: Primrec_Attrs
v = [Maybe Attribute] -> [Attribute]
forall a. [Maybe a] -> [a]
catMaybes 
        [ (String -> String -> Maybe Attribute)
-> String -> Maybe String -> Maybe Attribute
forall a.
(String -> a -> Maybe Attribute)
-> String -> Maybe a -> Maybe Attribute
maybeToAttr String -> String -> Maybe Attribute
toAttrFrStr "target" (Primrec_Attrs -> Maybe String
primrecTarget Primrec_Attrs
v)
        ]

instance HTypeable Fixrec where
    toHType :: Fixrec -> HType
toHType _ = String -> [HType] -> [Constr] -> HType
Defined "Fixrec" [] []
instance XmlContent Fixrec where
    toContents :: Fixrec -> [Content ()]
toContents (Fixrec a :: List1 FixrecFun
a) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N "Fixrec") [] (List1 FixrecFun -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents List1 FixrecFun
a)) ()]
    parseContents :: Parser (Content Posn) Fixrec
parseContents = do
        { e :: Element Posn
e@(Elem _ [] _) <- [String] -> XMLParser (Element Posn)
element ["Fixrec"]
        ; Element Posn
-> Parser (Content Posn) Fixrec -> Parser (Content Posn) Fixrec
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (Parser (Content Posn) Fixrec -> Parser (Content Posn) Fixrec)
-> Parser (Content Posn) Fixrec -> Parser (Content Posn) Fixrec
forall a b. (a -> b) -> a -> b
$ (List1 FixrecFun -> Fixrec)
-> Parser (Content Posn) (List1 FixrecFun -> Fixrec)
forall (m :: * -> *) a. Monad m => a -> m a
return (List1 FixrecFun -> Fixrec
Fixrec) Parser (Content Posn) (List1 FixrecFun -> Fixrec)
-> Parser (Content Posn) (List1 FixrecFun)
-> Parser (Content Posn) Fixrec
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) (List1 FixrecFun)
forall a. XmlContent a => XMLParser a
parseContents
        } Parser (Content Posn) Fixrec
-> ShowS -> Parser (Content Posn) Fixrec
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <Fixrec>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)

instance HTypeable FixrecFun where
    toHType :: FixrecFun -> HType
toHType _ = String -> [HType] -> [Constr] -> HType
Defined "FixrecFun" [] []
instance XmlContent FixrecFun where
    toContents :: FixrecFun -> [Content ()]
toContents (FixrecFun as :: FixrecFun_Attrs
as a :: Maybe Mixfix
a b :: OneOf3 TVar TFree Type
b c :: List1 FixrecEquation
c) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N "FixrecFun") (FixrecFun_Attrs -> [Attribute]
forall a. XmlAttributes a => a -> [Attribute]
toAttrs FixrecFun_Attrs
as) ([Content ()]
-> (Mixfix -> [Content ()]) -> Maybe Mixfix -> [Content ()]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] Mixfix -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents Maybe Mixfix
a [Content ()] -> [Content ()] -> [Content ()]
forall a. [a] -> [a] -> [a]
++
                                                   OneOf3 TVar TFree Type -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents OneOf3 TVar TFree Type
b [Content ()] -> [Content ()] -> [Content ()]
forall a. [a] -> [a] -> [a]
++ List1 FixrecEquation -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents List1 FixrecEquation
c)) ()]
    parseContents :: XMLParser FixrecFun
parseContents = do
        { e :: Element Posn
e@(Elem _ as :: [Attribute]
as _) <- [String] -> XMLParser (Element Posn)
element ["FixrecFun"]
        ; Element Posn -> XMLParser FixrecFun -> XMLParser FixrecFun
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (XMLParser FixrecFun -> XMLParser FixrecFun)
-> XMLParser FixrecFun -> XMLParser FixrecFun
forall a b. (a -> b) -> a -> b
$ (Maybe Mixfix
 -> OneOf3 TVar TFree Type -> List1 FixrecEquation -> FixrecFun)
-> Parser
     (Content Posn)
     (Maybe Mixfix
      -> OneOf3 TVar TFree Type -> List1 FixrecEquation -> FixrecFun)
forall (m :: * -> *) a. Monad m => a -> m a
return (FixrecFun_Attrs
-> Maybe Mixfix
-> OneOf3 TVar TFree Type
-> List1 FixrecEquation
-> FixrecFun
FixrecFun ([Attribute] -> FixrecFun_Attrs
forall a. XmlAttributes a => [Attribute] -> a
fromAttrs [Attribute]
as))
                       Parser
  (Content Posn)
  (Maybe Mixfix
   -> OneOf3 TVar TFree Type -> List1 FixrecEquation -> FixrecFun)
-> Parser (Content Posn) (Maybe Mixfix)
-> Parser
     (Content Posn)
     (OneOf3 TVar TFree Type -> List1 FixrecEquation -> FixrecFun)
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) Mixfix
-> Parser (Content Posn) (Maybe Mixfix)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser (Content Posn) Mixfix
forall a. XmlContent a => XMLParser a
parseContents Parser
  (Content Posn)
  (OneOf3 TVar TFree Type -> List1 FixrecEquation -> FixrecFun)
-> Parser (Content Posn) (OneOf3 TVar TFree Type)
-> Parser (Content Posn) (List1 FixrecEquation -> FixrecFun)
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) (OneOf3 TVar TFree Type)
forall a. XmlContent a => XMLParser a
parseContents
                       Parser (Content Posn) (List1 FixrecEquation -> FixrecFun)
-> Parser (Content Posn) (List1 FixrecEquation)
-> XMLParser FixrecFun
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) (List1 FixrecEquation)
forall a. XmlContent a => XMLParser a
parseContents
        } XMLParser FixrecFun -> ShowS -> XMLParser FixrecFun
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <FixrecFun>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)
instance XmlAttributes FixrecFun_Attrs where
    fromAttrs :: [Attribute] -> FixrecFun_Attrs
fromAttrs as :: [Attribute]
as =
        FixrecFun_Attrs :: String -> FixrecFun_Attrs
FixrecFun_Attrs
          { fixrecFunName :: String
fixrecFunName = (String -> Attribute -> Maybe String)
-> String -> String -> [Attribute] -> String
forall a.
(String -> Attribute -> Maybe a)
-> String -> String -> [Attribute] -> a
definiteA String -> Attribute -> Maybe String
fromAttrToStr "FixrecFun" "name" [Attribute]
as
          }
    toAttrs :: FixrecFun_Attrs -> [Attribute]
toAttrs v :: FixrecFun_Attrs
v = [Maybe Attribute] -> [Attribute]
forall a. [Maybe a] -> [a]
catMaybes 
        [ String -> String -> Maybe Attribute
toAttrFrStr "name" (FixrecFun_Attrs -> String
fixrecFunName FixrecFun_Attrs
v)
        ]

instance HTypeable FixrecEquation where
    toHType :: FixrecEquation -> HType
toHType _ = String -> [HType] -> [Constr] -> HType
Defined "FixrecEquation" [] []
instance XmlContent FixrecEquation where
    toContents :: FixrecEquation -> [Content ()]
toContents (FixrecEquation as :: FixrecEquation_Attrs
as a :: Premises
a b :: List1 (OneOf6 Bound Free Var Const App Abs)
b) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N "FixrecEquation") (FixrecEquation_Attrs -> [Attribute]
forall a. XmlAttributes a => a -> [Attribute]
toAttrs FixrecEquation_Attrs
as) (Premises -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents Premises
a [Content ()] -> [Content ()] -> [Content ()]
forall a. [a] -> [a] -> [a]
++
                                                        List1 (OneOf6 Bound Free Var Const App Abs) -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents List1 (OneOf6 Bound Free Var Const App Abs)
b)) ()]
    parseContents :: XMLParser FixrecEquation
parseContents = do
        { e :: Element Posn
e@(Elem _ as :: [Attribute]
as _) <- [String] -> XMLParser (Element Posn)
element ["FixrecEquation"]
        ; Element Posn
-> XMLParser FixrecEquation -> XMLParser FixrecEquation
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (XMLParser FixrecEquation -> XMLParser FixrecEquation)
-> XMLParser FixrecEquation -> XMLParser FixrecEquation
forall a b. (a -> b) -> a -> b
$ (Premises
 -> List1 (OneOf6 Bound Free Var Const App Abs) -> FixrecEquation)
-> Parser
     (Content Posn)
     (Premises
      -> List1 (OneOf6 Bound Free Var Const App Abs) -> FixrecEquation)
forall (m :: * -> *) a. Monad m => a -> m a
return (FixrecEquation_Attrs
-> Premises
-> List1 (OneOf6 Bound Free Var Const App Abs)
-> FixrecEquation
FixrecEquation ([Attribute] -> FixrecEquation_Attrs
forall a. XmlAttributes a => [Attribute] -> a
fromAttrs [Attribute]
as))
                       Parser
  (Content Posn)
  (Premises
   -> List1 (OneOf6 Bound Free Var Const App Abs) -> FixrecEquation)
-> Parser (Content Posn) Premises
-> Parser
     (Content Posn)
     (List1 (OneOf6 Bound Free Var Const App Abs) -> FixrecEquation)
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) Premises
forall a. XmlContent a => XMLParser a
parseContents Parser
  (Content Posn)
  (List1 (OneOf6 Bound Free Var Const App Abs) -> FixrecEquation)
-> Parser
     (Content Posn) (List1 (OneOf6 Bound Free Var Const App Abs))
-> XMLParser FixrecEquation
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) (List1 (OneOf6 Bound Free Var Const App Abs))
forall a. XmlContent a => XMLParser a
parseContents
        } XMLParser FixrecEquation -> ShowS -> XMLParser FixrecEquation
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <FixrecEquation>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)
instance XmlAttributes FixrecEquation_Attrs where
    fromAttrs :: [Attribute] -> FixrecEquation_Attrs
fromAttrs as :: [Attribute]
as =
        FixrecEquation_Attrs :: Maybe String -> FixrecEquation_Attrs
FixrecEquation_Attrs
          { fixrecEquationUnchecked :: Maybe String
fixrecEquationUnchecked = (String -> Attribute -> Maybe String)
-> String -> [Attribute] -> Maybe String
forall a.
(String -> Attribute -> Maybe a)
-> String -> [Attribute] -> Maybe a
possibleA String -> Attribute -> Maybe String
fromAttrToStr "unchecked" [Attribute]
as
          }
    toAttrs :: FixrecEquation_Attrs -> [Attribute]
toAttrs v :: FixrecEquation_Attrs
v = [Maybe Attribute] -> [Attribute]
forall a. [Maybe a] -> [a]
catMaybes 
        [ (String -> String -> Maybe Attribute)
-> String -> Maybe String -> Maybe Attribute
forall a.
(String -> a -> Maybe Attribute)
-> String -> Maybe a -> Maybe Attribute
maybeToAttr String -> String -> Maybe Attribute
toAttrFrStr "unchecked" (FixrecEquation_Attrs -> Maybe String
fixrecEquationUnchecked FixrecEquation_Attrs
v)
        ]

instance HTypeable Premises where
    toHType :: Premises -> HType
toHType _ = String -> [HType] -> [Constr] -> HType
Defined "Premises" [] []
instance XmlContent Premises where
    toContents :: Premises -> [Content ()]
toContents (Premises a :: [OneOf6 Bound Free Var Const App Abs]
a) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N "Premises") [] ((OneOf6 Bound Free Var Const App Abs -> [Content ()])
-> [OneOf6 Bound Free Var Const App Abs] -> [Content ()]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap OneOf6 Bound Free Var Const App Abs -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents [OneOf6 Bound Free Var Const App Abs]
a)) ()]
    parseContents :: Parser (Content Posn) Premises
parseContents = do
        { e :: Element Posn
e@(Elem _ [] _) <- [String] -> XMLParser (Element Posn)
element ["Premises"]
        ; Element Posn
-> Parser (Content Posn) Premises -> Parser (Content Posn) Premises
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (Parser (Content Posn) Premises -> Parser (Content Posn) Premises)
-> Parser (Content Posn) Premises -> Parser (Content Posn) Premises
forall a b. (a -> b) -> a -> b
$ ([OneOf6 Bound Free Var Const App Abs] -> Premises)
-> Parser
     (Content Posn) ([OneOf6 Bound Free Var Const App Abs] -> Premises)
forall (m :: * -> *) a. Monad m => a -> m a
return ([OneOf6 Bound Free Var Const App Abs] -> Premises
Premises) Parser
  (Content Posn) ([OneOf6 Bound Free Var Const App Abs] -> Premises)
-> Parser (Content Posn) [OneOf6 Bound Free Var Const App Abs]
-> Parser (Content Posn) Premises
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) (OneOf6 Bound Free Var Const App Abs)
-> Parser (Content Posn) [OneOf6 Bound Free Var Const App Abs]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many Parser (Content Posn) (OneOf6 Bound Free Var Const App Abs)
forall a. XmlContent a => XMLParser a
parseContents
        } Parser (Content Posn) Premises
-> ShowS -> Parser (Content Posn) Premises
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <Premises>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)

instance HTypeable Instantiation where
    toHType :: Instantiation -> HType
toHType _ = String -> [HType] -> [Constr] -> HType
Defined "Instantiation" [] []
instance XmlContent Instantiation where
    toContents :: Instantiation -> [Content ()]
toContents (Instantiation as :: Instantiation_Attrs
as a :: Arity
a b :: Body
b) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N "Instantiation") (Instantiation_Attrs -> [Attribute]
forall a. XmlAttributes a => a -> [Attribute]
toAttrs Instantiation_Attrs
as) (Arity -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents Arity
a [Content ()] -> [Content ()] -> [Content ()]
forall a. [a] -> [a] -> [a]
++
                                                       Body -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents Body
b)) ()]
    parseContents :: Parser (Content Posn) Instantiation
parseContents = do
        { e :: Element Posn
e@(Elem _ as :: [Attribute]
as _) <- [String] -> XMLParser (Element Posn)
element ["Instantiation"]
        ; Element Posn
-> Parser (Content Posn) Instantiation
-> Parser (Content Posn) Instantiation
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (Parser (Content Posn) Instantiation
 -> Parser (Content Posn) Instantiation)
-> Parser (Content Posn) Instantiation
-> Parser (Content Posn) Instantiation
forall a b. (a -> b) -> a -> b
$ (Arity -> Body -> Instantiation)
-> Parser (Content Posn) (Arity -> Body -> Instantiation)
forall (m :: * -> *) a. Monad m => a -> m a
return (Instantiation_Attrs -> Arity -> Body -> Instantiation
Instantiation ([Attribute] -> Instantiation_Attrs
forall a. XmlAttributes a => [Attribute] -> a
fromAttrs [Attribute]
as))
                       Parser (Content Posn) (Arity -> Body -> Instantiation)
-> Parser (Content Posn) Arity
-> Parser (Content Posn) (Body -> Instantiation)
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) Arity
forall a. XmlContent a => XMLParser a
parseContents Parser (Content Posn) (Body -> Instantiation)
-> Parser (Content Posn) Body
-> Parser (Content Posn) Instantiation
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) Body
forall a. XmlContent a => XMLParser a
parseContents
        } Parser (Content Posn) Instantiation
-> ShowS -> Parser (Content Posn) Instantiation
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <Instantiation>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)
instance XmlAttributes Instantiation_Attrs where
    fromAttrs :: [Attribute] -> Instantiation_Attrs
fromAttrs as :: [Attribute]
as =
        Instantiation_Attrs :: String -> Instantiation_Attrs
Instantiation_Attrs
          { instantiationType :: String
instantiationType = (String -> Attribute -> Maybe String)
-> String -> String -> [Attribute] -> String
forall a.
(String -> Attribute -> Maybe a)
-> String -> String -> [Attribute] -> a
definiteA String -> Attribute -> Maybe String
fromAttrToStr "Instantiation" "type" [Attribute]
as
          }
    toAttrs :: Instantiation_Attrs -> [Attribute]
toAttrs v :: Instantiation_Attrs
v = [Maybe Attribute] -> [Attribute]
forall a. [Maybe a] -> [a]
catMaybes 
        [ String -> String -> Maybe Attribute
toAttrFrStr "type" (Instantiation_Attrs -> String
instantiationType Instantiation_Attrs
v)
        ]

instance HTypeable Instance where
    toHType :: Instance -> HType
toHType _ = String -> [HType] -> [Constr] -> HType
Defined "Instance" [] []
instance XmlContent Instance where
    toContents :: Instance -> [Content ()]
toContents (Instance as :: Instance_Attrs
as a :: Proof
a b :: Maybe (Vars, Arity)
b) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N "Instance") (Instance_Attrs -> [Attribute]
forall a. XmlAttributes a => a -> [Attribute]
toAttrs Instance_Attrs
as) (Proof -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents Proof
a [Content ()] -> [Content ()] -> [Content ()]
forall a. [a] -> [a] -> [a]
++
                                                  [Content ()]
-> ((Vars, Arity) -> [Content ()])
-> Maybe (Vars, Arity)
-> [Content ()]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] (Vars, Arity) -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents Maybe (Vars, Arity)
b)) ()]
    parseContents :: Parser (Content Posn) Instance
parseContents = do
        { e :: Element Posn
e@(Elem _ as :: [Attribute]
as _) <- [String] -> XMLParser (Element Posn)
element ["Instance"]
        ; Element Posn
-> Parser (Content Posn) Instance -> Parser (Content Posn) Instance
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (Parser (Content Posn) Instance -> Parser (Content Posn) Instance)
-> Parser (Content Posn) Instance -> Parser (Content Posn) Instance
forall a b. (a -> b) -> a -> b
$ (Proof -> Maybe (Vars, Arity) -> Instance)
-> Parser (Content Posn) (Proof -> Maybe (Vars, Arity) -> Instance)
forall (m :: * -> *) a. Monad m => a -> m a
return (Instance_Attrs -> Proof -> Maybe (Vars, Arity) -> Instance
Instance ([Attribute] -> Instance_Attrs
forall a. XmlAttributes a => [Attribute] -> a
fromAttrs [Attribute]
as))
                       Parser (Content Posn) (Proof -> Maybe (Vars, Arity) -> Instance)
-> Parser (Content Posn) Proof
-> Parser (Content Posn) (Maybe (Vars, Arity) -> Instance)
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) Proof
forall a. XmlContent a => XMLParser a
parseContents Parser (Content Posn) (Maybe (Vars, Arity) -> Instance)
-> Parser (Content Posn) (Maybe (Vars, Arity))
-> Parser (Content Posn) Instance
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) (Vars, Arity)
-> Parser (Content Posn) (Maybe (Vars, Arity))
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser (Content Posn) (Vars, Arity)
forall a. XmlContent a => XMLParser a
parseContents
        } Parser (Content Posn) Instance
-> ShowS -> Parser (Content Posn) Instance
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <Instance>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)
instance XmlAttributes Instance_Attrs where
    fromAttrs :: [Attribute] -> Instance_Attrs
fromAttrs as :: [Attribute]
as =
        Instance_Attrs :: Maybe String -> Maybe String -> Maybe String -> Instance_Attrs
Instance_Attrs
          { instanceClass :: Maybe String
instanceClass = (String -> Attribute -> Maybe String)
-> String -> [Attribute] -> Maybe String
forall a.
(String -> Attribute -> Maybe a)
-> String -> [Attribute] -> Maybe a
possibleA String -> Attribute -> Maybe String
fromAttrToStr "class" [Attribute]
as
          , instanceRel :: Maybe String
instanceRel = (String -> Attribute -> Maybe String)
-> String -> [Attribute] -> Maybe String
forall a.
(String -> Attribute -> Maybe a)
-> String -> [Attribute] -> Maybe a
possibleA String -> Attribute -> Maybe String
fromAttrToStr "rel" [Attribute]
as
          , instanceClass1 :: Maybe String
instanceClass1 = (String -> Attribute -> Maybe String)
-> String -> [Attribute] -> Maybe String
forall a.
(String -> Attribute -> Maybe a)
-> String -> [Attribute] -> Maybe a
possibleA String -> Attribute -> Maybe String
fromAttrToStr "class1" [Attribute]
as
          }
    toAttrs :: Instance_Attrs -> [Attribute]
toAttrs v :: Instance_Attrs
v = [Maybe Attribute] -> [Attribute]
forall a. [Maybe a] -> [a]
catMaybes 
        [ (String -> String -> Maybe Attribute)
-> String -> Maybe String -> Maybe Attribute
forall a.
(String -> a -> Maybe Attribute)
-> String -> Maybe a -> Maybe Attribute
maybeToAttr String -> String -> Maybe Attribute
toAttrFrStr "class" (Instance_Attrs -> Maybe String
instanceClass Instance_Attrs
v)
        , (String -> String -> Maybe Attribute)
-> String -> Maybe String -> Maybe Attribute
forall a.
(String -> a -> Maybe Attribute)
-> String -> Maybe a -> Maybe Attribute
maybeToAttr String -> String -> Maybe Attribute
toAttrFrStr "rel" (Instance_Attrs -> Maybe String
instanceRel Instance_Attrs
v)
        , (String -> String -> Maybe Attribute)
-> String -> Maybe String -> Maybe Attribute
forall a.
(String -> a -> Maybe Attribute)
-> String -> Maybe a -> Maybe Attribute
maybeToAttr String -> String -> Maybe Attribute
toAttrFrStr "class1" (Instance_Attrs -> Maybe String
instanceClass1 Instance_Attrs
v)
        ]

instance HTypeable Subclass where
    toHType :: Subclass -> HType
toHType _ = String -> [HType] -> [Constr] -> HType
Defined "Subclass" [] []
instance XmlContent Subclass where
    toContents :: Subclass -> [Content ()]
toContents (Subclass as :: Subclass_Attrs
as a :: Proof
a) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N "Subclass") (Subclass_Attrs -> [Attribute]
forall a. XmlAttributes a => a -> [Attribute]
toAttrs Subclass_Attrs
as) (Proof -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents Proof
a)) ()]
    parseContents :: Parser (Content Posn) Subclass
parseContents = do
        { e :: Element Posn
e@(Elem _ as :: [Attribute]
as _) <- [String] -> XMLParser (Element Posn)
element ["Subclass"]
        ; Element Posn
-> Parser (Content Posn) Subclass -> Parser (Content Posn) Subclass
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (Parser (Content Posn) Subclass -> Parser (Content Posn) Subclass)
-> Parser (Content Posn) Subclass -> Parser (Content Posn) Subclass
forall a b. (a -> b) -> a -> b
$ (Proof -> Subclass) -> Parser (Content Posn) (Proof -> Subclass)
forall (m :: * -> *) a. Monad m => a -> m a
return (Subclass_Attrs -> Proof -> Subclass
Subclass ([Attribute] -> Subclass_Attrs
forall a. XmlAttributes a => [Attribute] -> a
fromAttrs [Attribute]
as))
                       Parser (Content Posn) (Proof -> Subclass)
-> Parser (Content Posn) Proof -> Parser (Content Posn) Subclass
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) Proof
forall a. XmlContent a => XMLParser a
parseContents
        } Parser (Content Posn) Subclass
-> ShowS -> Parser (Content Posn) Subclass
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <Subclass>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)
instance XmlAttributes Subclass_Attrs where
    fromAttrs :: [Attribute] -> Subclass_Attrs
fromAttrs as :: [Attribute]
as =
        Subclass_Attrs :: String -> Maybe String -> Subclass_Attrs
Subclass_Attrs
          { subclassClass :: String
subclassClass = (String -> Attribute -> Maybe String)
-> String -> String -> [Attribute] -> String
forall a.
(String -> Attribute -> Maybe a)
-> String -> String -> [Attribute] -> a
definiteA String -> Attribute -> Maybe String
fromAttrToStr "Subclass" "class" [Attribute]
as
          , subclassTarget :: Maybe String
subclassTarget = (String -> Attribute -> Maybe String)
-> String -> [Attribute] -> Maybe String
forall a.
(String -> Attribute -> Maybe a)
-> String -> [Attribute] -> Maybe a
possibleA String -> Attribute -> Maybe String
fromAttrToStr "target" [Attribute]
as
          }
    toAttrs :: Subclass_Attrs -> [Attribute]
toAttrs v :: Subclass_Attrs
v = [Maybe Attribute] -> [Attribute]
forall a. [Maybe a] -> [a]
catMaybes 
        [ String -> String -> Maybe Attribute
toAttrFrStr "class" (Subclass_Attrs -> String
subclassClass Subclass_Attrs
v)
        , (String -> String -> Maybe Attribute)
-> String -> Maybe String -> Maybe Attribute
forall a.
(String -> a -> Maybe Attribute)
-> String -> Maybe a -> Maybe Attribute
maybeToAttr String -> String -> Maybe Attribute
toAttrFrStr "target" (Subclass_Attrs -> Maybe String
subclassTarget Subclass_Attrs
v)
        ]

instance HTypeable Typedef where
    toHType :: Typedef -> HType
toHType _ = String -> [HType] -> [Constr] -> HType
Defined "Typedef" [] []
instance XmlContent Typedef where
    toContents :: Typedef -> [Content ()]
toContents (Typedef as :: Typedef_Attrs
as a :: Maybe Mixfix
a b :: Proof
b c :: OneOf6 Bound Free Var Const App Abs
c d :: [TFree]
d) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N "Typedef") (Typedef_Attrs -> [Attribute]
forall a. XmlAttributes a => a -> [Attribute]
toAttrs Typedef_Attrs
as) ([Content ()]
-> (Mixfix -> [Content ()]) -> Maybe Mixfix -> [Content ()]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] Mixfix -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents Maybe Mixfix
a [Content ()] -> [Content ()] -> [Content ()]
forall a. [a] -> [a] -> [a]
++
                                                 Proof -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents Proof
b [Content ()] -> [Content ()] -> [Content ()]
forall a. [a] -> [a] -> [a]
++ OneOf6 Bound Free Var Const App Abs -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents OneOf6 Bound Free Var Const App Abs
c [Content ()] -> [Content ()] -> [Content ()]
forall a. [a] -> [a] -> [a]
++
                                                 (TFree -> [Content ()]) -> [TFree] -> [Content ()]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap TFree -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents [TFree]
d)) ()]
    parseContents :: Parser (Content Posn) Typedef
parseContents = do
        { e :: Element Posn
e@(Elem _ as :: [Attribute]
as _) <- [String] -> XMLParser (Element Posn)
element ["Typedef"]
        ; Element Posn
-> Parser (Content Posn) Typedef -> Parser (Content Posn) Typedef
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (Parser (Content Posn) Typedef -> Parser (Content Posn) Typedef)
-> Parser (Content Posn) Typedef -> Parser (Content Posn) Typedef
forall a b. (a -> b) -> a -> b
$ (Maybe Mixfix
 -> Proof
 -> OneOf6 Bound Free Var Const App Abs
 -> [TFree]
 -> Typedef)
-> Parser
     (Content Posn)
     (Maybe Mixfix
      -> Proof
      -> OneOf6 Bound Free Var Const App Abs
      -> [TFree]
      -> Typedef)
forall (m :: * -> *) a. Monad m => a -> m a
return (Typedef_Attrs
-> Maybe Mixfix
-> Proof
-> OneOf6 Bound Free Var Const App Abs
-> [TFree]
-> Typedef
Typedef ([Attribute] -> Typedef_Attrs
forall a. XmlAttributes a => [Attribute] -> a
fromAttrs [Attribute]
as))
                       Parser
  (Content Posn)
  (Maybe Mixfix
   -> Proof
   -> OneOf6 Bound Free Var Const App Abs
   -> [TFree]
   -> Typedef)
-> Parser (Content Posn) (Maybe Mixfix)
-> Parser
     (Content Posn)
     (Proof
      -> OneOf6 Bound Free Var Const App Abs -> [TFree] -> Typedef)
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) Mixfix
-> Parser (Content Posn) (Maybe Mixfix)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser (Content Posn) Mixfix
forall a. XmlContent a => XMLParser a
parseContents Parser
  (Content Posn)
  (Proof
   -> OneOf6 Bound Free Var Const App Abs -> [TFree] -> Typedef)
-> Parser (Content Posn) Proof
-> Parser
     (Content Posn)
     (OneOf6 Bound Free Var Const App Abs -> [TFree] -> Typedef)
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) Proof
forall a. XmlContent a => XMLParser a
parseContents
                       Parser
  (Content Posn)
  (OneOf6 Bound Free Var Const App Abs -> [TFree] -> Typedef)
-> Parser (Content Posn) (OneOf6 Bound Free Var Const App Abs)
-> Parser (Content Posn) ([TFree] -> Typedef)
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) (OneOf6 Bound Free Var Const App Abs)
forall a. XmlContent a => XMLParser a
parseContents Parser (Content Posn) ([TFree] -> Typedef)
-> Parser (Content Posn) [TFree] -> Parser (Content Posn) Typedef
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) TFree -> Parser (Content Posn) [TFree]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many Parser (Content Posn) TFree
forall a. XmlContent a => XMLParser a
parseContents
        } Parser (Content Posn) Typedef
-> ShowS -> Parser (Content Posn) Typedef
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <Typedef>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)
instance XmlAttributes Typedef_Attrs where
    fromAttrs :: [Attribute] -> Typedef_Attrs
fromAttrs as :: [Attribute]
as =
        Typedef_Attrs :: String -> Maybe String -> Maybe String -> Typedef_Attrs
Typedef_Attrs
          { typedefType :: String
typedefType = (String -> Attribute -> Maybe String)
-> String -> String -> [Attribute] -> String
forall a.
(String -> Attribute -> Maybe a)
-> String -> String -> [Attribute] -> a
definiteA String -> Attribute -> Maybe String
fromAttrToStr "Typedef" "type" [Attribute]
as
          , typedefM1 :: Maybe String
typedefM1 = (String -> Attribute -> Maybe String)
-> String -> [Attribute] -> Maybe String
forall a.
(String -> Attribute -> Maybe a)
-> String -> [Attribute] -> Maybe a
possibleA String -> Attribute -> Maybe String
fromAttrToStr "m1" [Attribute]
as
          , typedefM2 :: Maybe String
typedefM2 = (String -> Attribute -> Maybe String)
-> String -> [Attribute] -> Maybe String
forall a.
(String -> Attribute -> Maybe a)
-> String -> [Attribute] -> Maybe a
possibleA String -> Attribute -> Maybe String
fromAttrToStr "m2" [Attribute]
as
          }
    toAttrs :: Typedef_Attrs -> [Attribute]
toAttrs v :: Typedef_Attrs
v = [Maybe Attribute] -> [Attribute]
forall a. [Maybe a] -> [a]
catMaybes 
        [ String -> String -> Maybe Attribute
toAttrFrStr "type" (Typedef_Attrs -> String
typedefType Typedef_Attrs
v)
        , (String -> String -> Maybe Attribute)
-> String -> Maybe String -> Maybe Attribute
forall a.
(String -> a -> Maybe Attribute)
-> String -> Maybe a -> Maybe Attribute
maybeToAttr String -> String -> Maybe Attribute
toAttrFrStr "m1" (Typedef_Attrs -> Maybe String
typedefM1 Typedef_Attrs
v)
        , (String -> String -> Maybe Attribute)
-> String -> Maybe String -> Maybe Attribute
forall a.
(String -> a -> Maybe Attribute)
-> String -> Maybe a -> Maybe Attribute
maybeToAttr String -> String -> Maybe Attribute
toAttrFrStr "m2" (Typedef_Attrs -> Maybe String
typedefM2 Typedef_Attrs
v)
        ]

instance HTypeable Defs where
    toHType :: Defs -> HType
toHType _ = String -> [HType] -> [Constr] -> HType
Defined "Defs" [] []
instance XmlContent Defs where
    toContents :: Defs -> [Content ()]
toContents (Defs as :: Defs_Attrs
as a :: List1 Def
a) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N "Defs") (Defs_Attrs -> [Attribute]
forall a. XmlAttributes a => a -> [Attribute]
toAttrs Defs_Attrs
as) (List1 Def -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents List1 Def
a)) ()]
    parseContents :: Parser (Content Posn) Defs
parseContents = do
        { e :: Element Posn
e@(Elem _ as :: [Attribute]
as _) <- [String] -> XMLParser (Element Posn)
element ["Defs"]
        ; Element Posn
-> Parser (Content Posn) Defs -> Parser (Content Posn) Defs
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (Parser (Content Posn) Defs -> Parser (Content Posn) Defs)
-> Parser (Content Posn) Defs -> Parser (Content Posn) Defs
forall a b. (a -> b) -> a -> b
$ (List1 Def -> Defs) -> Parser (Content Posn) (List1 Def -> Defs)
forall (m :: * -> *) a. Monad m => a -> m a
return (Defs_Attrs -> List1 Def -> Defs
Defs ([Attribute] -> Defs_Attrs
forall a. XmlAttributes a => [Attribute] -> a
fromAttrs [Attribute]
as)) Parser (Content Posn) (List1 Def -> Defs)
-> Parser (Content Posn) (List1 Def) -> Parser (Content Posn) Defs
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) (List1 Def)
forall a. XmlContent a => XMLParser a
parseContents
        } Parser (Content Posn) Defs -> ShowS -> Parser (Content Posn) Defs
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <Defs>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)
instance XmlAttributes Defs_Attrs where
    fromAttrs :: [Attribute] -> Defs_Attrs
fromAttrs as :: [Attribute]
as =
        Defs_Attrs :: Maybe String -> Maybe String -> Defs_Attrs
Defs_Attrs
          { defsUnchecked :: Maybe String
defsUnchecked = (String -> Attribute -> Maybe String)
-> String -> [Attribute] -> Maybe String
forall a.
(String -> Attribute -> Maybe a)
-> String -> [Attribute] -> Maybe a
possibleA String -> Attribute -> Maybe String
fromAttrToStr "unchecked" [Attribute]
as
          , defsOverloaded :: Maybe String
defsOverloaded = (String -> Attribute -> Maybe String)
-> String -> [Attribute] -> Maybe String
forall a.
(String -> Attribute -> Maybe a)
-> String -> [Attribute] -> Maybe a
possibleA String -> Attribute -> Maybe String
fromAttrToStr "overloaded" [Attribute]
as
          }
    toAttrs :: Defs_Attrs -> [Attribute]
toAttrs v :: Defs_Attrs
v = [Maybe Attribute] -> [Attribute]
forall a. [Maybe a] -> [a]
catMaybes 
        [ (String -> String -> Maybe Attribute)
-> String -> Maybe String -> Maybe Attribute
forall a.
(String -> a -> Maybe Attribute)
-> String -> Maybe a -> Maybe Attribute
maybeToAttr String -> String -> Maybe Attribute
toAttrFrStr "unchecked" (Defs_Attrs -> Maybe String
defsUnchecked Defs_Attrs
v)
        , (String -> String -> Maybe Attribute)
-> String -> Maybe String -> Maybe Attribute
forall a.
(String -> a -> Maybe Attribute)
-> String -> Maybe a -> Maybe Attribute
maybeToAttr String -> String -> Maybe Attribute
toAttrFrStr "overloaded" (Defs_Attrs -> Maybe String
defsOverloaded Defs_Attrs
v)
        ]

instance HTypeable Def where
    toHType :: Def -> HType
toHType _ = String -> [HType] -> [Constr] -> HType
Defined "Def" [] []
instance XmlContent Def where
    toContents :: Def -> [Content ()]
toContents (Def as :: Def_Attrs
as a :: OneOf3 TVar TFree Type
a b :: OneOf6 Bound Free Var Const App Abs
b) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N "Def") (Def_Attrs -> [Attribute]
forall a. XmlAttributes a => a -> [Attribute]
toAttrs Def_Attrs
as) (OneOf3 TVar TFree Type -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents OneOf3 TVar TFree Type
a [Content ()] -> [Content ()] -> [Content ()]
forall a. [a] -> [a] -> [a]
++
                                             OneOf6 Bound Free Var Const App Abs -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents OneOf6 Bound Free Var Const App Abs
b)) ()]
    parseContents :: XMLParser Def
parseContents = do
        { e :: Element Posn
e@(Elem _ as :: [Attribute]
as _) <- [String] -> XMLParser (Element Posn)
element ["Def"]
        ; Element Posn -> XMLParser Def -> XMLParser Def
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (XMLParser Def -> XMLParser Def) -> XMLParser Def -> XMLParser Def
forall a b. (a -> b) -> a -> b
$ (OneOf3 TVar TFree Type
 -> OneOf6 Bound Free Var Const App Abs -> Def)
-> Parser
     (Content Posn)
     (OneOf3 TVar TFree Type
      -> OneOf6 Bound Free Var Const App Abs -> Def)
forall (m :: * -> *) a. Monad m => a -> m a
return (Def_Attrs
-> OneOf3 TVar TFree Type
-> OneOf6 Bound Free Var Const App Abs
-> Def
Def ([Attribute] -> Def_Attrs
forall a. XmlAttributes a => [Attribute] -> a
fromAttrs [Attribute]
as)) Parser
  (Content Posn)
  (OneOf3 TVar TFree Type
   -> OneOf6 Bound Free Var Const App Abs -> Def)
-> Parser (Content Posn) (OneOf3 TVar TFree Type)
-> Parser
     (Content Posn) (OneOf6 Bound Free Var Const App Abs -> Def)
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) (OneOf3 TVar TFree Type)
forall a. XmlContent a => XMLParser a
parseContents
                       Parser (Content Posn) (OneOf6 Bound Free Var Const App Abs -> Def)
-> Parser (Content Posn) (OneOf6 Bound Free Var Const App Abs)
-> XMLParser Def
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) (OneOf6 Bound Free Var Const App Abs)
forall a. XmlContent a => XMLParser a
parseContents
        } XMLParser Def -> ShowS -> XMLParser Def
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <Def>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)
instance XmlAttributes Def_Attrs where
    fromAttrs :: [Attribute] -> Def_Attrs
fromAttrs as :: [Attribute]
as =
        Def_Attrs :: String -> String -> String -> Def_Attrs
Def_Attrs
          { defName :: String
defName = (String -> Attribute -> Maybe String)
-> String -> String -> [Attribute] -> String
forall a.
(String -> Attribute -> Maybe a)
-> String -> String -> [Attribute] -> a
definiteA String -> Attribute -> Maybe String
fromAttrToStr "Def" "name" [Attribute]
as
          , defArgs :: String
defArgs = (String -> Attribute -> Maybe String)
-> String -> String -> [Attribute] -> String
forall a.
(String -> Attribute -> Maybe a)
-> String -> String -> [Attribute] -> a
definiteA String -> Attribute -> Maybe String
fromAttrToStr "Def" "args" [Attribute]
as
          , defConst :: String
defConst = (String -> Attribute -> Maybe String)
-> String -> String -> [Attribute] -> String
forall a.
(String -> Attribute -> Maybe a)
-> String -> String -> [Attribute] -> a
definiteA String -> Attribute -> Maybe String
fromAttrToStr "Def" "const" [Attribute]
as
          }
    toAttrs :: Def_Attrs -> [Attribute]
toAttrs v :: Def_Attrs
v = [Maybe Attribute] -> [Attribute]
forall a. [Maybe a] -> [a]
catMaybes 
        [ String -> String -> Maybe Attribute
toAttrFrStr "name" (Def_Attrs -> String
defName Def_Attrs
v)
        , String -> String -> Maybe Attribute
toAttrFrStr "args" (Def_Attrs -> String
defArgs Def_Attrs
v)
        , String -> String -> Maybe Attribute
toAttrFrStr "const" (Def_Attrs -> String
defConst Def_Attrs
v)
        ]

instance HTypeable Sort where
    toHType :: Sort -> HType
toHType _ = String -> [HType] -> [Constr] -> HType
Defined "Sort" [] []
instance XmlContent Sort where
    toContents :: Sort -> [Content ()]
toContents (Sort a :: List1 Class
a) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N "Sort") [] (List1 Class -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents List1 Class
a)) ()]
    parseContents :: XMLParser Sort
parseContents = do
        { e :: Element Posn
e@(Elem _ [] _) <- [String] -> XMLParser (Element Posn)
element ["Sort"]
        ; Element Posn -> XMLParser Sort -> XMLParser Sort
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (XMLParser Sort -> XMLParser Sort)
-> XMLParser Sort -> XMLParser Sort
forall a b. (a -> b) -> a -> b
$ (List1 Class -> Sort)
-> Parser (Content Posn) (List1 Class -> Sort)
forall (m :: * -> *) a. Monad m => a -> m a
return (List1 Class -> Sort
Sort) Parser (Content Posn) (List1 Class -> Sort)
-> Parser (Content Posn) (List1 Class) -> XMLParser Sort
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) (List1 Class)
forall a. XmlContent a => XMLParser a
parseContents
        } XMLParser Sort -> ShowS -> XMLParser Sort
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <Sort>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)

instance HTypeable Arity where
    toHType :: Arity -> HType
toHType _ = String -> [HType] -> [Constr] -> HType
Defined "Arity" [] []
instance XmlContent Arity where
    toContents :: Arity -> [Content ()]
toContents (Arity a :: Sort
a b :: [Sort]
b) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N "Arity") [] (Sort -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents Sort
a [Content ()] -> [Content ()] -> [Content ()]
forall a. [a] -> [a] -> [a]
++
                                     (Sort -> [Content ()]) -> [Sort] -> [Content ()]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap Sort -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents [Sort]
b)) ()]
    parseContents :: Parser (Content Posn) Arity
parseContents = do
        { e :: Element Posn
e@(Elem _ [] _) <- [String] -> XMLParser (Element Posn)
element ["Arity"]
        ; Element Posn
-> Parser (Content Posn) Arity -> Parser (Content Posn) Arity
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (Parser (Content Posn) Arity -> Parser (Content Posn) Arity)
-> Parser (Content Posn) Arity -> Parser (Content Posn) Arity
forall a b. (a -> b) -> a -> b
$ (Sort -> [Sort] -> Arity)
-> Parser (Content Posn) (Sort -> [Sort] -> Arity)
forall (m :: * -> *) a. Monad m => a -> m a
return (Sort -> [Sort] -> Arity
Arity) Parser (Content Posn) (Sort -> [Sort] -> Arity)
-> XMLParser Sort -> Parser (Content Posn) ([Sort] -> Arity)
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` XMLParser Sort
forall a. XmlContent a => XMLParser a
parseContents
                       Parser (Content Posn) ([Sort] -> Arity)
-> Parser (Content Posn) [Sort] -> Parser (Content Posn) Arity
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` XMLParser Sort -> Parser (Content Posn) [Sort]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many XMLParser Sort
forall a. XmlContent a => XMLParser a
parseContents
        } Parser (Content Posn) Arity -> ShowS -> Parser (Content Posn) Arity
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <Arity>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)

instance HTypeable Vars where
    toHType :: Vars -> HType
toHType _ = String -> [HType] -> [Constr] -> HType
Defined "Vars" [] []
instance XmlContent Vars where
    toContents :: Vars -> [Content ()]
toContents (Vars a :: [TFree]
a) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N "Vars") [] ((TFree -> [Content ()]) -> [TFree] -> [Content ()]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap TFree -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents [TFree]
a)) ()]
    parseContents :: Parser (Content Posn) Vars
parseContents = do
        { e :: Element Posn
e@(Elem _ [] _) <- [String] -> XMLParser (Element Posn)
element ["Vars"]
        ; Element Posn
-> Parser (Content Posn) Vars -> Parser (Content Posn) Vars
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (Parser (Content Posn) Vars -> Parser (Content Posn) Vars)
-> Parser (Content Posn) Vars -> Parser (Content Posn) Vars
forall a b. (a -> b) -> a -> b
$ ([TFree] -> Vars) -> Parser (Content Posn) ([TFree] -> Vars)
forall (m :: * -> *) a. Monad m => a -> m a
return ([TFree] -> Vars
Vars) Parser (Content Posn) ([TFree] -> Vars)
-> Parser (Content Posn) [TFree] -> Parser (Content Posn) Vars
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) TFree -> Parser (Content Posn) [TFree]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many Parser (Content Posn) TFree
forall a. XmlContent a => XMLParser a
parseContents
        } Parser (Content Posn) Vars -> ShowS -> Parser (Content Posn) Vars
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <Vars>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)

instance HTypeable Parent where
    toHType :: Parent -> HType
toHType _ = String -> [HType] -> [Constr] -> HType
Defined "Parent" [] []
instance XmlContent Parent where
    toContents :: Parent -> [Content ()]
toContents as :: Parent
as =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N "Parent") (Parent -> [Attribute]
forall a. XmlAttributes a => a -> [Attribute]
toAttrs Parent
as) []) ()]
    parseContents :: Parser (Content Posn) Parent
parseContents = do
        { (Elem _ as :: [Attribute]
as []) <- [String] -> XMLParser (Element Posn)
element ["Parent"]
        ; Parent -> Parser (Content Posn) Parent
forall (m :: * -> *) a. Monad m => a -> m a
return ([Attribute] -> Parent
forall a. XmlAttributes a => [Attribute] -> a
fromAttrs [Attribute]
as)
        } Parser (Content Posn) Parent
-> ShowS -> Parser (Content Posn) Parent
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <Parent>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)
instance XmlAttributes Parent where
    fromAttrs :: [Attribute] -> Parent
fromAttrs as :: [Attribute]
as =
        Parent :: String -> Parent
Parent
          { parentName :: String
parentName = (String -> Attribute -> Maybe String)
-> String -> String -> [Attribute] -> String
forall a.
(String -> Attribute -> Maybe a)
-> String -> String -> [Attribute] -> a
definiteA String -> Attribute -> Maybe String
fromAttrToStr "Parent" "name" [Attribute]
as
          }
    toAttrs :: Parent -> [Attribute]
toAttrs v :: Parent
v = [Maybe Attribute] -> [Attribute]
forall a. [Maybe a] -> [a]
catMaybes 
        [ String -> String -> Maybe Attribute
toAttrFrStr "name" (Parent -> String
parentName Parent
v)
        ]

instance HTypeable Fixes where
    toHType :: Fixes -> HType
toHType _ = String -> [HType] -> [Constr] -> HType
Defined "Fixes" [] []
instance XmlContent Fixes where
    toContents :: Fixes -> [Content ()]
toContents (Fixes a :: [Fix]
a) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N "Fixes") [] ((Fix -> [Content ()]) -> [Fix] -> [Content ()]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap Fix -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents [Fix]
a)) ()]
    parseContents :: XMLParser Fixes
parseContents = do
        { e :: Element Posn
e@(Elem _ [] _) <- [String] -> XMLParser (Element Posn)
element ["Fixes"]
        ; Element Posn -> XMLParser Fixes -> XMLParser Fixes
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (XMLParser Fixes -> XMLParser Fixes)
-> XMLParser Fixes -> XMLParser Fixes
forall a b. (a -> b) -> a -> b
$ ([Fix] -> Fixes) -> Parser (Content Posn) ([Fix] -> Fixes)
forall (m :: * -> *) a. Monad m => a -> m a
return ([Fix] -> Fixes
Fixes) Parser (Content Posn) ([Fix] -> Fixes)
-> Parser (Content Posn) [Fix] -> XMLParser Fixes
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) Fix -> Parser (Content Posn) [Fix]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many Parser (Content Posn) Fix
forall a. XmlContent a => XMLParser a
parseContents
        } XMLParser Fixes -> ShowS -> XMLParser Fixes
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <Fixes>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)

instance HTypeable Fix where
    toHType :: Fix -> HType
toHType _ = String -> [HType] -> [Constr] -> HType
Defined "Fix" [] []
instance XmlContent Fix where
    toContents :: Fix -> [Content ()]
toContents (Fix as :: Fix_Attrs
as a :: OneOf3 TVar TFree Type
a b :: Maybe Mixfix
b) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N "Fix") (Fix_Attrs -> [Attribute]
forall a. XmlAttributes a => a -> [Attribute]
toAttrs Fix_Attrs
as) (OneOf3 TVar TFree Type -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents OneOf3 TVar TFree Type
a [Content ()] -> [Content ()] -> [Content ()]
forall a. [a] -> [a] -> [a]
++
                                             [Content ()]
-> (Mixfix -> [Content ()]) -> Maybe Mixfix -> [Content ()]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] Mixfix -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents Maybe Mixfix
b)) ()]
    parseContents :: Parser (Content Posn) Fix
parseContents = do
        { e :: Element Posn
e@(Elem _ as :: [Attribute]
as _) <- [String] -> XMLParser (Element Posn)
element ["Fix"]
        ; Element Posn
-> Parser (Content Posn) Fix -> Parser (Content Posn) Fix
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (Parser (Content Posn) Fix -> Parser (Content Posn) Fix)
-> Parser (Content Posn) Fix -> Parser (Content Posn) Fix
forall a b. (a -> b) -> a -> b
$ (OneOf3 TVar TFree Type -> Maybe Mixfix -> Fix)
-> Parser
     (Content Posn) (OneOf3 TVar TFree Type -> Maybe Mixfix -> Fix)
forall (m :: * -> *) a. Monad m => a -> m a
return (Fix_Attrs -> OneOf3 TVar TFree Type -> Maybe Mixfix -> Fix
Fix ([Attribute] -> Fix_Attrs
forall a. XmlAttributes a => [Attribute] -> a
fromAttrs [Attribute]
as)) Parser
  (Content Posn) (OneOf3 TVar TFree Type -> Maybe Mixfix -> Fix)
-> Parser (Content Posn) (OneOf3 TVar TFree Type)
-> Parser (Content Posn) (Maybe Mixfix -> Fix)
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) (OneOf3 TVar TFree Type)
forall a. XmlContent a => XMLParser a
parseContents
                       Parser (Content Posn) (Maybe Mixfix -> Fix)
-> Parser (Content Posn) (Maybe Mixfix)
-> Parser (Content Posn) Fix
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) Mixfix
-> Parser (Content Posn) (Maybe Mixfix)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser (Content Posn) Mixfix
forall a. XmlContent a => XMLParser a
parseContents
        } Parser (Content Posn) Fix -> ShowS -> Parser (Content Posn) Fix
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <Fix>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)
instance XmlAttributes Fix_Attrs where
    fromAttrs :: [Attribute] -> Fix_Attrs
fromAttrs as :: [Attribute]
as =
        Fix_Attrs :: String -> Fix_Attrs
Fix_Attrs
          { fixName :: String
fixName = (String -> Attribute -> Maybe String)
-> String -> String -> [Attribute] -> String
forall a.
(String -> Attribute -> Maybe a)
-> String -> String -> [Attribute] -> a
definiteA String -> Attribute -> Maybe String
fromAttrToStr "Fix" "name" [Attribute]
as
          }
    toAttrs :: Fix_Attrs -> [Attribute]
toAttrs v :: Fix_Attrs
v = [Maybe Attribute] -> [Attribute]
forall a. [Maybe a] -> [a]
catMaybes 
        [ String -> String -> Maybe Attribute
toAttrFrStr "name" (Fix_Attrs -> String
fixName Fix_Attrs
v)
        ]

instance HTypeable Assumes where
    toHType :: Assumes -> HType
toHType _ = String -> [HType] -> [Constr] -> HType
Defined "Assumes" [] []
instance XmlContent Assumes where
    toContents :: Assumes -> [Content ()]
toContents (Assumes a :: [Assumption]
a) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N "Assumes") [] ((Assumption -> [Content ()]) -> [Assumption] -> [Content ()]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap Assumption -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents [Assumption]
a)) ()]
    parseContents :: XMLParser Assumes
parseContents = do
        { e :: Element Posn
e@(Elem _ [] _) <- [String] -> XMLParser (Element Posn)
element ["Assumes"]
        ; Element Posn -> XMLParser Assumes -> XMLParser Assumes
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (XMLParser Assumes -> XMLParser Assumes)
-> XMLParser Assumes -> XMLParser Assumes
forall a b. (a -> b) -> a -> b
$ ([Assumption] -> Assumes)
-> Parser (Content Posn) ([Assumption] -> Assumes)
forall (m :: * -> *) a. Monad m => a -> m a
return ([Assumption] -> Assumes
Assumes) Parser (Content Posn) ([Assumption] -> Assumes)
-> Parser (Content Posn) [Assumption] -> XMLParser Assumes
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) Assumption
-> Parser (Content Posn) [Assumption]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many Parser (Content Posn) Assumption
forall a. XmlContent a => XMLParser a
parseContents
        } XMLParser Assumes -> ShowS -> XMLParser Assumes
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <Assumes>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)

instance HTypeable Assumption where
    toHType :: Assumption -> HType
toHType _ = String -> [HType] -> [Constr] -> HType
Defined "Assumption" [] []
instance XmlContent Assumption where
    toContents :: Assumption -> [Content ()]
toContents (Assumption as :: Assumption_Attrs
as a :: OneOf6 Bound Free Var Const App Abs
a) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N "Assumption") (Assumption_Attrs -> [Attribute]
forall a. XmlAttributes a => a -> [Attribute]
toAttrs Assumption_Attrs
as) (OneOf6 Bound Free Var Const App Abs -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents OneOf6 Bound Free Var Const App Abs
a)) ()]
    parseContents :: Parser (Content Posn) Assumption
parseContents = do
        { e :: Element Posn
e@(Elem _ as :: [Attribute]
as _) <- [String] -> XMLParser (Element Posn)
element ["Assumption"]
        ; Element Posn
-> Parser (Content Posn) Assumption
-> Parser (Content Posn) Assumption
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (Parser (Content Posn) Assumption
 -> Parser (Content Posn) Assumption)
-> Parser (Content Posn) Assumption
-> Parser (Content Posn) Assumption
forall a b. (a -> b) -> a -> b
$ (OneOf6 Bound Free Var Const App Abs -> Assumption)
-> Parser
     (Content Posn) (OneOf6 Bound Free Var Const App Abs -> Assumption)
forall (m :: * -> *) a. Monad m => a -> m a
return (Assumption_Attrs
-> OneOf6 Bound Free Var Const App Abs -> Assumption
Assumption ([Attribute] -> Assumption_Attrs
forall a. XmlAttributes a => [Attribute] -> a
fromAttrs [Attribute]
as))
                       Parser
  (Content Posn) (OneOf6 Bound Free Var Const App Abs -> Assumption)
-> Parser (Content Posn) (OneOf6 Bound Free Var Const App Abs)
-> Parser (Content Posn) Assumption
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) (OneOf6 Bound Free Var Const App Abs)
forall a. XmlContent a => XMLParser a
parseContents
        } Parser (Content Posn) Assumption
-> ShowS -> Parser (Content Posn) Assumption
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <Assumption>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)
instance XmlAttributes Assumption_Attrs where
    fromAttrs :: [Attribute] -> Assumption_Attrs
fromAttrs as :: [Attribute]
as =
        Assumption_Attrs :: String -> String -> Assumption_Attrs
Assumption_Attrs
          { assumptionName :: String
assumptionName = (String -> Attribute -> Maybe String)
-> String -> String -> [Attribute] -> String
forall a.
(String -> Attribute -> Maybe a)
-> String -> String -> [Attribute] -> a
definiteA String -> Attribute -> Maybe String
fromAttrToStr "Assumption" "name" [Attribute]
as
          , assumptionArgs :: String
assumptionArgs = (String -> Attribute -> Maybe String)
-> String -> String -> [Attribute] -> String
forall a.
(String -> Attribute -> Maybe a)
-> String -> String -> [Attribute] -> a
definiteA String -> Attribute -> Maybe String
fromAttrToStr "Assumption" "args" [Attribute]
as
          }
    toAttrs :: Assumption_Attrs -> [Attribute]
toAttrs v :: Assumption_Attrs
v = [Maybe Attribute] -> [Attribute]
forall a. [Maybe a] -> [a]
catMaybes 
        [ String -> String -> Maybe Attribute
toAttrFrStr "name" (Assumption_Attrs -> String
assumptionName Assumption_Attrs
v)
        , String -> String -> Maybe Attribute
toAttrFrStr "args" (Assumption_Attrs -> String
assumptionArgs Assumption_Attrs
v)
        ]

instance HTypeable Ctxt where
    toHType :: Ctxt -> HType
toHType _ = String -> [HType] -> [Constr] -> HType
Defined "Ctxt" [] []
instance XmlContent Ctxt where
    toContents :: Ctxt -> [Content ()]
toContents (Ctxt a :: [OneOf2 Fixes Assumes]
a) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N "Ctxt") [] ((OneOf2 Fixes Assumes -> [Content ()])
-> [OneOf2 Fixes Assumes] -> [Content ()]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap OneOf2 Fixes Assumes -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents [OneOf2 Fixes Assumes]
a)) ()]
    parseContents :: Parser (Content Posn) Ctxt
parseContents = do
        { e :: Element Posn
e@(Elem _ [] _) <- [String] -> XMLParser (Element Posn)
element ["Ctxt"]
        ; Element Posn
-> Parser (Content Posn) Ctxt -> Parser (Content Posn) Ctxt
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (Parser (Content Posn) Ctxt -> Parser (Content Posn) Ctxt)
-> Parser (Content Posn) Ctxt -> Parser (Content Posn) Ctxt
forall a b. (a -> b) -> a -> b
$ ([OneOf2 Fixes Assumes] -> Ctxt)
-> Parser (Content Posn) ([OneOf2 Fixes Assumes] -> Ctxt)
forall (m :: * -> *) a. Monad m => a -> m a
return ([OneOf2 Fixes Assumes] -> Ctxt
Ctxt) Parser (Content Posn) ([OneOf2 Fixes Assumes] -> Ctxt)
-> Parser (Content Posn) [OneOf2 Fixes Assumes]
-> Parser (Content Posn) Ctxt
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) (OneOf2 Fixes Assumes)
-> Parser (Content Posn) [OneOf2 Fixes Assumes]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many Parser (Content Posn) (OneOf2 Fixes Assumes)
forall a. XmlContent a => XMLParser a
parseContents
        } Parser (Content Posn) Ctxt -> ShowS -> Parser (Content Posn) Ctxt
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <Ctxt>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)

instance HTypeable Mixfix where
    toHType :: Mixfix -> HType
toHType _ = String -> [HType] -> [Constr] -> HType
Defined "Mixfix" [] []
instance XmlContent Mixfix where
    toContents :: Mixfix -> [Content ()]
toContents (Mixfix as :: Mixfix_Attrs
as a :: [OneOf4 Arg AString Break Block]
a) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N "Mixfix") (Mixfix_Attrs -> [Attribute]
forall a. XmlAttributes a => a -> [Attribute]
toAttrs Mixfix_Attrs
as) ((OneOf4 Arg AString Break Block -> [Content ()])
-> [OneOf4 Arg AString Break Block] -> [Content ()]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap OneOf4 Arg AString Break Block -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents [OneOf4 Arg AString Break Block]
a)) ()]
    parseContents :: Parser (Content Posn) Mixfix
parseContents = do
        { e :: Element Posn
e@(Elem _ as :: [Attribute]
as _) <- [String] -> XMLParser (Element Posn)
element ["Mixfix"]
        ; Element Posn
-> Parser (Content Posn) Mixfix -> Parser (Content Posn) Mixfix
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (Parser (Content Posn) Mixfix -> Parser (Content Posn) Mixfix)
-> Parser (Content Posn) Mixfix -> Parser (Content Posn) Mixfix
forall a b. (a -> b) -> a -> b
$ ([OneOf4 Arg AString Break Block] -> Mixfix)
-> Parser
     (Content Posn) ([OneOf4 Arg AString Break Block] -> Mixfix)
forall (m :: * -> *) a. Monad m => a -> m a
return (Mixfix_Attrs -> [OneOf4 Arg AString Break Block] -> Mixfix
Mixfix ([Attribute] -> Mixfix_Attrs
forall a. XmlAttributes a => [Attribute] -> a
fromAttrs [Attribute]
as))
                       Parser (Content Posn) ([OneOf4 Arg AString Break Block] -> Mixfix)
-> Parser (Content Posn) [OneOf4 Arg AString Break Block]
-> Parser (Content Posn) Mixfix
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) (OneOf4 Arg AString Break Block)
-> Parser (Content Posn) [OneOf4 Arg AString Break Block]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many Parser (Content Posn) (OneOf4 Arg AString Break Block)
forall a. XmlContent a => XMLParser a
parseContents
        } Parser (Content Posn) Mixfix
-> ShowS -> Parser (Content Posn) Mixfix
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <Mixfix>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)
instance XmlAttributes Mixfix_Attrs where
    fromAttrs :: [Attribute] -> Mixfix_Attrs
fromAttrs as :: [Attribute]
as =
        Mixfix_Attrs :: String -> String -> String -> Mixfix_Attrs
Mixfix_Attrs
          { mixfixNargs :: String
mixfixNargs = (String -> Attribute -> Maybe String)
-> String -> String -> [Attribute] -> String
forall a.
(String -> Attribute -> Maybe a)
-> String -> String -> [Attribute] -> a
definiteA String -> Attribute -> Maybe String
fromAttrToStr "Mixfix" "nargs" [Attribute]
as
          , mixfixPrio :: String
mixfixPrio = (String -> Attribute -> Maybe String)
-> String -> String -> [Attribute] -> String
forall a.
(String -> Attribute -> Maybe a)
-> String -> String -> [Attribute] -> a
definiteA String -> Attribute -> Maybe String
fromAttrToStr "Mixfix" "prio" [Attribute]
as
          , mixfixPretty :: String
mixfixPretty = (String -> Attribute -> Maybe String)
-> String -> String -> [Attribute] -> String
forall a.
(String -> Attribute -> Maybe a)
-> String -> String -> [Attribute] -> a
definiteA String -> Attribute -> Maybe String
fromAttrToStr "Mixfix" "pretty" [Attribute]
as
          }
    toAttrs :: Mixfix_Attrs -> [Attribute]
toAttrs v :: Mixfix_Attrs
v = [Maybe Attribute] -> [Attribute]
forall a. [Maybe a] -> [a]
catMaybes 
        [ String -> String -> Maybe Attribute
toAttrFrStr "nargs" (Mixfix_Attrs -> String
mixfixNargs Mixfix_Attrs
v)
        , String -> String -> Maybe Attribute
toAttrFrStr "prio" (Mixfix_Attrs -> String
mixfixPrio Mixfix_Attrs
v)
        , String -> String -> Maybe Attribute
toAttrFrStr "pretty" (Mixfix_Attrs -> String
mixfixPretty Mixfix_Attrs
v)
        ]

instance HTypeable Arg where
    toHType :: Arg -> HType
toHType _ = String -> [HType] -> [Constr] -> HType
Defined "Arg" [] []
instance XmlContent Arg where
    toContents :: Arg -> [Content ()]
toContents as :: Arg
as =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N "Arg") (Arg -> [Attribute]
forall a. XmlAttributes a => a -> [Attribute]
toAttrs Arg
as) []) ()]
    parseContents :: XMLParser Arg
parseContents = do
        { (Elem _ as :: [Attribute]
as []) <- [String] -> XMLParser (Element Posn)
element ["Arg"]
        ; Arg -> XMLParser Arg
forall (m :: * -> *) a. Monad m => a -> m a
return ([Attribute] -> Arg
forall a. XmlAttributes a => [Attribute] -> a
fromAttrs [Attribute]
as)
        } XMLParser Arg -> ShowS -> XMLParser Arg
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <Arg>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)
instance XmlAttributes Arg where
    fromAttrs :: [Attribute] -> Arg
fromAttrs as :: [Attribute]
as =
        Arg :: String -> Arg
Arg
          { argPrio :: String
argPrio = (String -> Attribute -> Maybe String)
-> String -> String -> [Attribute] -> String
forall a.
(String -> Attribute -> Maybe a)
-> String -> String -> [Attribute] -> a
definiteA String -> Attribute -> Maybe String
fromAttrToStr "Arg" "prio" [Attribute]
as
          }
    toAttrs :: Arg -> [Attribute]
toAttrs v :: Arg
v = [Maybe Attribute] -> [Attribute]
forall a. [Maybe a] -> [a]
catMaybes 
        [ String -> String -> Maybe Attribute
toAttrFrStr "prio" (Arg -> String
argPrio Arg
v)
        ]

instance HTypeable AString where
    toHType :: AString -> HType
toHType _ = String -> [HType] -> [Constr] -> HType
Defined "String" [] []
instance XmlContent AString where
    toContents :: AString -> [Content ()]
toContents as :: AString
as =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N "String") (AString -> [Attribute]
forall a. XmlAttributes a => a -> [Attribute]
toAttrs AString
as) []) ()]
    parseContents :: XMLParser AString
parseContents = do
        { (Elem _ as :: [Attribute]
as []) <- [String] -> XMLParser (Element Posn)
element ["String"]
        ; AString -> XMLParser AString
forall (m :: * -> *) a. Monad m => a -> m a
return ([Attribute] -> AString
forall a. XmlAttributes a => [Attribute] -> a
fromAttrs [Attribute]
as)
        } XMLParser AString -> ShowS -> XMLParser AString
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <String>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)
instance XmlAttributes AString where
    fromAttrs :: [Attribute] -> AString
fromAttrs as :: [Attribute]
as =
        AString :: String -> AString
AString
          { stringVal :: String
stringVal = (String -> Attribute -> Maybe String)
-> String -> String -> [Attribute] -> String
forall a.
(String -> Attribute -> Maybe a)
-> String -> String -> [Attribute] -> a
definiteA String -> Attribute -> Maybe String
fromAttrToStr "String" "val" [Attribute]
as
          }
    toAttrs :: AString -> [Attribute]
toAttrs v :: AString
v = [Maybe Attribute] -> [Attribute]
forall a. [Maybe a] -> [a]
catMaybes 
        [ String -> String -> Maybe Attribute
toAttrFrStr "val" (AString -> String
stringVal AString
v)
        ]

instance HTypeable Break where
    toHType :: Break -> HType
toHType _ = String -> [HType] -> [Constr] -> HType
Defined "Break" [] []
instance XmlContent Break where
    toContents :: Break -> [Content ()]
toContents as :: Break
as =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N "Break") (Break -> [Attribute]
forall a. XmlAttributes a => a -> [Attribute]
toAttrs Break
as) []) ()]
    parseContents :: XMLParser Break
parseContents = do
        { (Elem _ as :: [Attribute]
as []) <- [String] -> XMLParser (Element Posn)
element ["Break"]
        ; Break -> XMLParser Break
forall (m :: * -> *) a. Monad m => a -> m a
return ([Attribute] -> Break
forall a. XmlAttributes a => [Attribute] -> a
fromAttrs [Attribute]
as)
        } XMLParser Break -> ShowS -> XMLParser Break
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <Break>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)
instance XmlAttributes Break where
    fromAttrs :: [Attribute] -> Break
fromAttrs as :: [Attribute]
as =
        Break :: String -> Break
Break
          { breakPrio :: String
breakPrio = (String -> Attribute -> Maybe String)
-> String -> String -> [Attribute] -> String
forall a.
(String -> Attribute -> Maybe a)
-> String -> String -> [Attribute] -> a
definiteA String -> Attribute -> Maybe String
fromAttrToStr "Break" "prio" [Attribute]
as
          }
    toAttrs :: Break -> [Attribute]
toAttrs v :: Break
v = [Maybe Attribute] -> [Attribute]
forall a. [Maybe a] -> [a]
catMaybes 
        [ String -> String -> Maybe Attribute
toAttrFrStr "prio" (Break -> String
breakPrio Break
v)
        ]

instance HTypeable Block where
    toHType :: Block -> HType
toHType _ = String -> [HType] -> [Constr] -> HType
Defined "Block" [] []
instance XmlContent Block where
    toContents :: Block -> [Content ()]
toContents (Block as :: Block_Attrs
as a :: [OneOf4 Arg AString Break Block]
a) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N "Block") (Block_Attrs -> [Attribute]
forall a. XmlAttributes a => a -> [Attribute]
toAttrs Block_Attrs
as) ((OneOf4 Arg AString Break Block -> [Content ()])
-> [OneOf4 Arg AString Break Block] -> [Content ()]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap OneOf4 Arg AString Break Block -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents [OneOf4 Arg AString Break Block]
a)) ()]
    parseContents :: XMLParser Block
parseContents = do
        { e :: Element Posn
e@(Elem _ as :: [Attribute]
as _) <- [String] -> XMLParser (Element Posn)
element ["Block"]
        ; Element Posn -> XMLParser Block -> XMLParser Block
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (XMLParser Block -> XMLParser Block)
-> XMLParser Block -> XMLParser Block
forall a b. (a -> b) -> a -> b
$ ([OneOf4 Arg AString Break Block] -> Block)
-> Parser
     (Content Posn) ([OneOf4 Arg AString Break Block] -> Block)
forall (m :: * -> *) a. Monad m => a -> m a
return (Block_Attrs -> [OneOf4 Arg AString Break Block] -> Block
Block ([Attribute] -> Block_Attrs
forall a. XmlAttributes a => [Attribute] -> a
fromAttrs [Attribute]
as))
                       Parser (Content Posn) ([OneOf4 Arg AString Break Block] -> Block)
-> Parser (Content Posn) [OneOf4 Arg AString Break Block]
-> XMLParser Block
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) (OneOf4 Arg AString Break Block)
-> Parser (Content Posn) [OneOf4 Arg AString Break Block]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many Parser (Content Posn) (OneOf4 Arg AString Break Block)
forall a. XmlContent a => XMLParser a
parseContents
        } XMLParser Block -> ShowS -> XMLParser Block
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <Block>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)
instance XmlAttributes Block_Attrs where
    fromAttrs :: [Attribute] -> Block_Attrs
fromAttrs as :: [Attribute]
as =
        Block_Attrs :: String -> Block_Attrs
Block_Attrs
          { blockPrio :: String
blockPrio = (String -> Attribute -> Maybe String)
-> String -> String -> [Attribute] -> String
forall a.
(String -> Attribute -> Maybe a)
-> String -> String -> [Attribute] -> a
definiteA String -> Attribute -> Maybe String
fromAttrToStr "Block" "prio" [Attribute]
as
          }
    toAttrs :: Block_Attrs -> [Attribute]
toAttrs v :: Block_Attrs
v = [Maybe Attribute] -> [Attribute]
forall a. [Maybe a] -> [a]
catMaybes 
        [ String -> String -> Maybe Attribute
toAttrFrStr "prio" (Block_Attrs -> String
blockPrio Block_Attrs
v)
        ]

instance HTypeable Proof where
    toHType :: Proof -> HType
toHType _ = String -> [HType] -> [Constr] -> HType
Defined "Proof" [] []
instance XmlContent Proof where
    toContents :: Proof -> [Content ()]
toContents (Proof a :: String
a) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N "Proof") [] (String -> [Content ()]
toText String
a)) ()]
    parseContents :: Parser (Content Posn) Proof
parseContents = do
        { e :: Element Posn
e@(Elem _ [] _) <- [String] -> XMLParser (Element Posn)
element ["Proof"]
        ; Element Posn
-> Parser (Content Posn) Proof -> Parser (Content Posn) Proof
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (Parser (Content Posn) Proof -> Parser (Content Posn) Proof)
-> Parser (Content Posn) Proof -> Parser (Content Posn) Proof
forall a b. (a -> b) -> a -> b
$ (String -> Proof) -> Parser (Content Posn) (String -> Proof)
forall (m :: * -> *) a. Monad m => a -> m a
return (String -> Proof
Proof) Parser (Content Posn) (String -> Proof)
-> Parser (Content Posn) String -> Parser (Content Posn) Proof
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` (Parser (Content Posn) String
text Parser (Content Posn) String
-> Parser (Content Posn) String -> Parser (Content Posn) String
forall t a. Parser t a -> Parser t a -> Parser t a
`onFail` String -> Parser (Content Posn) String
forall (m :: * -> *) a. Monad m => a -> m a
return "")
        } Parser (Content Posn) Proof -> ShowS -> Parser (Content Posn) Proof
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <Proof>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)

instance HTypeable Shows where
    toHType :: Shows -> HType
toHType _ = String -> [HType] -> [Constr] -> HType
Defined "Shows" [] []
instance XmlContent Shows where
    toContents :: Shows -> [Content ()]
toContents (Shows as :: Shows_Attrs
as a :: List1 AShow
a) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N "Shows") (Shows_Attrs -> [Attribute]
forall a. XmlAttributes a => a -> [Attribute]
toAttrs Shows_Attrs
as) (List1 AShow -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents List1 AShow
a)) ()]
    parseContents :: XMLParser Shows
parseContents = do
        { e :: Element Posn
e@(Elem _ as :: [Attribute]
as _) <- [String] -> XMLParser (Element Posn)
element ["Shows"]
        ; Element Posn -> XMLParser Shows -> XMLParser Shows
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (XMLParser Shows -> XMLParser Shows)
-> XMLParser Shows -> XMLParser Shows
forall a b. (a -> b) -> a -> b
$ (List1 AShow -> Shows)
-> Parser (Content Posn) (List1 AShow -> Shows)
forall (m :: * -> *) a. Monad m => a -> m a
return (Shows_Attrs -> List1 AShow -> Shows
Shows ([Attribute] -> Shows_Attrs
forall a. XmlAttributes a => [Attribute] -> a
fromAttrs [Attribute]
as)) Parser (Content Posn) (List1 AShow -> Shows)
-> Parser (Content Posn) (List1 AShow) -> XMLParser Shows
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) (List1 AShow)
forall a. XmlContent a => XMLParser a
parseContents
        } XMLParser Shows -> ShowS -> XMLParser Shows
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <Shows>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)
instance XmlAttributes Shows_Attrs where
    fromAttrs :: [Attribute] -> Shows_Attrs
fromAttrs as :: [Attribute]
as =
        Shows_Attrs :: String -> Maybe String -> Shows_Attrs
Shows_Attrs
          { showsName :: String
showsName = (String -> Attribute -> Maybe String)
-> String -> String -> [Attribute] -> String
forall a.
(String -> Attribute -> Maybe a)
-> String -> String -> [Attribute] -> a
definiteA String -> Attribute -> Maybe String
fromAttrToStr "Shows" "name" [Attribute]
as
          , showsArgs :: Maybe String
showsArgs = (String -> Attribute -> Maybe String)
-> String -> [Attribute] -> Maybe String
forall a.
(String -> Attribute -> Maybe a)
-> String -> [Attribute] -> Maybe a
possibleA String -> Attribute -> Maybe String
fromAttrToStr "args" [Attribute]
as
          }
    toAttrs :: Shows_Attrs -> [Attribute]
toAttrs v :: Shows_Attrs
v = [Maybe Attribute] -> [Attribute]
forall a. [Maybe a] -> [a]
catMaybes 
        [ String -> String -> Maybe Attribute
toAttrFrStr "name" (Shows_Attrs -> String
showsName Shows_Attrs
v)
        , (String -> String -> Maybe Attribute)
-> String -> Maybe String -> Maybe Attribute
forall a.
(String -> a -> Maybe Attribute)
-> String -> Maybe a -> Maybe Attribute
maybeToAttr String -> String -> Maybe Attribute
toAttrFrStr "args" (Shows_Attrs -> Maybe String
showsArgs Shows_Attrs
v)
        ]

instance HTypeable AShow where
    toHType :: AShow -> HType
toHType _ = String -> [HType] -> [Constr] -> HType
Defined "Show" [] []
instance XmlContent AShow where
    toContents :: AShow -> [Content ()]
toContents (AShow a :: List1 (OneOf6 Bound Free Var Const App Abs)
a) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N "Show") [] (List1 (OneOf6 Bound Free Var Const App Abs) -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents List1 (OneOf6 Bound Free Var Const App Abs)
a)) ()]
    parseContents :: XMLParser AShow
parseContents = do
        { e :: Element Posn
e@(Elem _ [] _) <- [String] -> XMLParser (Element Posn)
element ["Show"]
        ; Element Posn -> XMLParser AShow -> XMLParser AShow
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (XMLParser AShow -> XMLParser AShow)
-> XMLParser AShow -> XMLParser AShow
forall a b. (a -> b) -> a -> b
$ (List1 (OneOf6 Bound Free Var Const App Abs) -> AShow)
-> Parser
     (Content Posn)
     (List1 (OneOf6 Bound Free Var Const App Abs) -> AShow)
forall (m :: * -> *) a. Monad m => a -> m a
return (List1 (OneOf6 Bound Free Var Const App Abs) -> AShow
AShow) Parser
  (Content Posn)
  (List1 (OneOf6 Bound Free Var Const App Abs) -> AShow)
-> Parser
     (Content Posn) (List1 (OneOf6 Bound Free Var Const App Abs))
-> XMLParser AShow
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) (List1 (OneOf6 Bound Free Var Const App Abs))
forall a. XmlContent a => XMLParser a
parseContents
        } XMLParser AShow -> ShowS -> XMLParser AShow
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <Show>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)

instance HTypeable Bound where
    toHType :: Bound -> HType
toHType _ = String -> [HType] -> [Constr] -> HType
Defined "Bound" [] []
instance XmlContent Bound where
    toContents :: Bound -> [Content ()]
toContents as :: Bound
as =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N "Bound") (Bound -> [Attribute]
forall a. XmlAttributes a => a -> [Attribute]
toAttrs Bound
as) []) ()]
    parseContents :: XMLParser Bound
parseContents = do
        { (Elem _ as :: [Attribute]
as []) <- [String] -> XMLParser (Element Posn)
element ["Bound"]
        ; Bound -> XMLParser Bound
forall (m :: * -> *) a. Monad m => a -> m a
return ([Attribute] -> Bound
forall a. XmlAttributes a => [Attribute] -> a
fromAttrs [Attribute]
as)
        } XMLParser Bound -> ShowS -> XMLParser Bound
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <Bound>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)
instance XmlAttributes Bound where
    fromAttrs :: [Attribute] -> Bound
fromAttrs as :: [Attribute]
as =
        Bound :: String -> Bound
Bound
          { boundIndex :: String
boundIndex = (String -> Attribute -> Maybe String)
-> String -> String -> [Attribute] -> String
forall a.
(String -> Attribute -> Maybe a)
-> String -> String -> [Attribute] -> a
definiteA String -> Attribute -> Maybe String
fromAttrToStr "Bound" "index" [Attribute]
as
          }
    toAttrs :: Bound -> [Attribute]
toAttrs v :: Bound
v = [Maybe Attribute] -> [Attribute]
forall a. [Maybe a] -> [a]
catMaybes 
        [ String -> String -> Maybe Attribute
toAttrFrStr "index" (Bound -> String
boundIndex Bound
v)
        ]

instance HTypeable Free where
    toHType :: Free -> HType
toHType _ = String -> [HType] -> [Constr] -> HType
Defined "Free" [] []
instance XmlContent Free where
    toContents :: Free -> [Content ()]
toContents (FreeTVar as :: Free_Attrs
as a :: TVar
a) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N "Free") (Free_Attrs -> [Attribute]
forall a. XmlAttributes a => a -> [Attribute]
toAttrs Free_Attrs
as) (TVar -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents TVar
a) ) ()]
    toContents (FreeTFree as :: Free_Attrs
as a :: TFree
a) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N "Free") (Free_Attrs -> [Attribute]
forall a. XmlAttributes a => a -> [Attribute]
toAttrs Free_Attrs
as) (TFree -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents TFree
a) ) ()]
    toContents (FreeType as :: Free_Attrs
as a :: Type
a) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N "Free") (Free_Attrs -> [Attribute]
forall a. XmlAttributes a => a -> [Attribute]
toAttrs Free_Attrs
as) (Type -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents Type
a) ) ()]
    parseContents :: XMLParser Free
parseContents = do 
        { e :: Element Posn
e@(Elem _ as :: [Attribute]
as _) <- [String] -> XMLParser (Element Posn)
element ["Free"]
        ; Element Posn -> XMLParser Free -> XMLParser Free
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (XMLParser Free -> XMLParser Free)
-> XMLParser Free -> XMLParser Free
forall a b. (a -> b) -> a -> b
$ [XMLParser Free] -> XMLParser Free
forall (p :: * -> *) a. PolyParse p => [p a] -> p a
oneOf
            [ (TVar -> Free) -> Parser (Content Posn) (TVar -> Free)
forall (m :: * -> *) a. Monad m => a -> m a
return (Free_Attrs -> TVar -> Free
FreeTVar ([Attribute] -> Free_Attrs
forall a. XmlAttributes a => [Attribute] -> a
fromAttrs [Attribute]
as)) Parser (Content Posn) (TVar -> Free)
-> Parser (Content Posn) TVar -> XMLParser Free
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) TVar
forall a. XmlContent a => XMLParser a
parseContents
            , (TFree -> Free) -> Parser (Content Posn) (TFree -> Free)
forall (m :: * -> *) a. Monad m => a -> m a
return (Free_Attrs -> TFree -> Free
FreeTFree ([Attribute] -> Free_Attrs
forall a. XmlAttributes a => [Attribute] -> a
fromAttrs [Attribute]
as)) Parser (Content Posn) (TFree -> Free)
-> Parser (Content Posn) TFree -> XMLParser Free
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) TFree
forall a. XmlContent a => XMLParser a
parseContents
            , (Type -> Free) -> Parser (Content Posn) (Type -> Free)
forall (m :: * -> *) a. Monad m => a -> m a
return (Free_Attrs -> Type -> Free
FreeType ([Attribute] -> Free_Attrs
forall a. XmlAttributes a => [Attribute] -> a
fromAttrs [Attribute]
as)) Parser (Content Posn) (Type -> Free)
-> Parser (Content Posn) Type -> XMLParser Free
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) Type
forall a. XmlContent a => XMLParser a
parseContents
            ] XMLParser Free -> ShowS -> XMLParser Free
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <Free>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)
        }
instance XmlAttributes Free_Attrs where
    fromAttrs :: [Attribute] -> Free_Attrs
fromAttrs as :: [Attribute]
as =
        Free_Attrs :: String -> Free_Attrs
Free_Attrs
          { freeName :: String
freeName = (String -> Attribute -> Maybe String)
-> String -> String -> [Attribute] -> String
forall a.
(String -> Attribute -> Maybe a)
-> String -> String -> [Attribute] -> a
definiteA String -> Attribute -> Maybe String
fromAttrToStr "Free" "name" [Attribute]
as
          }
    toAttrs :: Free_Attrs -> [Attribute]
toAttrs v :: Free_Attrs
v = [Maybe Attribute] -> [Attribute]
forall a. [Maybe a] -> [a]
catMaybes 
        [ String -> String -> Maybe Attribute
toAttrFrStr "name" (Free_Attrs -> String
freeName Free_Attrs
v)
        ]

instance HTypeable Var where
    toHType :: Var -> HType
toHType _ = String -> [HType] -> [Constr] -> HType
Defined "Var" [] []
instance XmlContent Var where
    toContents :: Var -> [Content ()]
toContents (VarTVar as :: Var_Attrs
as a :: TVar
a) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N "Var") (Var_Attrs -> [Attribute]
forall a. XmlAttributes a => a -> [Attribute]
toAttrs Var_Attrs
as) (TVar -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents TVar
a) ) ()]
    toContents (VarTFree as :: Var_Attrs
as a :: TFree
a) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N "Var") (Var_Attrs -> [Attribute]
forall a. XmlAttributes a => a -> [Attribute]
toAttrs Var_Attrs
as) (TFree -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents TFree
a) ) ()]
    toContents (VarType as :: Var_Attrs
as a :: Type
a) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N "Var") (Var_Attrs -> [Attribute]
forall a. XmlAttributes a => a -> [Attribute]
toAttrs Var_Attrs
as) (Type -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents Type
a) ) ()]
    parseContents :: XMLParser Var
parseContents = do 
        { e :: Element Posn
e@(Elem _ as :: [Attribute]
as _) <- [String] -> XMLParser (Element Posn)
element ["Var"]
        ; Element Posn -> XMLParser Var -> XMLParser Var
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (XMLParser Var -> XMLParser Var) -> XMLParser Var -> XMLParser Var
forall a b. (a -> b) -> a -> b
$ [XMLParser Var] -> XMLParser Var
forall (p :: * -> *) a. PolyParse p => [p a] -> p a
oneOf
            [ (TVar -> Var) -> Parser (Content Posn) (TVar -> Var)
forall (m :: * -> *) a. Monad m => a -> m a
return (Var_Attrs -> TVar -> Var
VarTVar ([Attribute] -> Var_Attrs
forall a. XmlAttributes a => [Attribute] -> a
fromAttrs [Attribute]
as)) Parser (Content Posn) (TVar -> Var)
-> Parser (Content Posn) TVar -> XMLParser Var
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) TVar
forall a. XmlContent a => XMLParser a
parseContents
            , (TFree -> Var) -> Parser (Content Posn) (TFree -> Var)
forall (m :: * -> *) a. Monad m => a -> m a
return (Var_Attrs -> TFree -> Var
VarTFree ([Attribute] -> Var_Attrs
forall a. XmlAttributes a => [Attribute] -> a
fromAttrs [Attribute]
as)) Parser (Content Posn) (TFree -> Var)
-> Parser (Content Posn) TFree -> XMLParser Var
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) TFree
forall a. XmlContent a => XMLParser a
parseContents
            , (Type -> Var) -> Parser (Content Posn) (Type -> Var)
forall (m :: * -> *) a. Monad m => a -> m a
return (Var_Attrs -> Type -> Var
VarType ([Attribute] -> Var_Attrs
forall a. XmlAttributes a => [Attribute] -> a
fromAttrs [Attribute]
as)) Parser (Content Posn) (Type -> Var)
-> Parser (Content Posn) Type -> XMLParser Var
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) Type
forall a. XmlContent a => XMLParser a
parseContents
            ] XMLParser Var -> ShowS -> XMLParser Var
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <Var>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)
        }
instance XmlAttributes Var_Attrs where
    fromAttrs :: [Attribute] -> Var_Attrs
fromAttrs as :: [Attribute]
as =
        Var_Attrs :: String -> Maybe String -> Var_Attrs
Var_Attrs
          { varName :: String
varName = (String -> Attribute -> Maybe String)
-> String -> String -> [Attribute] -> String
forall a.
(String -> Attribute -> Maybe a)
-> String -> String -> [Attribute] -> a
definiteA String -> Attribute -> Maybe String
fromAttrToStr "Var" "name" [Attribute]
as
          , varIndex :: Maybe String
varIndex = (String -> Attribute -> Maybe String)
-> String -> [Attribute] -> Maybe String
forall a.
(String -> Attribute -> Maybe a)
-> String -> [Attribute] -> Maybe a
possibleA String -> Attribute -> Maybe String
fromAttrToStr "index" [Attribute]
as
          }
    toAttrs :: Var_Attrs -> [Attribute]
toAttrs v :: Var_Attrs
v = [Maybe Attribute] -> [Attribute]
forall a. [Maybe a] -> [a]
catMaybes 
        [ String -> String -> Maybe Attribute
toAttrFrStr "name" (Var_Attrs -> String
varName Var_Attrs
v)
        , (String -> String -> Maybe Attribute)
-> String -> Maybe String -> Maybe Attribute
forall a.
(String -> a -> Maybe Attribute)
-> String -> Maybe a -> Maybe Attribute
maybeToAttr String -> String -> Maybe Attribute
toAttrFrStr "index" (Var_Attrs -> Maybe String
varIndex Var_Attrs
v)
        ]

instance HTypeable Const where
    toHType :: Const -> HType
toHType _ = String -> [HType] -> [Constr] -> HType
Defined "Const" [] []
instance XmlContent Const where
    toContents :: Const -> [Content ()]
toContents (Const as :: Const_Attrs
as a :: OneOf3 TVar TFree Type
a) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N "Const") (Const_Attrs -> [Attribute]
forall a. XmlAttributes a => a -> [Attribute]
toAttrs Const_Attrs
as) (OneOf3 TVar TFree Type -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents OneOf3 TVar TFree Type
a)) ()]
    parseContents :: XMLParser Const
parseContents = do
        { e :: Element Posn
e@(Elem _ as :: [Attribute]
as _) <- [String] -> XMLParser (Element Posn)
element ["Const"]
        ; Element Posn -> XMLParser Const -> XMLParser Const
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (XMLParser Const -> XMLParser Const)
-> XMLParser Const -> XMLParser Const
forall a b. (a -> b) -> a -> b
$ (OneOf3 TVar TFree Type -> Const)
-> Parser (Content Posn) (OneOf3 TVar TFree Type -> Const)
forall (m :: * -> *) a. Monad m => a -> m a
return (Const_Attrs -> OneOf3 TVar TFree Type -> Const
Const ([Attribute] -> Const_Attrs
forall a. XmlAttributes a => [Attribute] -> a
fromAttrs [Attribute]
as)) Parser (Content Posn) (OneOf3 TVar TFree Type -> Const)
-> Parser (Content Posn) (OneOf3 TVar TFree Type)
-> XMLParser Const
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) (OneOf3 TVar TFree Type)
forall a. XmlContent a => XMLParser a
parseContents
        } XMLParser Const -> ShowS -> XMLParser Const
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <Const>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)
instance XmlAttributes Const_Attrs where
    fromAttrs :: [Attribute] -> Const_Attrs
fromAttrs as :: [Attribute]
as =
        Const_Attrs :: String -> Const_Attrs
Const_Attrs
          { constName :: String
constName = (String -> Attribute -> Maybe String)
-> String -> String -> [Attribute] -> String
forall a.
(String -> Attribute -> Maybe a)
-> String -> String -> [Attribute] -> a
definiteA String -> Attribute -> Maybe String
fromAttrToStr "Const" "name" [Attribute]
as
          }
    toAttrs :: Const_Attrs -> [Attribute]
toAttrs v :: Const_Attrs
v = [Maybe Attribute] -> [Attribute]
forall a. [Maybe a] -> [a]
catMaybes 
        [ String -> String -> Maybe Attribute
toAttrFrStr "name" (Const_Attrs -> String
constName Const_Attrs
v)
        ]

instance HTypeable App where
    toHType :: App -> HType
toHType _ = String -> [HType] -> [Constr] -> HType
Defined "App" [] []
instance XmlContent App where
    toContents :: App -> [Content ()]
toContents (App a :: OneOf6 Bound Free Var Const App Abs
a b :: OneOf6 Bound Free Var Const App Abs
b) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N "App") [] (OneOf6 Bound Free Var Const App Abs -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents OneOf6 Bound Free Var Const App Abs
a [Content ()] -> [Content ()] -> [Content ()]
forall a. [a] -> [a] -> [a]
++ OneOf6 Bound Free Var Const App Abs -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents OneOf6 Bound Free Var Const App Abs
b)) ()]
    parseContents :: XMLParser App
parseContents = do
        { e :: Element Posn
e@(Elem _ [] _) <- [String] -> XMLParser (Element Posn)
element ["App"]
        ; Element Posn -> XMLParser App -> XMLParser App
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (XMLParser App -> XMLParser App) -> XMLParser App -> XMLParser App
forall a b. (a -> b) -> a -> b
$ (OneOf6 Bound Free Var Const App Abs
 -> OneOf6 Bound Free Var Const App Abs -> App)
-> Parser
     (Content Posn)
     (OneOf6 Bound Free Var Const App Abs
      -> OneOf6 Bound Free Var Const App Abs -> App)
forall (m :: * -> *) a. Monad m => a -> m a
return (OneOf6 Bound Free Var Const App Abs
-> OneOf6 Bound Free Var Const App Abs -> App
App) Parser
  (Content Posn)
  (OneOf6 Bound Free Var Const App Abs
   -> OneOf6 Bound Free Var Const App Abs -> App)
-> Parser (Content Posn) (OneOf6 Bound Free Var Const App Abs)
-> Parser
     (Content Posn) (OneOf6 Bound Free Var Const App Abs -> App)
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) (OneOf6 Bound Free Var Const App Abs)
forall a. XmlContent a => XMLParser a
parseContents
                       Parser (Content Posn) (OneOf6 Bound Free Var Const App Abs -> App)
-> Parser (Content Posn) (OneOf6 Bound Free Var Const App Abs)
-> XMLParser App
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) (OneOf6 Bound Free Var Const App Abs)
forall a. XmlContent a => XMLParser a
parseContents
        } XMLParser App -> ShowS -> XMLParser App
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <App>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)

instance HTypeable Abs where
    toHType :: Abs -> HType
toHType _ = String -> [HType] -> [Constr] -> HType
Defined "Abs" [] []
instance XmlContent Abs where
    toContents :: Abs -> [Content ()]
toContents (Abs as :: Abs_Attrs
as a :: OneOf3 TVar TFree Type
a b :: OneOf6 Bound Free Var Const App Abs
b) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N "Abs") (Abs_Attrs -> [Attribute]
forall a. XmlAttributes a => a -> [Attribute]
toAttrs Abs_Attrs
as) (OneOf3 TVar TFree Type -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents OneOf3 TVar TFree Type
a [Content ()] -> [Content ()] -> [Content ()]
forall a. [a] -> [a] -> [a]
++
                                             OneOf6 Bound Free Var Const App Abs -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents OneOf6 Bound Free Var Const App Abs
b)) ()]
    parseContents :: XMLParser Abs
parseContents = do
        { e :: Element Posn
e@(Elem _ as :: [Attribute]
as _) <- [String] -> XMLParser (Element Posn)
element ["Abs"]
        ; Element Posn -> XMLParser Abs -> XMLParser Abs
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (XMLParser Abs -> XMLParser Abs) -> XMLParser Abs -> XMLParser Abs
forall a b. (a -> b) -> a -> b
$ (OneOf3 TVar TFree Type
 -> OneOf6 Bound Free Var Const App Abs -> Abs)
-> Parser
     (Content Posn)
     (OneOf3 TVar TFree Type
      -> OneOf6 Bound Free Var Const App Abs -> Abs)
forall (m :: * -> *) a. Monad m => a -> m a
return (Abs_Attrs
-> OneOf3 TVar TFree Type
-> OneOf6 Bound Free Var Const App Abs
-> Abs
Abs ([Attribute] -> Abs_Attrs
forall a. XmlAttributes a => [Attribute] -> a
fromAttrs [Attribute]
as)) Parser
  (Content Posn)
  (OneOf3 TVar TFree Type
   -> OneOf6 Bound Free Var Const App Abs -> Abs)
-> Parser (Content Posn) (OneOf3 TVar TFree Type)
-> Parser
     (Content Posn) (OneOf6 Bound Free Var Const App Abs -> Abs)
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) (OneOf3 TVar TFree Type)
forall a. XmlContent a => XMLParser a
parseContents
                       Parser (Content Posn) (OneOf6 Bound Free Var Const App Abs -> Abs)
-> Parser (Content Posn) (OneOf6 Bound Free Var Const App Abs)
-> XMLParser Abs
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) (OneOf6 Bound Free Var Const App Abs)
forall a. XmlContent a => XMLParser a
parseContents
        } XMLParser Abs -> ShowS -> XMLParser Abs
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <Abs>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)
instance XmlAttributes Abs_Attrs where
    fromAttrs :: [Attribute] -> Abs_Attrs
fromAttrs as :: [Attribute]
as =
        Abs_Attrs :: String -> Abs_Attrs
Abs_Attrs
          { absVname :: String
absVname = (String -> Attribute -> Maybe String)
-> String -> String -> [Attribute] -> String
forall a.
(String -> Attribute -> Maybe a)
-> String -> String -> [Attribute] -> a
definiteA String -> Attribute -> Maybe String
fromAttrToStr "Abs" "vname" [Attribute]
as
          }
    toAttrs :: Abs_Attrs -> [Attribute]
toAttrs v :: Abs_Attrs
v = [Maybe Attribute] -> [Attribute]
forall a. [Maybe a] -> [a]
catMaybes 
        [ String -> String -> Maybe Attribute
toAttrFrStr "vname" (Abs_Attrs -> String
absVname Abs_Attrs
v)
        ]

instance HTypeable TVar where
    toHType :: TVar -> HType
toHType _ = String -> [HType] -> [Constr] -> HType
Defined "TVar" [] []
instance XmlContent TVar where
    toContents :: TVar -> [Content ()]
toContents (TVar as :: TVar_Attrs
as a :: [Class]
a) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N "TVar") (TVar_Attrs -> [Attribute]
forall a. XmlAttributes a => a -> [Attribute]
toAttrs TVar_Attrs
as) ((Class -> [Content ()]) -> [Class] -> [Content ()]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap Class -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents [Class]
a)) ()]
    parseContents :: Parser (Content Posn) TVar
parseContents = do
        { e :: Element Posn
e@(Elem _ as :: [Attribute]
as _) <- [String] -> XMLParser (Element Posn)
element ["TVar"]
        ; Element Posn
-> Parser (Content Posn) TVar -> Parser (Content Posn) TVar
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (Parser (Content Posn) TVar -> Parser (Content Posn) TVar)
-> Parser (Content Posn) TVar -> Parser (Content Posn) TVar
forall a b. (a -> b) -> a -> b
$ ([Class] -> TVar) -> Parser (Content Posn) ([Class] -> TVar)
forall (m :: * -> *) a. Monad m => a -> m a
return (TVar_Attrs -> [Class] -> TVar
TVar ([Attribute] -> TVar_Attrs
forall a. XmlAttributes a => [Attribute] -> a
fromAttrs [Attribute]
as))
                       Parser (Content Posn) ([Class] -> TVar)
-> Parser (Content Posn) [Class] -> Parser (Content Posn) TVar
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) Class -> Parser (Content Posn) [Class]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many Parser (Content Posn) Class
forall a. XmlContent a => XMLParser a
parseContents
        } Parser (Content Posn) TVar -> ShowS -> Parser (Content Posn) TVar
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <TVar>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)
instance XmlAttributes TVar_Attrs where
    fromAttrs :: [Attribute] -> TVar_Attrs
fromAttrs as :: [Attribute]
as =
        TVar_Attrs :: String -> Maybe String -> TVar_Attrs
TVar_Attrs
          { tVarName :: String
tVarName = (String -> Attribute -> Maybe String)
-> String -> String -> [Attribute] -> String
forall a.
(String -> Attribute -> Maybe a)
-> String -> String -> [Attribute] -> a
definiteA String -> Attribute -> Maybe String
fromAttrToStr "TVar" "name" [Attribute]
as
          , tVarIndex :: Maybe String
tVarIndex = (String -> Attribute -> Maybe String)
-> String -> [Attribute] -> Maybe String
forall a.
(String -> Attribute -> Maybe a)
-> String -> [Attribute] -> Maybe a
possibleA String -> Attribute -> Maybe String
fromAttrToStr "index" [Attribute]
as
          }
    toAttrs :: TVar_Attrs -> [Attribute]
toAttrs v :: TVar_Attrs
v = [Maybe Attribute] -> [Attribute]
forall a. [Maybe a] -> [a]
catMaybes 
        [ String -> String -> Maybe Attribute
toAttrFrStr "name" (TVar_Attrs -> String
tVarName TVar_Attrs
v)
        , (String -> String -> Maybe Attribute)
-> String -> Maybe String -> Maybe Attribute
forall a.
(String -> a -> Maybe Attribute)
-> String -> Maybe a -> Maybe Attribute
maybeToAttr String -> String -> Maybe Attribute
toAttrFrStr "index" (TVar_Attrs -> Maybe String
tVarIndex TVar_Attrs
v)
        ]

instance HTypeable TFree where
    toHType :: TFree -> HType
toHType _ = String -> [HType] -> [Constr] -> HType
Defined "TFree" [] []
instance XmlContent TFree where
    toContents :: TFree -> [Content ()]
toContents (TFree as :: TFree_Attrs
as a :: [Class]
a) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N "TFree") (TFree_Attrs -> [Attribute]
forall a. XmlAttributes a => a -> [Attribute]
toAttrs TFree_Attrs
as) ((Class -> [Content ()]) -> [Class] -> [Content ()]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap Class -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents [Class]
a)) ()]
    parseContents :: Parser (Content Posn) TFree
parseContents = do
        { e :: Element Posn
e@(Elem _ as :: [Attribute]
as _) <- [String] -> XMLParser (Element Posn)
element ["TFree"]
        ; Element Posn
-> Parser (Content Posn) TFree -> Parser (Content Posn) TFree
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (Parser (Content Posn) TFree -> Parser (Content Posn) TFree)
-> Parser (Content Posn) TFree -> Parser (Content Posn) TFree
forall a b. (a -> b) -> a -> b
$ ([Class] -> TFree) -> Parser (Content Posn) ([Class] -> TFree)
forall (m :: * -> *) a. Monad m => a -> m a
return (TFree_Attrs -> [Class] -> TFree
TFree ([Attribute] -> TFree_Attrs
forall a. XmlAttributes a => [Attribute] -> a
fromAttrs [Attribute]
as))
                       Parser (Content Posn) ([Class] -> TFree)
-> Parser (Content Posn) [Class] -> Parser (Content Posn) TFree
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) Class -> Parser (Content Posn) [Class]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many Parser (Content Posn) Class
forall a. XmlContent a => XMLParser a
parseContents
        } Parser (Content Posn) TFree -> ShowS -> Parser (Content Posn) TFree
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <TFree>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)
instance XmlAttributes TFree_Attrs where
    fromAttrs :: [Attribute] -> TFree_Attrs
fromAttrs as :: [Attribute]
as =
        TFree_Attrs :: String -> TFree_Attrs
TFree_Attrs
          { tFreeName :: String
tFreeName = (String -> Attribute -> Maybe String)
-> String -> String -> [Attribute] -> String
forall a.
(String -> Attribute -> Maybe a)
-> String -> String -> [Attribute] -> a
definiteA String -> Attribute -> Maybe String
fromAttrToStr "TFree" "name" [Attribute]
as
          }
    toAttrs :: TFree_Attrs -> [Attribute]
toAttrs v :: TFree_Attrs
v = [Maybe Attribute] -> [Attribute]
forall a. [Maybe a] -> [a]
catMaybes 
        [ String -> String -> Maybe Attribute
toAttrFrStr "name" (TFree_Attrs -> String
tFreeName TFree_Attrs
v)
        ]

instance HTypeable Type where
    toHType :: Type -> HType
toHType _ = String -> [HType] -> [Constr] -> HType
Defined "Type" [] []
instance XmlContent Type where
    toContents :: Type -> [Content ()]
toContents (Type as :: Type_Attrs
as a :: [OneOf3 TVar TFree Type]
a) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N "Type") (Type_Attrs -> [Attribute]
forall a. XmlAttributes a => a -> [Attribute]
toAttrs Type_Attrs
as) ((OneOf3 TVar TFree Type -> [Content ()])
-> [OneOf3 TVar TFree Type] -> [Content ()]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap OneOf3 TVar TFree Type -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents [OneOf3 TVar TFree Type]
a)) ()]
    parseContents :: Parser (Content Posn) Type
parseContents = do
        { e :: Element Posn
e@(Elem _ as :: [Attribute]
as _) <- [String] -> XMLParser (Element Posn)
element ["Type"]
        ; Element Posn
-> Parser (Content Posn) Type -> Parser (Content Posn) Type
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (Parser (Content Posn) Type -> Parser (Content Posn) Type)
-> Parser (Content Posn) Type -> Parser (Content Posn) Type
forall a b. (a -> b) -> a -> b
$ ([OneOf3 TVar TFree Type] -> Type)
-> Parser (Content Posn) ([OneOf3 TVar TFree Type] -> Type)
forall (m :: * -> *) a. Monad m => a -> m a
return (Type_Attrs -> [OneOf3 TVar TFree Type] -> Type
Type ([Attribute] -> Type_Attrs
forall a. XmlAttributes a => [Attribute] -> a
fromAttrs [Attribute]
as))
                       Parser (Content Posn) ([OneOf3 TVar TFree Type] -> Type)
-> Parser (Content Posn) [OneOf3 TVar TFree Type]
-> Parser (Content Posn) Type
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) (OneOf3 TVar TFree Type)
-> Parser (Content Posn) [OneOf3 TVar TFree Type]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many Parser (Content Posn) (OneOf3 TVar TFree Type)
forall a. XmlContent a => XMLParser a
parseContents
        } Parser (Content Posn) Type -> ShowS -> Parser (Content Posn) Type
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <Type>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)
instance XmlAttributes Type_Attrs where
    fromAttrs :: [Attribute] -> Type_Attrs
fromAttrs as :: [Attribute]
as =
        Type_Attrs :: String -> Type_Attrs
Type_Attrs
          { typeName :: String
typeName = (String -> Attribute -> Maybe String)
-> String -> String -> [Attribute] -> String
forall a.
(String -> Attribute -> Maybe a)
-> String -> String -> [Attribute] -> a
definiteA String -> Attribute -> Maybe String
fromAttrToStr "Type" "name" [Attribute]
as
          }
    toAttrs :: Type_Attrs -> [Attribute]
toAttrs v :: Type_Attrs
v = [Maybe Attribute] -> [Attribute]
forall a. [Maybe a] -> [a]
catMaybes 
        [ String -> String -> Maybe Attribute
toAttrFrStr "name" (Type_Attrs -> String
typeName Type_Attrs
v)
        ]

instance HTypeable Class where
    toHType :: Class -> HType
toHType _ = String -> [HType] -> [Constr] -> HType
Defined "class" [] []
instance XmlContent Class where
    toContents :: Class -> [Content ()]
toContents as :: Class
as =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N "class") (Class -> [Attribute]
forall a. XmlAttributes a => a -> [Attribute]
toAttrs Class
as) []) ()]
    parseContents :: Parser (Content Posn) Class
parseContents = do
        { (Elem _ as :: [Attribute]
as []) <- [String] -> XMLParser (Element Posn)
element ["class"]
        ; Class -> Parser (Content Posn) Class
forall (m :: * -> *) a. Monad m => a -> m a
return ([Attribute] -> Class
forall a. XmlAttributes a => [Attribute] -> a
fromAttrs [Attribute]
as)
        } Parser (Content Posn) Class -> ShowS -> Parser (Content Posn) Class
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <class>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)
instance XmlAttributes Class where
    fromAttrs :: [Attribute] -> Class
fromAttrs as :: [Attribute]
as =
        Class :: String -> Class
Class
          { className :: String
className = (String -> Attribute -> Maybe String)
-> String -> String -> [Attribute] -> String
forall a.
(String -> Attribute -> Maybe a)
-> String -> String -> [Attribute] -> a
definiteA String -> Attribute -> Maybe String
fromAttrToStr "class" "name" [Attribute]
as
          }
    toAttrs :: Class -> [Attribute]
toAttrs v :: Class
v = [Maybe Attribute] -> [Attribute]
forall a. [Maybe a] -> [a]
catMaybes 
        [ String -> String -> Maybe Attribute
toAttrFrStr "name" (Class -> String
className Class
v)
        ]



{-Done-}