-- | A partial XML Schema model, focusing on datatypes. All simple datatypes (i.e. xsd:anySimpleType and below) are included.
-- | See: https://www.w3.org/TR/xmlschema-2
-- | Note: for most of the XML Schema datatype definitions included here, the associated Hydra type is simply
-- |       the string type. Exceptions are made for xsd:boolean and most of the numeric types, where there is a clearly
-- |       corresponding Hydra literal type.

module Hydra.Langs.Xml.Schema where

import qualified Hydra.Core as Core
import Data.Int
import Data.List as L
import Data.Map as M
import Data.Set as S

newtype AnySimpleType = 
  AnySimpleType {
    AnySimpleType -> String
unAnySimpleType :: String}
  deriving (AnySimpleType -> AnySimpleType -> Bool
(AnySimpleType -> AnySimpleType -> Bool)
-> (AnySimpleType -> AnySimpleType -> Bool) -> Eq AnySimpleType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AnySimpleType -> AnySimpleType -> Bool
== :: AnySimpleType -> AnySimpleType -> Bool
$c/= :: AnySimpleType -> AnySimpleType -> Bool
/= :: AnySimpleType -> AnySimpleType -> Bool
Eq, Eq AnySimpleType
Eq AnySimpleType =>
(AnySimpleType -> AnySimpleType -> Ordering)
-> (AnySimpleType -> AnySimpleType -> Bool)
-> (AnySimpleType -> AnySimpleType -> Bool)
-> (AnySimpleType -> AnySimpleType -> Bool)
-> (AnySimpleType -> AnySimpleType -> Bool)
-> (AnySimpleType -> AnySimpleType -> AnySimpleType)
-> (AnySimpleType -> AnySimpleType -> AnySimpleType)
-> Ord AnySimpleType
AnySimpleType -> AnySimpleType -> Bool
AnySimpleType -> AnySimpleType -> Ordering
AnySimpleType -> AnySimpleType -> AnySimpleType
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: AnySimpleType -> AnySimpleType -> Ordering
compare :: AnySimpleType -> AnySimpleType -> Ordering
$c< :: AnySimpleType -> AnySimpleType -> Bool
< :: AnySimpleType -> AnySimpleType -> Bool
$c<= :: AnySimpleType -> AnySimpleType -> Bool
<= :: AnySimpleType -> AnySimpleType -> Bool
$c> :: AnySimpleType -> AnySimpleType -> Bool
> :: AnySimpleType -> AnySimpleType -> Bool
$c>= :: AnySimpleType -> AnySimpleType -> Bool
>= :: AnySimpleType -> AnySimpleType -> Bool
$cmax :: AnySimpleType -> AnySimpleType -> AnySimpleType
max :: AnySimpleType -> AnySimpleType -> AnySimpleType
$cmin :: AnySimpleType -> AnySimpleType -> AnySimpleType
min :: AnySimpleType -> AnySimpleType -> AnySimpleType
Ord, ReadPrec [AnySimpleType]
ReadPrec AnySimpleType
Int -> ReadS AnySimpleType
ReadS [AnySimpleType]
(Int -> ReadS AnySimpleType)
-> ReadS [AnySimpleType]
-> ReadPrec AnySimpleType
-> ReadPrec [AnySimpleType]
-> Read AnySimpleType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS AnySimpleType
readsPrec :: Int -> ReadS AnySimpleType
$creadList :: ReadS [AnySimpleType]
readList :: ReadS [AnySimpleType]
$creadPrec :: ReadPrec AnySimpleType
readPrec :: ReadPrec AnySimpleType
$creadListPrec :: ReadPrec [AnySimpleType]
readListPrec :: ReadPrec [AnySimpleType]
Read, Int -> AnySimpleType -> String -> String
[AnySimpleType] -> String -> String
AnySimpleType -> String
(Int -> AnySimpleType -> String -> String)
-> (AnySimpleType -> String)
-> ([AnySimpleType] -> String -> String)
-> Show AnySimpleType
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> AnySimpleType -> String -> String
showsPrec :: Int -> AnySimpleType -> String -> String
$cshow :: AnySimpleType -> String
show :: AnySimpleType -> String
$cshowList :: [AnySimpleType] -> String -> String
showList :: [AnySimpleType] -> String -> String
Show)

_AnySimpleType :: Name
_AnySimpleType = (String -> Name
Core.Name String
"hydra/langs/xml/schema.AnySimpleType")

newtype AnyType = 
  AnyType {
    AnyType -> String
unAnyType :: String}
  deriving (AnyType -> AnyType -> Bool
(AnyType -> AnyType -> Bool)
-> (AnyType -> AnyType -> Bool) -> Eq AnyType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AnyType -> AnyType -> Bool
== :: AnyType -> AnyType -> Bool
$c/= :: AnyType -> AnyType -> Bool
/= :: AnyType -> AnyType -> Bool
Eq, Eq AnyType
Eq AnyType =>
(AnyType -> AnyType -> Ordering)
-> (AnyType -> AnyType -> Bool)
-> (AnyType -> AnyType -> Bool)
-> (AnyType -> AnyType -> Bool)
-> (AnyType -> AnyType -> Bool)
-> (AnyType -> AnyType -> AnyType)
-> (AnyType -> AnyType -> AnyType)
-> Ord AnyType
AnyType -> AnyType -> Bool
AnyType -> AnyType -> Ordering
AnyType -> AnyType -> AnyType
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: AnyType -> AnyType -> Ordering
compare :: AnyType -> AnyType -> Ordering
$c< :: AnyType -> AnyType -> Bool
< :: AnyType -> AnyType -> Bool
$c<= :: AnyType -> AnyType -> Bool
<= :: AnyType -> AnyType -> Bool
$c> :: AnyType -> AnyType -> Bool
> :: AnyType -> AnyType -> Bool
$c>= :: AnyType -> AnyType -> Bool
>= :: AnyType -> AnyType -> Bool
$cmax :: AnyType -> AnyType -> AnyType
max :: AnyType -> AnyType -> AnyType
$cmin :: AnyType -> AnyType -> AnyType
min :: AnyType -> AnyType -> AnyType
Ord, ReadPrec [AnyType]
ReadPrec AnyType
Int -> ReadS AnyType
ReadS [AnyType]
(Int -> ReadS AnyType)
-> ReadS [AnyType]
-> ReadPrec AnyType
-> ReadPrec [AnyType]
-> Read AnyType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS AnyType
readsPrec :: Int -> ReadS AnyType
$creadList :: ReadS [AnyType]
readList :: ReadS [AnyType]
$creadPrec :: ReadPrec AnyType
readPrec :: ReadPrec AnyType
$creadListPrec :: ReadPrec [AnyType]
readListPrec :: ReadPrec [AnyType]
Read, Int -> AnyType -> String -> String
[AnyType] -> String -> String
AnyType -> String
(Int -> AnyType -> String -> String)
-> (AnyType -> String)
-> ([AnyType] -> String -> String)
-> Show AnyType
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> AnyType -> String -> String
showsPrec :: Int -> AnyType -> String -> String
$cshow :: AnyType -> String
show :: AnyType -> String
$cshowList :: [AnyType] -> String -> String
showList :: [AnyType] -> String -> String
Show)

_AnyType :: Name
_AnyType = (String -> Name
Core.Name String
"hydra/langs/xml/schema.AnyType")

newtype AnyURI = 
  AnyURI {
    AnyURI -> String
unAnyURI :: String}
  deriving (AnyURI -> AnyURI -> Bool
(AnyURI -> AnyURI -> Bool)
-> (AnyURI -> AnyURI -> Bool) -> Eq AnyURI
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AnyURI -> AnyURI -> Bool
== :: AnyURI -> AnyURI -> Bool
$c/= :: AnyURI -> AnyURI -> Bool
/= :: AnyURI -> AnyURI -> Bool
Eq, Eq AnyURI
Eq AnyURI =>
(AnyURI -> AnyURI -> Ordering)
-> (AnyURI -> AnyURI -> Bool)
-> (AnyURI -> AnyURI -> Bool)
-> (AnyURI -> AnyURI -> Bool)
-> (AnyURI -> AnyURI -> Bool)
-> (AnyURI -> AnyURI -> AnyURI)
-> (AnyURI -> AnyURI -> AnyURI)
-> Ord AnyURI
AnyURI -> AnyURI -> Bool
AnyURI -> AnyURI -> Ordering
AnyURI -> AnyURI -> AnyURI
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: AnyURI -> AnyURI -> Ordering
compare :: AnyURI -> AnyURI -> Ordering
$c< :: AnyURI -> AnyURI -> Bool
< :: AnyURI -> AnyURI -> Bool
$c<= :: AnyURI -> AnyURI -> Bool
<= :: AnyURI -> AnyURI -> Bool
$c> :: AnyURI -> AnyURI -> Bool
> :: AnyURI -> AnyURI -> Bool
$c>= :: AnyURI -> AnyURI -> Bool
>= :: AnyURI -> AnyURI -> Bool
$cmax :: AnyURI -> AnyURI -> AnyURI
max :: AnyURI -> AnyURI -> AnyURI
$cmin :: AnyURI -> AnyURI -> AnyURI
min :: AnyURI -> AnyURI -> AnyURI
Ord, ReadPrec [AnyURI]
ReadPrec AnyURI
Int -> ReadS AnyURI
ReadS [AnyURI]
(Int -> ReadS AnyURI)
-> ReadS [AnyURI]
-> ReadPrec AnyURI
-> ReadPrec [AnyURI]
-> Read AnyURI
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS AnyURI
readsPrec :: Int -> ReadS AnyURI
$creadList :: ReadS [AnyURI]
readList :: ReadS [AnyURI]
$creadPrec :: ReadPrec AnyURI
readPrec :: ReadPrec AnyURI
$creadListPrec :: ReadPrec [AnyURI]
readListPrec :: ReadPrec [AnyURI]
Read, Int -> AnyURI -> String -> String
[AnyURI] -> String -> String
AnyURI -> String
(Int -> AnyURI -> String -> String)
-> (AnyURI -> String)
-> ([AnyURI] -> String -> String)
-> Show AnyURI
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> AnyURI -> String -> String
showsPrec :: Int -> AnyURI -> String -> String
$cshow :: AnyURI -> String
show :: AnyURI -> String
$cshowList :: [AnyURI] -> String -> String
showList :: [AnyURI] -> String -> String
Show)

_AnyURI :: Name
_AnyURI = (String -> Name
Core.Name String
"hydra/langs/xml/schema.AnyURI")

newtype Base64Binary = 
  Base64Binary {
    Base64Binary -> String
unBase64Binary :: String}
  deriving (Base64Binary -> Base64Binary -> Bool
(Base64Binary -> Base64Binary -> Bool)
-> (Base64Binary -> Base64Binary -> Bool) -> Eq Base64Binary
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Base64Binary -> Base64Binary -> Bool
== :: Base64Binary -> Base64Binary -> Bool
$c/= :: Base64Binary -> Base64Binary -> Bool
/= :: Base64Binary -> Base64Binary -> Bool
Eq, Eq Base64Binary
Eq Base64Binary =>
(Base64Binary -> Base64Binary -> Ordering)
-> (Base64Binary -> Base64Binary -> Bool)
-> (Base64Binary -> Base64Binary -> Bool)
-> (Base64Binary -> Base64Binary -> Bool)
-> (Base64Binary -> Base64Binary -> Bool)
-> (Base64Binary -> Base64Binary -> Base64Binary)
-> (Base64Binary -> Base64Binary -> Base64Binary)
-> Ord Base64Binary
Base64Binary -> Base64Binary -> Bool
Base64Binary -> Base64Binary -> Ordering
Base64Binary -> Base64Binary -> Base64Binary
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Base64Binary -> Base64Binary -> Ordering
compare :: Base64Binary -> Base64Binary -> Ordering
$c< :: Base64Binary -> Base64Binary -> Bool
< :: Base64Binary -> Base64Binary -> Bool
$c<= :: Base64Binary -> Base64Binary -> Bool
<= :: Base64Binary -> Base64Binary -> Bool
$c> :: Base64Binary -> Base64Binary -> Bool
> :: Base64Binary -> Base64Binary -> Bool
$c>= :: Base64Binary -> Base64Binary -> Bool
>= :: Base64Binary -> Base64Binary -> Bool
$cmax :: Base64Binary -> Base64Binary -> Base64Binary
max :: Base64Binary -> Base64Binary -> Base64Binary
$cmin :: Base64Binary -> Base64Binary -> Base64Binary
min :: Base64Binary -> Base64Binary -> Base64Binary
Ord, ReadPrec [Base64Binary]
ReadPrec Base64Binary
Int -> ReadS Base64Binary
ReadS [Base64Binary]
(Int -> ReadS Base64Binary)
-> ReadS [Base64Binary]
-> ReadPrec Base64Binary
-> ReadPrec [Base64Binary]
-> Read Base64Binary
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Base64Binary
readsPrec :: Int -> ReadS Base64Binary
$creadList :: ReadS [Base64Binary]
readList :: ReadS [Base64Binary]
$creadPrec :: ReadPrec Base64Binary
readPrec :: ReadPrec Base64Binary
$creadListPrec :: ReadPrec [Base64Binary]
readListPrec :: ReadPrec [Base64Binary]
Read, Int -> Base64Binary -> String -> String
[Base64Binary] -> String -> String
Base64Binary -> String
(Int -> Base64Binary -> String -> String)
-> (Base64Binary -> String)
-> ([Base64Binary] -> String -> String)
-> Show Base64Binary
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Base64Binary -> String -> String
showsPrec :: Int -> Base64Binary -> String -> String
$cshow :: Base64Binary -> String
show :: Base64Binary -> String
$cshowList :: [Base64Binary] -> String -> String
showList :: [Base64Binary] -> String -> String
Show)

_Base64Binary :: Name
_Base64Binary = (String -> Name
Core.Name String
"hydra/langs/xml/schema.Base64Binary")

newtype Boolean = 
  Boolean {
    Boolean -> Bool
unBoolean :: Bool}
  deriving (Boolean -> Boolean -> Bool
(Boolean -> Boolean -> Bool)
-> (Boolean -> Boolean -> Bool) -> Eq Boolean
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Boolean -> Boolean -> Bool
== :: Boolean -> Boolean -> Bool
$c/= :: Boolean -> Boolean -> Bool
/= :: Boolean -> Boolean -> Bool
Eq, Eq Boolean
Eq Boolean =>
(Boolean -> Boolean -> Ordering)
-> (Boolean -> Boolean -> Bool)
-> (Boolean -> Boolean -> Bool)
-> (Boolean -> Boolean -> Bool)
-> (Boolean -> Boolean -> Bool)
-> (Boolean -> Boolean -> Boolean)
-> (Boolean -> Boolean -> Boolean)
-> Ord Boolean
Boolean -> Boolean -> Bool
Boolean -> Boolean -> Ordering
Boolean -> Boolean -> Boolean
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Boolean -> Boolean -> Ordering
compare :: Boolean -> Boolean -> Ordering
$c< :: Boolean -> Boolean -> Bool
< :: Boolean -> Boolean -> Bool
$c<= :: Boolean -> Boolean -> Bool
<= :: Boolean -> Boolean -> Bool
$c> :: Boolean -> Boolean -> Bool
> :: Boolean -> Boolean -> Bool
$c>= :: Boolean -> Boolean -> Bool
>= :: Boolean -> Boolean -> Bool
$cmax :: Boolean -> Boolean -> Boolean
max :: Boolean -> Boolean -> Boolean
$cmin :: Boolean -> Boolean -> Boolean
min :: Boolean -> Boolean -> Boolean
Ord, ReadPrec [Boolean]
ReadPrec Boolean
Int -> ReadS Boolean
ReadS [Boolean]
(Int -> ReadS Boolean)
-> ReadS [Boolean]
-> ReadPrec Boolean
-> ReadPrec [Boolean]
-> Read Boolean
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Boolean
readsPrec :: Int -> ReadS Boolean
$creadList :: ReadS [Boolean]
readList :: ReadS [Boolean]
$creadPrec :: ReadPrec Boolean
readPrec :: ReadPrec Boolean
$creadListPrec :: ReadPrec [Boolean]
readListPrec :: ReadPrec [Boolean]
Read, Int -> Boolean -> String -> String
[Boolean] -> String -> String
Boolean -> String
(Int -> Boolean -> String -> String)
-> (Boolean -> String)
-> ([Boolean] -> String -> String)
-> Show Boolean
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Boolean -> String -> String
showsPrec :: Int -> Boolean -> String -> String
$cshow :: Boolean -> String
show :: Boolean -> String
$cshowList :: [Boolean] -> String -> String
showList :: [Boolean] -> String -> String
Show)

_Boolean :: Name
_Boolean = (String -> Name
Core.Name String
"hydra/langs/xml/schema.Boolean")

newtype Byte = 
  Byte {
    Byte -> Int8
unByte :: Int8}
  deriving (Byte -> Byte -> Bool
(Byte -> Byte -> Bool) -> (Byte -> Byte -> Bool) -> Eq Byte
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Byte -> Byte -> Bool
== :: Byte -> Byte -> Bool
$c/= :: Byte -> Byte -> Bool
/= :: Byte -> Byte -> Bool
Eq, Eq Byte
Eq Byte =>
(Byte -> Byte -> Ordering)
-> (Byte -> Byte -> Bool)
-> (Byte -> Byte -> Bool)
-> (Byte -> Byte -> Bool)
-> (Byte -> Byte -> Bool)
-> (Byte -> Byte -> Byte)
-> (Byte -> Byte -> Byte)
-> Ord Byte
Byte -> Byte -> Bool
Byte -> Byte -> Ordering
Byte -> Byte -> Byte
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Byte -> Byte -> Ordering
compare :: Byte -> Byte -> Ordering
$c< :: Byte -> Byte -> Bool
< :: Byte -> Byte -> Bool
$c<= :: Byte -> Byte -> Bool
<= :: Byte -> Byte -> Bool
$c> :: Byte -> Byte -> Bool
> :: Byte -> Byte -> Bool
$c>= :: Byte -> Byte -> Bool
>= :: Byte -> Byte -> Bool
$cmax :: Byte -> Byte -> Byte
max :: Byte -> Byte -> Byte
$cmin :: Byte -> Byte -> Byte
min :: Byte -> Byte -> Byte
Ord, ReadPrec [Byte]
ReadPrec Byte
Int -> ReadS Byte
ReadS [Byte]
(Int -> ReadS Byte)
-> ReadS [Byte] -> ReadPrec Byte -> ReadPrec [Byte] -> Read Byte
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Byte
readsPrec :: Int -> ReadS Byte
$creadList :: ReadS [Byte]
readList :: ReadS [Byte]
$creadPrec :: ReadPrec Byte
readPrec :: ReadPrec Byte
$creadListPrec :: ReadPrec [Byte]
readListPrec :: ReadPrec [Byte]
Read, Int -> Byte -> String -> String
[Byte] -> String -> String
Byte -> String
(Int -> Byte -> String -> String)
-> (Byte -> String) -> ([Byte] -> String -> String) -> Show Byte
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Byte -> String -> String
showsPrec :: Int -> Byte -> String -> String
$cshow :: Byte -> String
show :: Byte -> String
$cshowList :: [Byte] -> String -> String
showList :: [Byte] -> String -> String
Show)

_Byte :: Name
_Byte = (String -> Name
Core.Name String
"hydra/langs/xml/schema.Byte")

newtype Date = 
  Date {
    Date -> String
unDate :: String}
  deriving (Date -> Date -> Bool
(Date -> Date -> Bool) -> (Date -> Date -> Bool) -> Eq Date
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Date -> Date -> Bool
== :: Date -> Date -> Bool
$c/= :: Date -> Date -> Bool
/= :: Date -> Date -> Bool
Eq, Eq Date
Eq Date =>
(Date -> Date -> Ordering)
-> (Date -> Date -> Bool)
-> (Date -> Date -> Bool)
-> (Date -> Date -> Bool)
-> (Date -> Date -> Bool)
-> (Date -> Date -> Date)
-> (Date -> Date -> Date)
-> Ord Date
Date -> Date -> Bool
Date -> Date -> Ordering
Date -> Date -> Date
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Date -> Date -> Ordering
compare :: Date -> Date -> Ordering
$c< :: Date -> Date -> Bool
< :: Date -> Date -> Bool
$c<= :: Date -> Date -> Bool
<= :: Date -> Date -> Bool
$c> :: Date -> Date -> Bool
> :: Date -> Date -> Bool
$c>= :: Date -> Date -> Bool
>= :: Date -> Date -> Bool
$cmax :: Date -> Date -> Date
max :: Date -> Date -> Date
$cmin :: Date -> Date -> Date
min :: Date -> Date -> Date
Ord, ReadPrec [Date]
ReadPrec Date
Int -> ReadS Date
ReadS [Date]
(Int -> ReadS Date)
-> ReadS [Date] -> ReadPrec Date -> ReadPrec [Date] -> Read Date
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Date
readsPrec :: Int -> ReadS Date
$creadList :: ReadS [Date]
readList :: ReadS [Date]
$creadPrec :: ReadPrec Date
readPrec :: ReadPrec Date
$creadListPrec :: ReadPrec [Date]
readListPrec :: ReadPrec [Date]
Read, Int -> Date -> String -> String
[Date] -> String -> String
Date -> String
(Int -> Date -> String -> String)
-> (Date -> String) -> ([Date] -> String -> String) -> Show Date
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Date -> String -> String
showsPrec :: Int -> Date -> String -> String
$cshow :: Date -> String
show :: Date -> String
$cshowList :: [Date] -> String -> String
showList :: [Date] -> String -> String
Show)

_Date :: Name
_Date = (String -> Name
Core.Name String
"hydra/langs/xml/schema.Date")

newtype DateTime = 
  DateTime {
    DateTime -> String
unDateTime :: String}
  deriving (DateTime -> DateTime -> Bool
(DateTime -> DateTime -> Bool)
-> (DateTime -> DateTime -> Bool) -> Eq DateTime
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DateTime -> DateTime -> Bool
== :: DateTime -> DateTime -> Bool
$c/= :: DateTime -> DateTime -> Bool
/= :: DateTime -> DateTime -> Bool
Eq, Eq DateTime
Eq DateTime =>
(DateTime -> DateTime -> Ordering)
-> (DateTime -> DateTime -> Bool)
-> (DateTime -> DateTime -> Bool)
-> (DateTime -> DateTime -> Bool)
-> (DateTime -> DateTime -> Bool)
-> (DateTime -> DateTime -> DateTime)
-> (DateTime -> DateTime -> DateTime)
-> Ord DateTime
DateTime -> DateTime -> Bool
DateTime -> DateTime -> Ordering
DateTime -> DateTime -> DateTime
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: DateTime -> DateTime -> Ordering
compare :: DateTime -> DateTime -> Ordering
$c< :: DateTime -> DateTime -> Bool
< :: DateTime -> DateTime -> Bool
$c<= :: DateTime -> DateTime -> Bool
<= :: DateTime -> DateTime -> Bool
$c> :: DateTime -> DateTime -> Bool
> :: DateTime -> DateTime -> Bool
$c>= :: DateTime -> DateTime -> Bool
>= :: DateTime -> DateTime -> Bool
$cmax :: DateTime -> DateTime -> DateTime
max :: DateTime -> DateTime -> DateTime
$cmin :: DateTime -> DateTime -> DateTime
min :: DateTime -> DateTime -> DateTime
Ord, ReadPrec [DateTime]
ReadPrec DateTime
Int -> ReadS DateTime
ReadS [DateTime]
(Int -> ReadS DateTime)
-> ReadS [DateTime]
-> ReadPrec DateTime
-> ReadPrec [DateTime]
-> Read DateTime
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS DateTime
readsPrec :: Int -> ReadS DateTime
$creadList :: ReadS [DateTime]
readList :: ReadS [DateTime]
$creadPrec :: ReadPrec DateTime
readPrec :: ReadPrec DateTime
$creadListPrec :: ReadPrec [DateTime]
readListPrec :: ReadPrec [DateTime]
Read, Int -> DateTime -> String -> String
[DateTime] -> String -> String
DateTime -> String
(Int -> DateTime -> String -> String)
-> (DateTime -> String)
-> ([DateTime] -> String -> String)
-> Show DateTime
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> DateTime -> String -> String
showsPrec :: Int -> DateTime -> String -> String
$cshow :: DateTime -> String
show :: DateTime -> String
$cshowList :: [DateTime] -> String -> String
showList :: [DateTime] -> String -> String
Show)

_DateTime :: Name
_DateTime = (String -> Name
Core.Name String
"hydra/langs/xml/schema.DateTime")

newtype Decimal = 
  Decimal {
    Decimal -> String
unDecimal :: String}
  deriving (Decimal -> Decimal -> Bool
(Decimal -> Decimal -> Bool)
-> (Decimal -> Decimal -> Bool) -> Eq Decimal
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Decimal -> Decimal -> Bool
== :: Decimal -> Decimal -> Bool
$c/= :: Decimal -> Decimal -> Bool
/= :: Decimal -> Decimal -> Bool
Eq, Eq Decimal
Eq Decimal =>
(Decimal -> Decimal -> Ordering)
-> (Decimal -> Decimal -> Bool)
-> (Decimal -> Decimal -> Bool)
-> (Decimal -> Decimal -> Bool)
-> (Decimal -> Decimal -> Bool)
-> (Decimal -> Decimal -> Decimal)
-> (Decimal -> Decimal -> Decimal)
-> Ord Decimal
Decimal -> Decimal -> Bool
Decimal -> Decimal -> Ordering
Decimal -> Decimal -> Decimal
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Decimal -> Decimal -> Ordering
compare :: Decimal -> Decimal -> Ordering
$c< :: Decimal -> Decimal -> Bool
< :: Decimal -> Decimal -> Bool
$c<= :: Decimal -> Decimal -> Bool
<= :: Decimal -> Decimal -> Bool
$c> :: Decimal -> Decimal -> Bool
> :: Decimal -> Decimal -> Bool
$c>= :: Decimal -> Decimal -> Bool
>= :: Decimal -> Decimal -> Bool
$cmax :: Decimal -> Decimal -> Decimal
max :: Decimal -> Decimal -> Decimal
$cmin :: Decimal -> Decimal -> Decimal
min :: Decimal -> Decimal -> Decimal
Ord, ReadPrec [Decimal]
ReadPrec Decimal
Int -> ReadS Decimal
ReadS [Decimal]
(Int -> ReadS Decimal)
-> ReadS [Decimal]
-> ReadPrec Decimal
-> ReadPrec [Decimal]
-> Read Decimal
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Decimal
readsPrec :: Int -> ReadS Decimal
$creadList :: ReadS [Decimal]
readList :: ReadS [Decimal]
$creadPrec :: ReadPrec Decimal
readPrec :: ReadPrec Decimal
$creadListPrec :: ReadPrec [Decimal]
readListPrec :: ReadPrec [Decimal]
Read, Int -> Decimal -> String -> String
[Decimal] -> String -> String
Decimal -> String
(Int -> Decimal -> String -> String)
-> (Decimal -> String)
-> ([Decimal] -> String -> String)
-> Show Decimal
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Decimal -> String -> String
showsPrec :: Int -> Decimal -> String -> String
$cshow :: Decimal -> String
show :: Decimal -> String
$cshowList :: [Decimal] -> String -> String
showList :: [Decimal] -> String -> String
Show)

_Decimal :: Name
_Decimal = (String -> Name
Core.Name String
"hydra/langs/xml/schema.Decimal")

newtype Double_ = 
  Double_ {
    Double_ -> Double
unDouble :: Double}
  deriving (Double_ -> Double_ -> Bool
(Double_ -> Double_ -> Bool)
-> (Double_ -> Double_ -> Bool) -> Eq Double_
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Double_ -> Double_ -> Bool
== :: Double_ -> Double_ -> Bool
$c/= :: Double_ -> Double_ -> Bool
/= :: Double_ -> Double_ -> Bool
Eq, Eq Double_
Eq Double_ =>
(Double_ -> Double_ -> Ordering)
-> (Double_ -> Double_ -> Bool)
-> (Double_ -> Double_ -> Bool)
-> (Double_ -> Double_ -> Bool)
-> (Double_ -> Double_ -> Bool)
-> (Double_ -> Double_ -> Double_)
-> (Double_ -> Double_ -> Double_)
-> Ord Double_
Double_ -> Double_ -> Bool
Double_ -> Double_ -> Ordering
Double_ -> Double_ -> Double_
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Double_ -> Double_ -> Ordering
compare :: Double_ -> Double_ -> Ordering
$c< :: Double_ -> Double_ -> Bool
< :: Double_ -> Double_ -> Bool
$c<= :: Double_ -> Double_ -> Bool
<= :: Double_ -> Double_ -> Bool
$c> :: Double_ -> Double_ -> Bool
> :: Double_ -> Double_ -> Bool
$c>= :: Double_ -> Double_ -> Bool
>= :: Double_ -> Double_ -> Bool
$cmax :: Double_ -> Double_ -> Double_
max :: Double_ -> Double_ -> Double_
$cmin :: Double_ -> Double_ -> Double_
min :: Double_ -> Double_ -> Double_
Ord, ReadPrec [Double_]
ReadPrec Double_
Int -> ReadS Double_
ReadS [Double_]
(Int -> ReadS Double_)
-> ReadS [Double_]
-> ReadPrec Double_
-> ReadPrec [Double_]
-> Read Double_
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Double_
readsPrec :: Int -> ReadS Double_
$creadList :: ReadS [Double_]
readList :: ReadS [Double_]
$creadPrec :: ReadPrec Double_
readPrec :: ReadPrec Double_
$creadListPrec :: ReadPrec [Double_]
readListPrec :: ReadPrec [Double_]
Read, Int -> Double_ -> String -> String
[Double_] -> String -> String
Double_ -> String
(Int -> Double_ -> String -> String)
-> (Double_ -> String)
-> ([Double_] -> String -> String)
-> Show Double_
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Double_ -> String -> String
showsPrec :: Int -> Double_ -> String -> String
$cshow :: Double_ -> String
show :: Double_ -> String
$cshowList :: [Double_] -> String -> String
showList :: [Double_] -> String -> String
Show)

_Double :: Name
_Double = (String -> Name
Core.Name String
"hydra/langs/xml/schema.Double")

newtype Duration = 
  Duration {
    Duration -> String
unDuration :: String}
  deriving (Duration -> Duration -> Bool
(Duration -> Duration -> Bool)
-> (Duration -> Duration -> Bool) -> Eq Duration
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Duration -> Duration -> Bool
== :: Duration -> Duration -> Bool
$c/= :: Duration -> Duration -> Bool
/= :: Duration -> Duration -> Bool
Eq, Eq Duration
Eq Duration =>
(Duration -> Duration -> Ordering)
-> (Duration -> Duration -> Bool)
-> (Duration -> Duration -> Bool)
-> (Duration -> Duration -> Bool)
-> (Duration -> Duration -> Bool)
-> (Duration -> Duration -> Duration)
-> (Duration -> Duration -> Duration)
-> Ord Duration
Duration -> Duration -> Bool
Duration -> Duration -> Ordering
Duration -> Duration -> Duration
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Duration -> Duration -> Ordering
compare :: Duration -> Duration -> Ordering
$c< :: Duration -> Duration -> Bool
< :: Duration -> Duration -> Bool
$c<= :: Duration -> Duration -> Bool
<= :: Duration -> Duration -> Bool
$c> :: Duration -> Duration -> Bool
> :: Duration -> Duration -> Bool
$c>= :: Duration -> Duration -> Bool
>= :: Duration -> Duration -> Bool
$cmax :: Duration -> Duration -> Duration
max :: Duration -> Duration -> Duration
$cmin :: Duration -> Duration -> Duration
min :: Duration -> Duration -> Duration
Ord, ReadPrec [Duration]
ReadPrec Duration
Int -> ReadS Duration
ReadS [Duration]
(Int -> ReadS Duration)
-> ReadS [Duration]
-> ReadPrec Duration
-> ReadPrec [Duration]
-> Read Duration
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Duration
readsPrec :: Int -> ReadS Duration
$creadList :: ReadS [Duration]
readList :: ReadS [Duration]
$creadPrec :: ReadPrec Duration
readPrec :: ReadPrec Duration
$creadListPrec :: ReadPrec [Duration]
readListPrec :: ReadPrec [Duration]
Read, Int -> Duration -> String -> String
[Duration] -> String -> String
Duration -> String
(Int -> Duration -> String -> String)
-> (Duration -> String)
-> ([Duration] -> String -> String)
-> Show Duration
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Duration -> String -> String
showsPrec :: Int -> Duration -> String -> String
$cshow :: Duration -> String
show :: Duration -> String
$cshowList :: [Duration] -> String -> String
showList :: [Duration] -> String -> String
Show)

_Duration :: Name
_Duration = (String -> Name
Core.Name String
"hydra/langs/xml/schema.Duration")

newtype ENTITIES = 
  ENTITIES {
    ENTITIES -> String
unENTITIES :: String}
  deriving (ENTITIES -> ENTITIES -> Bool
(ENTITIES -> ENTITIES -> Bool)
-> (ENTITIES -> ENTITIES -> Bool) -> Eq ENTITIES
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ENTITIES -> ENTITIES -> Bool
== :: ENTITIES -> ENTITIES -> Bool
$c/= :: ENTITIES -> ENTITIES -> Bool
/= :: ENTITIES -> ENTITIES -> Bool
Eq, Eq ENTITIES
Eq ENTITIES =>
(ENTITIES -> ENTITIES -> Ordering)
-> (ENTITIES -> ENTITIES -> Bool)
-> (ENTITIES -> ENTITIES -> Bool)
-> (ENTITIES -> ENTITIES -> Bool)
-> (ENTITIES -> ENTITIES -> Bool)
-> (ENTITIES -> ENTITIES -> ENTITIES)
-> (ENTITIES -> ENTITIES -> ENTITIES)
-> Ord ENTITIES
ENTITIES -> ENTITIES -> Bool
ENTITIES -> ENTITIES -> Ordering
ENTITIES -> ENTITIES -> ENTITIES
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ENTITIES -> ENTITIES -> Ordering
compare :: ENTITIES -> ENTITIES -> Ordering
$c< :: ENTITIES -> ENTITIES -> Bool
< :: ENTITIES -> ENTITIES -> Bool
$c<= :: ENTITIES -> ENTITIES -> Bool
<= :: ENTITIES -> ENTITIES -> Bool
$c> :: ENTITIES -> ENTITIES -> Bool
> :: ENTITIES -> ENTITIES -> Bool
$c>= :: ENTITIES -> ENTITIES -> Bool
>= :: ENTITIES -> ENTITIES -> Bool
$cmax :: ENTITIES -> ENTITIES -> ENTITIES
max :: ENTITIES -> ENTITIES -> ENTITIES
$cmin :: ENTITIES -> ENTITIES -> ENTITIES
min :: ENTITIES -> ENTITIES -> ENTITIES
Ord, ReadPrec [ENTITIES]
ReadPrec ENTITIES
Int -> ReadS ENTITIES
ReadS [ENTITIES]
(Int -> ReadS ENTITIES)
-> ReadS [ENTITIES]
-> ReadPrec ENTITIES
-> ReadPrec [ENTITIES]
-> Read ENTITIES
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ENTITIES
readsPrec :: Int -> ReadS ENTITIES
$creadList :: ReadS [ENTITIES]
readList :: ReadS [ENTITIES]
$creadPrec :: ReadPrec ENTITIES
readPrec :: ReadPrec ENTITIES
$creadListPrec :: ReadPrec [ENTITIES]
readListPrec :: ReadPrec [ENTITIES]
Read, Int -> ENTITIES -> String -> String
[ENTITIES] -> String -> String
ENTITIES -> String
(Int -> ENTITIES -> String -> String)
-> (ENTITIES -> String)
-> ([ENTITIES] -> String -> String)
-> Show ENTITIES
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> ENTITIES -> String -> String
showsPrec :: Int -> ENTITIES -> String -> String
$cshow :: ENTITIES -> String
show :: ENTITIES -> String
$cshowList :: [ENTITIES] -> String -> String
showList :: [ENTITIES] -> String -> String
Show)

_ENTITIES :: Name
_ENTITIES = (String -> Name
Core.Name String
"hydra/langs/xml/schema.ENTITIES")

newtype ENTITY = 
  ENTITY {
    ENTITY -> String
unENTITY :: String}
  deriving (ENTITY -> ENTITY -> Bool
(ENTITY -> ENTITY -> Bool)
-> (ENTITY -> ENTITY -> Bool) -> Eq ENTITY
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ENTITY -> ENTITY -> Bool
== :: ENTITY -> ENTITY -> Bool
$c/= :: ENTITY -> ENTITY -> Bool
/= :: ENTITY -> ENTITY -> Bool
Eq, Eq ENTITY
Eq ENTITY =>
(ENTITY -> ENTITY -> Ordering)
-> (ENTITY -> ENTITY -> Bool)
-> (ENTITY -> ENTITY -> Bool)
-> (ENTITY -> ENTITY -> Bool)
-> (ENTITY -> ENTITY -> Bool)
-> (ENTITY -> ENTITY -> ENTITY)
-> (ENTITY -> ENTITY -> ENTITY)
-> Ord ENTITY
ENTITY -> ENTITY -> Bool
ENTITY -> ENTITY -> Ordering
ENTITY -> ENTITY -> ENTITY
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ENTITY -> ENTITY -> Ordering
compare :: ENTITY -> ENTITY -> Ordering
$c< :: ENTITY -> ENTITY -> Bool
< :: ENTITY -> ENTITY -> Bool
$c<= :: ENTITY -> ENTITY -> Bool
<= :: ENTITY -> ENTITY -> Bool
$c> :: ENTITY -> ENTITY -> Bool
> :: ENTITY -> ENTITY -> Bool
$c>= :: ENTITY -> ENTITY -> Bool
>= :: ENTITY -> ENTITY -> Bool
$cmax :: ENTITY -> ENTITY -> ENTITY
max :: ENTITY -> ENTITY -> ENTITY
$cmin :: ENTITY -> ENTITY -> ENTITY
min :: ENTITY -> ENTITY -> ENTITY
Ord, ReadPrec [ENTITY]
ReadPrec ENTITY
Int -> ReadS ENTITY
ReadS [ENTITY]
(Int -> ReadS ENTITY)
-> ReadS [ENTITY]
-> ReadPrec ENTITY
-> ReadPrec [ENTITY]
-> Read ENTITY
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ENTITY
readsPrec :: Int -> ReadS ENTITY
$creadList :: ReadS [ENTITY]
readList :: ReadS [ENTITY]
$creadPrec :: ReadPrec ENTITY
readPrec :: ReadPrec ENTITY
$creadListPrec :: ReadPrec [ENTITY]
readListPrec :: ReadPrec [ENTITY]
Read, Int -> ENTITY -> String -> String
[ENTITY] -> String -> String
ENTITY -> String
(Int -> ENTITY -> String -> String)
-> (ENTITY -> String)
-> ([ENTITY] -> String -> String)
-> Show ENTITY
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> ENTITY -> String -> String
showsPrec :: Int -> ENTITY -> String -> String
$cshow :: ENTITY -> String
show :: ENTITY -> String
$cshowList :: [ENTITY] -> String -> String
showList :: [ENTITY] -> String -> String
Show)

_ENTITY :: Name
_ENTITY = (String -> Name
Core.Name String
"hydra/langs/xml/schema.ENTITY")

newtype Float_ = 
  Float_ {
    Float_ -> Float
unFloat :: Float}
  deriving (Float_ -> Float_ -> Bool
(Float_ -> Float_ -> Bool)
-> (Float_ -> Float_ -> Bool) -> Eq Float_
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Float_ -> Float_ -> Bool
== :: Float_ -> Float_ -> Bool
$c/= :: Float_ -> Float_ -> Bool
/= :: Float_ -> Float_ -> Bool
Eq, Eq Float_
Eq Float_ =>
(Float_ -> Float_ -> Ordering)
-> (Float_ -> Float_ -> Bool)
-> (Float_ -> Float_ -> Bool)
-> (Float_ -> Float_ -> Bool)
-> (Float_ -> Float_ -> Bool)
-> (Float_ -> Float_ -> Float_)
-> (Float_ -> Float_ -> Float_)
-> Ord Float_
Float_ -> Float_ -> Bool
Float_ -> Float_ -> Ordering
Float_ -> Float_ -> Float_
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Float_ -> Float_ -> Ordering
compare :: Float_ -> Float_ -> Ordering
$c< :: Float_ -> Float_ -> Bool
< :: Float_ -> Float_ -> Bool
$c<= :: Float_ -> Float_ -> Bool
<= :: Float_ -> Float_ -> Bool
$c> :: Float_ -> Float_ -> Bool
> :: Float_ -> Float_ -> Bool
$c>= :: Float_ -> Float_ -> Bool
>= :: Float_ -> Float_ -> Bool
$cmax :: Float_ -> Float_ -> Float_
max :: Float_ -> Float_ -> Float_
$cmin :: Float_ -> Float_ -> Float_
min :: Float_ -> Float_ -> Float_
Ord, ReadPrec [Float_]
ReadPrec Float_
Int -> ReadS Float_
ReadS [Float_]
(Int -> ReadS Float_)
-> ReadS [Float_]
-> ReadPrec Float_
-> ReadPrec [Float_]
-> Read Float_
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Float_
readsPrec :: Int -> ReadS Float_
$creadList :: ReadS [Float_]
readList :: ReadS [Float_]
$creadPrec :: ReadPrec Float_
readPrec :: ReadPrec Float_
$creadListPrec :: ReadPrec [Float_]
readListPrec :: ReadPrec [Float_]
Read, Int -> Float_ -> String -> String
[Float_] -> String -> String
Float_ -> String
(Int -> Float_ -> String -> String)
-> (Float_ -> String)
-> ([Float_] -> String -> String)
-> Show Float_
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Float_ -> String -> String
showsPrec :: Int -> Float_ -> String -> String
$cshow :: Float_ -> String
show :: Float_ -> String
$cshowList :: [Float_] -> String -> String
showList :: [Float_] -> String -> String
Show)

_Float :: Name
_Float = (String -> Name
Core.Name String
"hydra/langs/xml/schema.Float")

newtype GDay = 
  GDay {
    GDay -> String
unGDay :: String}
  deriving (GDay -> GDay -> Bool
(GDay -> GDay -> Bool) -> (GDay -> GDay -> Bool) -> Eq GDay
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: GDay -> GDay -> Bool
== :: GDay -> GDay -> Bool
$c/= :: GDay -> GDay -> Bool
/= :: GDay -> GDay -> Bool
Eq, Eq GDay
Eq GDay =>
(GDay -> GDay -> Ordering)
-> (GDay -> GDay -> Bool)
-> (GDay -> GDay -> Bool)
-> (GDay -> GDay -> Bool)
-> (GDay -> GDay -> Bool)
-> (GDay -> GDay -> GDay)
-> (GDay -> GDay -> GDay)
-> Ord GDay
GDay -> GDay -> Bool
GDay -> GDay -> Ordering
GDay -> GDay -> GDay
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: GDay -> GDay -> Ordering
compare :: GDay -> GDay -> Ordering
$c< :: GDay -> GDay -> Bool
< :: GDay -> GDay -> Bool
$c<= :: GDay -> GDay -> Bool
<= :: GDay -> GDay -> Bool
$c> :: GDay -> GDay -> Bool
> :: GDay -> GDay -> Bool
$c>= :: GDay -> GDay -> Bool
>= :: GDay -> GDay -> Bool
$cmax :: GDay -> GDay -> GDay
max :: GDay -> GDay -> GDay
$cmin :: GDay -> GDay -> GDay
min :: GDay -> GDay -> GDay
Ord, ReadPrec [GDay]
ReadPrec GDay
Int -> ReadS GDay
ReadS [GDay]
(Int -> ReadS GDay)
-> ReadS [GDay] -> ReadPrec GDay -> ReadPrec [GDay] -> Read GDay
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS GDay
readsPrec :: Int -> ReadS GDay
$creadList :: ReadS [GDay]
readList :: ReadS [GDay]
$creadPrec :: ReadPrec GDay
readPrec :: ReadPrec GDay
$creadListPrec :: ReadPrec [GDay]
readListPrec :: ReadPrec [GDay]
Read, Int -> GDay -> String -> String
[GDay] -> String -> String
GDay -> String
(Int -> GDay -> String -> String)
-> (GDay -> String) -> ([GDay] -> String -> String) -> Show GDay
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> GDay -> String -> String
showsPrec :: Int -> GDay -> String -> String
$cshow :: GDay -> String
show :: GDay -> String
$cshowList :: [GDay] -> String -> String
showList :: [GDay] -> String -> String
Show)

_GDay :: Name
_GDay = (String -> Name
Core.Name String
"hydra/langs/xml/schema.GDay")

newtype GMonth = 
  GMonth {
    GMonth -> String
unGMonth :: String}
  deriving (GMonth -> GMonth -> Bool
(GMonth -> GMonth -> Bool)
-> (GMonth -> GMonth -> Bool) -> Eq GMonth
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: GMonth -> GMonth -> Bool
== :: GMonth -> GMonth -> Bool
$c/= :: GMonth -> GMonth -> Bool
/= :: GMonth -> GMonth -> Bool
Eq, Eq GMonth
Eq GMonth =>
(GMonth -> GMonth -> Ordering)
-> (GMonth -> GMonth -> Bool)
-> (GMonth -> GMonth -> Bool)
-> (GMonth -> GMonth -> Bool)
-> (GMonth -> GMonth -> Bool)
-> (GMonth -> GMonth -> GMonth)
-> (GMonth -> GMonth -> GMonth)
-> Ord GMonth
GMonth -> GMonth -> Bool
GMonth -> GMonth -> Ordering
GMonth -> GMonth -> GMonth
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: GMonth -> GMonth -> Ordering
compare :: GMonth -> GMonth -> Ordering
$c< :: GMonth -> GMonth -> Bool
< :: GMonth -> GMonth -> Bool
$c<= :: GMonth -> GMonth -> Bool
<= :: GMonth -> GMonth -> Bool
$c> :: GMonth -> GMonth -> Bool
> :: GMonth -> GMonth -> Bool
$c>= :: GMonth -> GMonth -> Bool
>= :: GMonth -> GMonth -> Bool
$cmax :: GMonth -> GMonth -> GMonth
max :: GMonth -> GMonth -> GMonth
$cmin :: GMonth -> GMonth -> GMonth
min :: GMonth -> GMonth -> GMonth
Ord, ReadPrec [GMonth]
ReadPrec GMonth
Int -> ReadS GMonth
ReadS [GMonth]
(Int -> ReadS GMonth)
-> ReadS [GMonth]
-> ReadPrec GMonth
-> ReadPrec [GMonth]
-> Read GMonth
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS GMonth
readsPrec :: Int -> ReadS GMonth
$creadList :: ReadS [GMonth]
readList :: ReadS [GMonth]
$creadPrec :: ReadPrec GMonth
readPrec :: ReadPrec GMonth
$creadListPrec :: ReadPrec [GMonth]
readListPrec :: ReadPrec [GMonth]
Read, Int -> GMonth -> String -> String
[GMonth] -> String -> String
GMonth -> String
(Int -> GMonth -> String -> String)
-> (GMonth -> String)
-> ([GMonth] -> String -> String)
-> Show GMonth
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> GMonth -> String -> String
showsPrec :: Int -> GMonth -> String -> String
$cshow :: GMonth -> String
show :: GMonth -> String
$cshowList :: [GMonth] -> String -> String
showList :: [GMonth] -> String -> String
Show)

_GMonth :: Name
_GMonth = (String -> Name
Core.Name String
"hydra/langs/xml/schema.GMonth")

newtype GMonthDay = 
  GMonthDay {
    GMonthDay -> String
unGMonthDay :: String}
  deriving (GMonthDay -> GMonthDay -> Bool
(GMonthDay -> GMonthDay -> Bool)
-> (GMonthDay -> GMonthDay -> Bool) -> Eq GMonthDay
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: GMonthDay -> GMonthDay -> Bool
== :: GMonthDay -> GMonthDay -> Bool
$c/= :: GMonthDay -> GMonthDay -> Bool
/= :: GMonthDay -> GMonthDay -> Bool
Eq, Eq GMonthDay
Eq GMonthDay =>
(GMonthDay -> GMonthDay -> Ordering)
-> (GMonthDay -> GMonthDay -> Bool)
-> (GMonthDay -> GMonthDay -> Bool)
-> (GMonthDay -> GMonthDay -> Bool)
-> (GMonthDay -> GMonthDay -> Bool)
-> (GMonthDay -> GMonthDay -> GMonthDay)
-> (GMonthDay -> GMonthDay -> GMonthDay)
-> Ord GMonthDay
GMonthDay -> GMonthDay -> Bool
GMonthDay -> GMonthDay -> Ordering
GMonthDay -> GMonthDay -> GMonthDay
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: GMonthDay -> GMonthDay -> Ordering
compare :: GMonthDay -> GMonthDay -> Ordering
$c< :: GMonthDay -> GMonthDay -> Bool
< :: GMonthDay -> GMonthDay -> Bool
$c<= :: GMonthDay -> GMonthDay -> Bool
<= :: GMonthDay -> GMonthDay -> Bool
$c> :: GMonthDay -> GMonthDay -> Bool
> :: GMonthDay -> GMonthDay -> Bool
$c>= :: GMonthDay -> GMonthDay -> Bool
>= :: GMonthDay -> GMonthDay -> Bool
$cmax :: GMonthDay -> GMonthDay -> GMonthDay
max :: GMonthDay -> GMonthDay -> GMonthDay
$cmin :: GMonthDay -> GMonthDay -> GMonthDay
min :: GMonthDay -> GMonthDay -> GMonthDay
Ord, ReadPrec [GMonthDay]
ReadPrec GMonthDay
Int -> ReadS GMonthDay
ReadS [GMonthDay]
(Int -> ReadS GMonthDay)
-> ReadS [GMonthDay]
-> ReadPrec GMonthDay
-> ReadPrec [GMonthDay]
-> Read GMonthDay
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS GMonthDay
readsPrec :: Int -> ReadS GMonthDay
$creadList :: ReadS [GMonthDay]
readList :: ReadS [GMonthDay]
$creadPrec :: ReadPrec GMonthDay
readPrec :: ReadPrec GMonthDay
$creadListPrec :: ReadPrec [GMonthDay]
readListPrec :: ReadPrec [GMonthDay]
Read, Int -> GMonthDay -> String -> String
[GMonthDay] -> String -> String
GMonthDay -> String
(Int -> GMonthDay -> String -> String)
-> (GMonthDay -> String)
-> ([GMonthDay] -> String -> String)
-> Show GMonthDay
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> GMonthDay -> String -> String
showsPrec :: Int -> GMonthDay -> String -> String
$cshow :: GMonthDay -> String
show :: GMonthDay -> String
$cshowList :: [GMonthDay] -> String -> String
showList :: [GMonthDay] -> String -> String
Show)

_GMonthDay :: Name
_GMonthDay = (String -> Name
Core.Name String
"hydra/langs/xml/schema.GMonthDay")

newtype GYear = 
  GYear {
    GYear -> String
unGYear :: String}
  deriving (GYear -> GYear -> Bool
(GYear -> GYear -> Bool) -> (GYear -> GYear -> Bool) -> Eq GYear
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: GYear -> GYear -> Bool
== :: GYear -> GYear -> Bool
$c/= :: GYear -> GYear -> Bool
/= :: GYear -> GYear -> Bool
Eq, Eq GYear
Eq GYear =>
(GYear -> GYear -> Ordering)
-> (GYear -> GYear -> Bool)
-> (GYear -> GYear -> Bool)
-> (GYear -> GYear -> Bool)
-> (GYear -> GYear -> Bool)
-> (GYear -> GYear -> GYear)
-> (GYear -> GYear -> GYear)
-> Ord GYear
GYear -> GYear -> Bool
GYear -> GYear -> Ordering
GYear -> GYear -> GYear
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: GYear -> GYear -> Ordering
compare :: GYear -> GYear -> Ordering
$c< :: GYear -> GYear -> Bool
< :: GYear -> GYear -> Bool
$c<= :: GYear -> GYear -> Bool
<= :: GYear -> GYear -> Bool
$c> :: GYear -> GYear -> Bool
> :: GYear -> GYear -> Bool
$c>= :: GYear -> GYear -> Bool
>= :: GYear -> GYear -> Bool
$cmax :: GYear -> GYear -> GYear
max :: GYear -> GYear -> GYear
$cmin :: GYear -> GYear -> GYear
min :: GYear -> GYear -> GYear
Ord, ReadPrec [GYear]
ReadPrec GYear
Int -> ReadS GYear
ReadS [GYear]
(Int -> ReadS GYear)
-> ReadS [GYear]
-> ReadPrec GYear
-> ReadPrec [GYear]
-> Read GYear
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS GYear
readsPrec :: Int -> ReadS GYear
$creadList :: ReadS [GYear]
readList :: ReadS [GYear]
$creadPrec :: ReadPrec GYear
readPrec :: ReadPrec GYear
$creadListPrec :: ReadPrec [GYear]
readListPrec :: ReadPrec [GYear]
Read, Int -> GYear -> String -> String
[GYear] -> String -> String
GYear -> String
(Int -> GYear -> String -> String)
-> (GYear -> String) -> ([GYear] -> String -> String) -> Show GYear
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> GYear -> String -> String
showsPrec :: Int -> GYear -> String -> String
$cshow :: GYear -> String
show :: GYear -> String
$cshowList :: [GYear] -> String -> String
showList :: [GYear] -> String -> String
Show)

_GYear :: Name
_GYear = (String -> Name
Core.Name String
"hydra/langs/xml/schema.GYear")

newtype GYearMonth = 
  GYearMonth {
    GYearMonth -> String
unGYearMonth :: String}
  deriving (GYearMonth -> GYearMonth -> Bool
(GYearMonth -> GYearMonth -> Bool)
-> (GYearMonth -> GYearMonth -> Bool) -> Eq GYearMonth
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: GYearMonth -> GYearMonth -> Bool
== :: GYearMonth -> GYearMonth -> Bool
$c/= :: GYearMonth -> GYearMonth -> Bool
/= :: GYearMonth -> GYearMonth -> Bool
Eq, Eq GYearMonth
Eq GYearMonth =>
(GYearMonth -> GYearMonth -> Ordering)
-> (GYearMonth -> GYearMonth -> Bool)
-> (GYearMonth -> GYearMonth -> Bool)
-> (GYearMonth -> GYearMonth -> Bool)
-> (GYearMonth -> GYearMonth -> Bool)
-> (GYearMonth -> GYearMonth -> GYearMonth)
-> (GYearMonth -> GYearMonth -> GYearMonth)
-> Ord GYearMonth
GYearMonth -> GYearMonth -> Bool
GYearMonth -> GYearMonth -> Ordering
GYearMonth -> GYearMonth -> GYearMonth
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: GYearMonth -> GYearMonth -> Ordering
compare :: GYearMonth -> GYearMonth -> Ordering
$c< :: GYearMonth -> GYearMonth -> Bool
< :: GYearMonth -> GYearMonth -> Bool
$c<= :: GYearMonth -> GYearMonth -> Bool
<= :: GYearMonth -> GYearMonth -> Bool
$c> :: GYearMonth -> GYearMonth -> Bool
> :: GYearMonth -> GYearMonth -> Bool
$c>= :: GYearMonth -> GYearMonth -> Bool
>= :: GYearMonth -> GYearMonth -> Bool
$cmax :: GYearMonth -> GYearMonth -> GYearMonth
max :: GYearMonth -> GYearMonth -> GYearMonth
$cmin :: GYearMonth -> GYearMonth -> GYearMonth
min :: GYearMonth -> GYearMonth -> GYearMonth
Ord, ReadPrec [GYearMonth]
ReadPrec GYearMonth
Int -> ReadS GYearMonth
ReadS [GYearMonth]
(Int -> ReadS GYearMonth)
-> ReadS [GYearMonth]
-> ReadPrec GYearMonth
-> ReadPrec [GYearMonth]
-> Read GYearMonth
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS GYearMonth
readsPrec :: Int -> ReadS GYearMonth
$creadList :: ReadS [GYearMonth]
readList :: ReadS [GYearMonth]
$creadPrec :: ReadPrec GYearMonth
readPrec :: ReadPrec GYearMonth
$creadListPrec :: ReadPrec [GYearMonth]
readListPrec :: ReadPrec [GYearMonth]
Read, Int -> GYearMonth -> String -> String
[GYearMonth] -> String -> String
GYearMonth -> String
(Int -> GYearMonth -> String -> String)
-> (GYearMonth -> String)
-> ([GYearMonth] -> String -> String)
-> Show GYearMonth
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> GYearMonth -> String -> String
showsPrec :: Int -> GYearMonth -> String -> String
$cshow :: GYearMonth -> String
show :: GYearMonth -> String
$cshowList :: [GYearMonth] -> String -> String
showList :: [GYearMonth] -> String -> String
Show)

_GYearMonth :: Name
_GYearMonth = (String -> Name
Core.Name String
"hydra/langs/xml/schema.GYearMonth")

newtype HexBinary = 
  HexBinary {
    HexBinary -> String
unHexBinary :: String}
  deriving (HexBinary -> HexBinary -> Bool
(HexBinary -> HexBinary -> Bool)
-> (HexBinary -> HexBinary -> Bool) -> Eq HexBinary
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: HexBinary -> HexBinary -> Bool
== :: HexBinary -> HexBinary -> Bool
$c/= :: HexBinary -> HexBinary -> Bool
/= :: HexBinary -> HexBinary -> Bool
Eq, Eq HexBinary
Eq HexBinary =>
(HexBinary -> HexBinary -> Ordering)
-> (HexBinary -> HexBinary -> Bool)
-> (HexBinary -> HexBinary -> Bool)
-> (HexBinary -> HexBinary -> Bool)
-> (HexBinary -> HexBinary -> Bool)
-> (HexBinary -> HexBinary -> HexBinary)
-> (HexBinary -> HexBinary -> HexBinary)
-> Ord HexBinary
HexBinary -> HexBinary -> Bool
HexBinary -> HexBinary -> Ordering
HexBinary -> HexBinary -> HexBinary
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: HexBinary -> HexBinary -> Ordering
compare :: HexBinary -> HexBinary -> Ordering
$c< :: HexBinary -> HexBinary -> Bool
< :: HexBinary -> HexBinary -> Bool
$c<= :: HexBinary -> HexBinary -> Bool
<= :: HexBinary -> HexBinary -> Bool
$c> :: HexBinary -> HexBinary -> Bool
> :: HexBinary -> HexBinary -> Bool
$c>= :: HexBinary -> HexBinary -> Bool
>= :: HexBinary -> HexBinary -> Bool
$cmax :: HexBinary -> HexBinary -> HexBinary
max :: HexBinary -> HexBinary -> HexBinary
$cmin :: HexBinary -> HexBinary -> HexBinary
min :: HexBinary -> HexBinary -> HexBinary
Ord, ReadPrec [HexBinary]
ReadPrec HexBinary
Int -> ReadS HexBinary
ReadS [HexBinary]
(Int -> ReadS HexBinary)
-> ReadS [HexBinary]
-> ReadPrec HexBinary
-> ReadPrec [HexBinary]
-> Read HexBinary
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS HexBinary
readsPrec :: Int -> ReadS HexBinary
$creadList :: ReadS [HexBinary]
readList :: ReadS [HexBinary]
$creadPrec :: ReadPrec HexBinary
readPrec :: ReadPrec HexBinary
$creadListPrec :: ReadPrec [HexBinary]
readListPrec :: ReadPrec [HexBinary]
Read, Int -> HexBinary -> String -> String
[HexBinary] -> String -> String
HexBinary -> String
(Int -> HexBinary -> String -> String)
-> (HexBinary -> String)
-> ([HexBinary] -> String -> String)
-> Show HexBinary
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> HexBinary -> String -> String
showsPrec :: Int -> HexBinary -> String -> String
$cshow :: HexBinary -> String
show :: HexBinary -> String
$cshowList :: [HexBinary] -> String -> String
showList :: [HexBinary] -> String -> String
Show)

_HexBinary :: Name
_HexBinary = (String -> Name
Core.Name String
"hydra/langs/xml/schema.HexBinary")

newtype ID = 
  ID {
    ID -> String
unID :: String}
  deriving (ID -> ID -> Bool
(ID -> ID -> Bool) -> (ID -> ID -> Bool) -> Eq ID
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ID -> ID -> Bool
== :: ID -> ID -> Bool
$c/= :: ID -> ID -> Bool
/= :: ID -> ID -> Bool
Eq, Eq ID
Eq ID =>
(ID -> ID -> Ordering)
-> (ID -> ID -> Bool)
-> (ID -> ID -> Bool)
-> (ID -> ID -> Bool)
-> (ID -> ID -> Bool)
-> (ID -> ID -> ID)
-> (ID -> ID -> ID)
-> Ord ID
ID -> ID -> Bool
ID -> ID -> Ordering
ID -> ID -> ID
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ID -> ID -> Ordering
compare :: ID -> ID -> Ordering
$c< :: ID -> ID -> Bool
< :: ID -> ID -> Bool
$c<= :: ID -> ID -> Bool
<= :: ID -> ID -> Bool
$c> :: ID -> ID -> Bool
> :: ID -> ID -> Bool
$c>= :: ID -> ID -> Bool
>= :: ID -> ID -> Bool
$cmax :: ID -> ID -> ID
max :: ID -> ID -> ID
$cmin :: ID -> ID -> ID
min :: ID -> ID -> ID
Ord, ReadPrec [ID]
ReadPrec ID
Int -> ReadS ID
ReadS [ID]
(Int -> ReadS ID)
-> ReadS [ID] -> ReadPrec ID -> ReadPrec [ID] -> Read ID
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ID
readsPrec :: Int -> ReadS ID
$creadList :: ReadS [ID]
readList :: ReadS [ID]
$creadPrec :: ReadPrec ID
readPrec :: ReadPrec ID
$creadListPrec :: ReadPrec [ID]
readListPrec :: ReadPrec [ID]
Read, Int -> ID -> String -> String
[ID] -> String -> String
ID -> String
(Int -> ID -> String -> String)
-> (ID -> String) -> ([ID] -> String -> String) -> Show ID
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> ID -> String -> String
showsPrec :: Int -> ID -> String -> String
$cshow :: ID -> String
show :: ID -> String
$cshowList :: [ID] -> String -> String
showList :: [ID] -> String -> String
Show)

_ID :: Name
_ID = (String -> Name
Core.Name String
"hydra/langs/xml/schema.ID")

newtype IDREF = 
  IDREF {
    IDREF -> String
unIDREF :: String}
  deriving (IDREF -> IDREF -> Bool
(IDREF -> IDREF -> Bool) -> (IDREF -> IDREF -> Bool) -> Eq IDREF
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: IDREF -> IDREF -> Bool
== :: IDREF -> IDREF -> Bool
$c/= :: IDREF -> IDREF -> Bool
/= :: IDREF -> IDREF -> Bool
Eq, Eq IDREF
Eq IDREF =>
(IDREF -> IDREF -> Ordering)
-> (IDREF -> IDREF -> Bool)
-> (IDREF -> IDREF -> Bool)
-> (IDREF -> IDREF -> Bool)
-> (IDREF -> IDREF -> Bool)
-> (IDREF -> IDREF -> IDREF)
-> (IDREF -> IDREF -> IDREF)
-> Ord IDREF
IDREF -> IDREF -> Bool
IDREF -> IDREF -> Ordering
IDREF -> IDREF -> IDREF
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: IDREF -> IDREF -> Ordering
compare :: IDREF -> IDREF -> Ordering
$c< :: IDREF -> IDREF -> Bool
< :: IDREF -> IDREF -> Bool
$c<= :: IDREF -> IDREF -> Bool
<= :: IDREF -> IDREF -> Bool
$c> :: IDREF -> IDREF -> Bool
> :: IDREF -> IDREF -> Bool
$c>= :: IDREF -> IDREF -> Bool
>= :: IDREF -> IDREF -> Bool
$cmax :: IDREF -> IDREF -> IDREF
max :: IDREF -> IDREF -> IDREF
$cmin :: IDREF -> IDREF -> IDREF
min :: IDREF -> IDREF -> IDREF
Ord, ReadPrec [IDREF]
ReadPrec IDREF
Int -> ReadS IDREF
ReadS [IDREF]
(Int -> ReadS IDREF)
-> ReadS [IDREF]
-> ReadPrec IDREF
-> ReadPrec [IDREF]
-> Read IDREF
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS IDREF
readsPrec :: Int -> ReadS IDREF
$creadList :: ReadS [IDREF]
readList :: ReadS [IDREF]
$creadPrec :: ReadPrec IDREF
readPrec :: ReadPrec IDREF
$creadListPrec :: ReadPrec [IDREF]
readListPrec :: ReadPrec [IDREF]
Read, Int -> IDREF -> String -> String
[IDREF] -> String -> String
IDREF -> String
(Int -> IDREF -> String -> String)
-> (IDREF -> String) -> ([IDREF] -> String -> String) -> Show IDREF
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> IDREF -> String -> String
showsPrec :: Int -> IDREF -> String -> String
$cshow :: IDREF -> String
show :: IDREF -> String
$cshowList :: [IDREF] -> String -> String
showList :: [IDREF] -> String -> String
Show)

_IDREF :: Name
_IDREF = (String -> Name
Core.Name String
"hydra/langs/xml/schema.IDREF")

newtype IDREFS = 
  IDREFS {
    IDREFS -> String
unIDREFS :: String}
  deriving (IDREFS -> IDREFS -> Bool
(IDREFS -> IDREFS -> Bool)
-> (IDREFS -> IDREFS -> Bool) -> Eq IDREFS
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: IDREFS -> IDREFS -> Bool
== :: IDREFS -> IDREFS -> Bool
$c/= :: IDREFS -> IDREFS -> Bool
/= :: IDREFS -> IDREFS -> Bool
Eq, Eq IDREFS
Eq IDREFS =>
(IDREFS -> IDREFS -> Ordering)
-> (IDREFS -> IDREFS -> Bool)
-> (IDREFS -> IDREFS -> Bool)
-> (IDREFS -> IDREFS -> Bool)
-> (IDREFS -> IDREFS -> Bool)
-> (IDREFS -> IDREFS -> IDREFS)
-> (IDREFS -> IDREFS -> IDREFS)
-> Ord IDREFS
IDREFS -> IDREFS -> Bool
IDREFS -> IDREFS -> Ordering
IDREFS -> IDREFS -> IDREFS
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: IDREFS -> IDREFS -> Ordering
compare :: IDREFS -> IDREFS -> Ordering
$c< :: IDREFS -> IDREFS -> Bool
< :: IDREFS -> IDREFS -> Bool
$c<= :: IDREFS -> IDREFS -> Bool
<= :: IDREFS -> IDREFS -> Bool
$c> :: IDREFS -> IDREFS -> Bool
> :: IDREFS -> IDREFS -> Bool
$c>= :: IDREFS -> IDREFS -> Bool
>= :: IDREFS -> IDREFS -> Bool
$cmax :: IDREFS -> IDREFS -> IDREFS
max :: IDREFS -> IDREFS -> IDREFS
$cmin :: IDREFS -> IDREFS -> IDREFS
min :: IDREFS -> IDREFS -> IDREFS
Ord, ReadPrec [IDREFS]
ReadPrec IDREFS
Int -> ReadS IDREFS
ReadS [IDREFS]
(Int -> ReadS IDREFS)
-> ReadS [IDREFS]
-> ReadPrec IDREFS
-> ReadPrec [IDREFS]
-> Read IDREFS
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS IDREFS
readsPrec :: Int -> ReadS IDREFS
$creadList :: ReadS [IDREFS]
readList :: ReadS [IDREFS]
$creadPrec :: ReadPrec IDREFS
readPrec :: ReadPrec IDREFS
$creadListPrec :: ReadPrec [IDREFS]
readListPrec :: ReadPrec [IDREFS]
Read, Int -> IDREFS -> String -> String
[IDREFS] -> String -> String
IDREFS -> String
(Int -> IDREFS -> String -> String)
-> (IDREFS -> String)
-> ([IDREFS] -> String -> String)
-> Show IDREFS
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> IDREFS -> String -> String
showsPrec :: Int -> IDREFS -> String -> String
$cshow :: IDREFS -> String
show :: IDREFS -> String
$cshowList :: [IDREFS] -> String -> String
showList :: [IDREFS] -> String -> String
Show)

_IDREFS :: Name
_IDREFS = (String -> Name
Core.Name String
"hydra/langs/xml/schema.IDREFS")

newtype Int_ = 
  Int_ {
    Int_ -> Int
unInt :: Int}
  deriving (Int_ -> Int_ -> Bool
(Int_ -> Int_ -> Bool) -> (Int_ -> Int_ -> Bool) -> Eq Int_
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Int_ -> Int_ -> Bool
== :: Int_ -> Int_ -> Bool
$c/= :: Int_ -> Int_ -> Bool
/= :: Int_ -> Int_ -> Bool
Eq, Eq Int_
Eq Int_ =>
(Int_ -> Int_ -> Ordering)
-> (Int_ -> Int_ -> Bool)
-> (Int_ -> Int_ -> Bool)
-> (Int_ -> Int_ -> Bool)
-> (Int_ -> Int_ -> Bool)
-> (Int_ -> Int_ -> Int_)
-> (Int_ -> Int_ -> Int_)
-> Ord Int_
Int_ -> Int_ -> Bool
Int_ -> Int_ -> Ordering
Int_ -> Int_ -> Int_
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Int_ -> Int_ -> Ordering
compare :: Int_ -> Int_ -> Ordering
$c< :: Int_ -> Int_ -> Bool
< :: Int_ -> Int_ -> Bool
$c<= :: Int_ -> Int_ -> Bool
<= :: Int_ -> Int_ -> Bool
$c> :: Int_ -> Int_ -> Bool
> :: Int_ -> Int_ -> Bool
$c>= :: Int_ -> Int_ -> Bool
>= :: Int_ -> Int_ -> Bool
$cmax :: Int_ -> Int_ -> Int_
max :: Int_ -> Int_ -> Int_
$cmin :: Int_ -> Int_ -> Int_
min :: Int_ -> Int_ -> Int_
Ord, ReadPrec [Int_]
ReadPrec Int_
Int -> ReadS Int_
ReadS [Int_]
(Int -> ReadS Int_)
-> ReadS [Int_] -> ReadPrec Int_ -> ReadPrec [Int_] -> Read Int_
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Int_
readsPrec :: Int -> ReadS Int_
$creadList :: ReadS [Int_]
readList :: ReadS [Int_]
$creadPrec :: ReadPrec Int_
readPrec :: ReadPrec Int_
$creadListPrec :: ReadPrec [Int_]
readListPrec :: ReadPrec [Int_]
Read, Int -> Int_ -> String -> String
[Int_] -> String -> String
Int_ -> String
(Int -> Int_ -> String -> String)
-> (Int_ -> String) -> ([Int_] -> String -> String) -> Show Int_
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Int_ -> String -> String
showsPrec :: Int -> Int_ -> String -> String
$cshow :: Int_ -> String
show :: Int_ -> String
$cshowList :: [Int_] -> String -> String
showList :: [Int_] -> String -> String
Show)

_Int :: Name
_Int = (String -> Name
Core.Name String
"hydra/langs/xml/schema.Int")

newtype Integer_ = 
  Integer_ {
    Integer_ -> Integer
unInteger :: Integer}
  deriving (Integer_ -> Integer_ -> Bool
(Integer_ -> Integer_ -> Bool)
-> (Integer_ -> Integer_ -> Bool) -> Eq Integer_
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Integer_ -> Integer_ -> Bool
== :: Integer_ -> Integer_ -> Bool
$c/= :: Integer_ -> Integer_ -> Bool
/= :: Integer_ -> Integer_ -> Bool
Eq, Eq Integer_
Eq Integer_ =>
(Integer_ -> Integer_ -> Ordering)
-> (Integer_ -> Integer_ -> Bool)
-> (Integer_ -> Integer_ -> Bool)
-> (Integer_ -> Integer_ -> Bool)
-> (Integer_ -> Integer_ -> Bool)
-> (Integer_ -> Integer_ -> Integer_)
-> (Integer_ -> Integer_ -> Integer_)
-> Ord Integer_
Integer_ -> Integer_ -> Bool
Integer_ -> Integer_ -> Ordering
Integer_ -> Integer_ -> Integer_
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Integer_ -> Integer_ -> Ordering
compare :: Integer_ -> Integer_ -> Ordering
$c< :: Integer_ -> Integer_ -> Bool
< :: Integer_ -> Integer_ -> Bool
$c<= :: Integer_ -> Integer_ -> Bool
<= :: Integer_ -> Integer_ -> Bool
$c> :: Integer_ -> Integer_ -> Bool
> :: Integer_ -> Integer_ -> Bool
$c>= :: Integer_ -> Integer_ -> Bool
>= :: Integer_ -> Integer_ -> Bool
$cmax :: Integer_ -> Integer_ -> Integer_
max :: Integer_ -> Integer_ -> Integer_
$cmin :: Integer_ -> Integer_ -> Integer_
min :: Integer_ -> Integer_ -> Integer_
Ord, ReadPrec [Integer_]
ReadPrec Integer_
Int -> ReadS Integer_
ReadS [Integer_]
(Int -> ReadS Integer_)
-> ReadS [Integer_]
-> ReadPrec Integer_
-> ReadPrec [Integer_]
-> Read Integer_
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Integer_
readsPrec :: Int -> ReadS Integer_
$creadList :: ReadS [Integer_]
readList :: ReadS [Integer_]
$creadPrec :: ReadPrec Integer_
readPrec :: ReadPrec Integer_
$creadListPrec :: ReadPrec [Integer_]
readListPrec :: ReadPrec [Integer_]
Read, Int -> Integer_ -> String -> String
[Integer_] -> String -> String
Integer_ -> String
(Int -> Integer_ -> String -> String)
-> (Integer_ -> String)
-> ([Integer_] -> String -> String)
-> Show Integer_
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Integer_ -> String -> String
showsPrec :: Int -> Integer_ -> String -> String
$cshow :: Integer_ -> String
show :: Integer_ -> String
$cshowList :: [Integer_] -> String -> String
showList :: [Integer_] -> String -> String
Show)

_Integer :: Name
_Integer = (String -> Name
Core.Name String
"hydra/langs/xml/schema.Integer")

newtype Language = 
  Language {
    Language -> String
unLanguage :: String}
  deriving (Language -> Language -> Bool
(Language -> Language -> Bool)
-> (Language -> Language -> Bool) -> Eq Language
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Language -> Language -> Bool
== :: Language -> Language -> Bool
$c/= :: Language -> Language -> Bool
/= :: Language -> Language -> Bool
Eq, Eq Language
Eq Language =>
(Language -> Language -> Ordering)
-> (Language -> Language -> Bool)
-> (Language -> Language -> Bool)
-> (Language -> Language -> Bool)
-> (Language -> Language -> Bool)
-> (Language -> Language -> Language)
-> (Language -> Language -> Language)
-> Ord Language
Language -> Language -> Bool
Language -> Language -> Ordering
Language -> Language -> Language
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Language -> Language -> Ordering
compare :: Language -> Language -> Ordering
$c< :: Language -> Language -> Bool
< :: Language -> Language -> Bool
$c<= :: Language -> Language -> Bool
<= :: Language -> Language -> Bool
$c> :: Language -> Language -> Bool
> :: Language -> Language -> Bool
$c>= :: Language -> Language -> Bool
>= :: Language -> Language -> Bool
$cmax :: Language -> Language -> Language
max :: Language -> Language -> Language
$cmin :: Language -> Language -> Language
min :: Language -> Language -> Language
Ord, ReadPrec [Language]
ReadPrec Language
Int -> ReadS Language
ReadS [Language]
(Int -> ReadS Language)
-> ReadS [Language]
-> ReadPrec Language
-> ReadPrec [Language]
-> Read Language
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Language
readsPrec :: Int -> ReadS Language
$creadList :: ReadS [Language]
readList :: ReadS [Language]
$creadPrec :: ReadPrec Language
readPrec :: ReadPrec Language
$creadListPrec :: ReadPrec [Language]
readListPrec :: ReadPrec [Language]
Read, Int -> Language -> String -> String
[Language] -> String -> String
Language -> String
(Int -> Language -> String -> String)
-> (Language -> String)
-> ([Language] -> String -> String)
-> Show Language
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Language -> String -> String
showsPrec :: Int -> Language -> String -> String
$cshow :: Language -> String
show :: Language -> String
$cshowList :: [Language] -> String -> String
showList :: [Language] -> String -> String
Show)

_Language :: Name
_Language = (String -> Name
Core.Name String
"hydra/langs/xml/schema.Language")

newtype Long = 
  Long {
    Long -> Int64
unLong :: Int64}
  deriving (Long -> Long -> Bool
(Long -> Long -> Bool) -> (Long -> Long -> Bool) -> Eq Long
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Long -> Long -> Bool
== :: Long -> Long -> Bool
$c/= :: Long -> Long -> Bool
/= :: Long -> Long -> Bool
Eq, Eq Long
Eq Long =>
(Long -> Long -> Ordering)
-> (Long -> Long -> Bool)
-> (Long -> Long -> Bool)
-> (Long -> Long -> Bool)
-> (Long -> Long -> Bool)
-> (Long -> Long -> Long)
-> (Long -> Long -> Long)
-> Ord Long
Long -> Long -> Bool
Long -> Long -> Ordering
Long -> Long -> Long
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Long -> Long -> Ordering
compare :: Long -> Long -> Ordering
$c< :: Long -> Long -> Bool
< :: Long -> Long -> Bool
$c<= :: Long -> Long -> Bool
<= :: Long -> Long -> Bool
$c> :: Long -> Long -> Bool
> :: Long -> Long -> Bool
$c>= :: Long -> Long -> Bool
>= :: Long -> Long -> Bool
$cmax :: Long -> Long -> Long
max :: Long -> Long -> Long
$cmin :: Long -> Long -> Long
min :: Long -> Long -> Long
Ord, ReadPrec [Long]
ReadPrec Long
Int -> ReadS Long
ReadS [Long]
(Int -> ReadS Long)
-> ReadS [Long] -> ReadPrec Long -> ReadPrec [Long] -> Read Long
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Long
readsPrec :: Int -> ReadS Long
$creadList :: ReadS [Long]
readList :: ReadS [Long]
$creadPrec :: ReadPrec Long
readPrec :: ReadPrec Long
$creadListPrec :: ReadPrec [Long]
readListPrec :: ReadPrec [Long]
Read, Int -> Long -> String -> String
[Long] -> String -> String
Long -> String
(Int -> Long -> String -> String)
-> (Long -> String) -> ([Long] -> String -> String) -> Show Long
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Long -> String -> String
showsPrec :: Int -> Long -> String -> String
$cshow :: Long -> String
show :: Long -> String
$cshowList :: [Long] -> String -> String
showList :: [Long] -> String -> String
Show)

_Long :: Name
_Long = (String -> Name
Core.Name String
"hydra/langs/xml/schema.Long")

newtype NMTOKEN = 
  NMTOKEN {
    NMTOKEN -> String
unNMTOKEN :: String}
  deriving (NMTOKEN -> NMTOKEN -> Bool
(NMTOKEN -> NMTOKEN -> Bool)
-> (NMTOKEN -> NMTOKEN -> Bool) -> Eq NMTOKEN
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NMTOKEN -> NMTOKEN -> Bool
== :: NMTOKEN -> NMTOKEN -> Bool
$c/= :: NMTOKEN -> NMTOKEN -> Bool
/= :: NMTOKEN -> NMTOKEN -> Bool
Eq, Eq NMTOKEN
Eq NMTOKEN =>
(NMTOKEN -> NMTOKEN -> Ordering)
-> (NMTOKEN -> NMTOKEN -> Bool)
-> (NMTOKEN -> NMTOKEN -> Bool)
-> (NMTOKEN -> NMTOKEN -> Bool)
-> (NMTOKEN -> NMTOKEN -> Bool)
-> (NMTOKEN -> NMTOKEN -> NMTOKEN)
-> (NMTOKEN -> NMTOKEN -> NMTOKEN)
-> Ord NMTOKEN
NMTOKEN -> NMTOKEN -> Bool
NMTOKEN -> NMTOKEN -> Ordering
NMTOKEN -> NMTOKEN -> NMTOKEN
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: NMTOKEN -> NMTOKEN -> Ordering
compare :: NMTOKEN -> NMTOKEN -> Ordering
$c< :: NMTOKEN -> NMTOKEN -> Bool
< :: NMTOKEN -> NMTOKEN -> Bool
$c<= :: NMTOKEN -> NMTOKEN -> Bool
<= :: NMTOKEN -> NMTOKEN -> Bool
$c> :: NMTOKEN -> NMTOKEN -> Bool
> :: NMTOKEN -> NMTOKEN -> Bool
$c>= :: NMTOKEN -> NMTOKEN -> Bool
>= :: NMTOKEN -> NMTOKEN -> Bool
$cmax :: NMTOKEN -> NMTOKEN -> NMTOKEN
max :: NMTOKEN -> NMTOKEN -> NMTOKEN
$cmin :: NMTOKEN -> NMTOKEN -> NMTOKEN
min :: NMTOKEN -> NMTOKEN -> NMTOKEN
Ord, ReadPrec [NMTOKEN]
ReadPrec NMTOKEN
Int -> ReadS NMTOKEN
ReadS [NMTOKEN]
(Int -> ReadS NMTOKEN)
-> ReadS [NMTOKEN]
-> ReadPrec NMTOKEN
-> ReadPrec [NMTOKEN]
-> Read NMTOKEN
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS NMTOKEN
readsPrec :: Int -> ReadS NMTOKEN
$creadList :: ReadS [NMTOKEN]
readList :: ReadS [NMTOKEN]
$creadPrec :: ReadPrec NMTOKEN
readPrec :: ReadPrec NMTOKEN
$creadListPrec :: ReadPrec [NMTOKEN]
readListPrec :: ReadPrec [NMTOKEN]
Read, Int -> NMTOKEN -> String -> String
[NMTOKEN] -> String -> String
NMTOKEN -> String
(Int -> NMTOKEN -> String -> String)
-> (NMTOKEN -> String)
-> ([NMTOKEN] -> String -> String)
-> Show NMTOKEN
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> NMTOKEN -> String -> String
showsPrec :: Int -> NMTOKEN -> String -> String
$cshow :: NMTOKEN -> String
show :: NMTOKEN -> String
$cshowList :: [NMTOKEN] -> String -> String
showList :: [NMTOKEN] -> String -> String
Show)

_NMTOKEN :: Name
_NMTOKEN = (String -> Name
Core.Name String
"hydra/langs/xml/schema.NMTOKEN")

newtype NOTATION = 
  NOTATION {
    NOTATION -> String
unNOTATION :: String}
  deriving (NOTATION -> NOTATION -> Bool
(NOTATION -> NOTATION -> Bool)
-> (NOTATION -> NOTATION -> Bool) -> Eq NOTATION
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NOTATION -> NOTATION -> Bool
== :: NOTATION -> NOTATION -> Bool
$c/= :: NOTATION -> NOTATION -> Bool
/= :: NOTATION -> NOTATION -> Bool
Eq, Eq NOTATION
Eq NOTATION =>
(NOTATION -> NOTATION -> Ordering)
-> (NOTATION -> NOTATION -> Bool)
-> (NOTATION -> NOTATION -> Bool)
-> (NOTATION -> NOTATION -> Bool)
-> (NOTATION -> NOTATION -> Bool)
-> (NOTATION -> NOTATION -> NOTATION)
-> (NOTATION -> NOTATION -> NOTATION)
-> Ord NOTATION
NOTATION -> NOTATION -> Bool
NOTATION -> NOTATION -> Ordering
NOTATION -> NOTATION -> NOTATION
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: NOTATION -> NOTATION -> Ordering
compare :: NOTATION -> NOTATION -> Ordering
$c< :: NOTATION -> NOTATION -> Bool
< :: NOTATION -> NOTATION -> Bool
$c<= :: NOTATION -> NOTATION -> Bool
<= :: NOTATION -> NOTATION -> Bool
$c> :: NOTATION -> NOTATION -> Bool
> :: NOTATION -> NOTATION -> Bool
$c>= :: NOTATION -> NOTATION -> Bool
>= :: NOTATION -> NOTATION -> Bool
$cmax :: NOTATION -> NOTATION -> NOTATION
max :: NOTATION -> NOTATION -> NOTATION
$cmin :: NOTATION -> NOTATION -> NOTATION
min :: NOTATION -> NOTATION -> NOTATION
Ord, ReadPrec [NOTATION]
ReadPrec NOTATION
Int -> ReadS NOTATION
ReadS [NOTATION]
(Int -> ReadS NOTATION)
-> ReadS [NOTATION]
-> ReadPrec NOTATION
-> ReadPrec [NOTATION]
-> Read NOTATION
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS NOTATION
readsPrec :: Int -> ReadS NOTATION
$creadList :: ReadS [NOTATION]
readList :: ReadS [NOTATION]
$creadPrec :: ReadPrec NOTATION
readPrec :: ReadPrec NOTATION
$creadListPrec :: ReadPrec [NOTATION]
readListPrec :: ReadPrec [NOTATION]
Read, Int -> NOTATION -> String -> String
[NOTATION] -> String -> String
NOTATION -> String
(Int -> NOTATION -> String -> String)
-> (NOTATION -> String)
-> ([NOTATION] -> String -> String)
-> Show NOTATION
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> NOTATION -> String -> String
showsPrec :: Int -> NOTATION -> String -> String
$cshow :: NOTATION -> String
show :: NOTATION -> String
$cshowList :: [NOTATION] -> String -> String
showList :: [NOTATION] -> String -> String
Show)

_NOTATION :: Name
_NOTATION = (String -> Name
Core.Name String
"hydra/langs/xml/schema.NOTATION")

newtype Name = 
  Name {
    Name -> String
unName :: String}
  deriving (Name -> Name -> Bool
(Name -> Name -> Bool) -> (Name -> Name -> Bool) -> Eq Name
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Name -> Name -> Bool
== :: Name -> Name -> Bool
$c/= :: Name -> Name -> Bool
/= :: Name -> Name -> Bool
Eq, Eq Name
Eq Name =>
(Name -> Name -> Ordering)
-> (Name -> Name -> Bool)
-> (Name -> Name -> Bool)
-> (Name -> Name -> Bool)
-> (Name -> Name -> Bool)
-> (Name -> Name -> Name)
-> (Name -> Name -> Name)
-> Ord Name
Name -> Name -> Bool
Name -> Name -> Ordering
Name -> Name -> Name
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Name -> Name -> Ordering
compare :: Name -> Name -> Ordering
$c< :: Name -> Name -> Bool
< :: Name -> Name -> Bool
$c<= :: Name -> Name -> Bool
<= :: Name -> Name -> Bool
$c> :: Name -> Name -> Bool
> :: Name -> Name -> Bool
$c>= :: Name -> Name -> Bool
>= :: Name -> Name -> Bool
$cmax :: Name -> Name -> Name
max :: Name -> Name -> Name
$cmin :: Name -> Name -> Name
min :: Name -> Name -> Name
Ord, ReadPrec [Name]
ReadPrec Name
Int -> ReadS Name
ReadS [Name]
(Int -> ReadS Name)
-> ReadS [Name] -> ReadPrec Name -> ReadPrec [Name] -> Read Name
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Name
readsPrec :: Int -> ReadS Name
$creadList :: ReadS [Name]
readList :: ReadS [Name]
$creadPrec :: ReadPrec Name
readPrec :: ReadPrec Name
$creadListPrec :: ReadPrec [Name]
readListPrec :: ReadPrec [Name]
Read, Int -> Name -> String -> String
[Name] -> String -> String
Name -> String
(Int -> Name -> String -> String)
-> (Name -> String) -> ([Name] -> String -> String) -> Show Name
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Name -> String -> String
showsPrec :: Int -> Name -> String -> String
$cshow :: Name -> String
show :: Name -> String
$cshowList :: [Name] -> String -> String
showList :: [Name] -> String -> String
Show)

_Name :: Name
_Name = (String -> Name
Core.Name String
"hydra/langs/xml/schema.Name")

newtype NegativeInteger = 
  NegativeInteger {
    NegativeInteger -> Integer
unNegativeInteger :: Integer}
  deriving (NegativeInteger -> NegativeInteger -> Bool
(NegativeInteger -> NegativeInteger -> Bool)
-> (NegativeInteger -> NegativeInteger -> Bool)
-> Eq NegativeInteger
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NegativeInteger -> NegativeInteger -> Bool
== :: NegativeInteger -> NegativeInteger -> Bool
$c/= :: NegativeInteger -> NegativeInteger -> Bool
/= :: NegativeInteger -> NegativeInteger -> Bool
Eq, Eq NegativeInteger
Eq NegativeInteger =>
(NegativeInteger -> NegativeInteger -> Ordering)
-> (NegativeInteger -> NegativeInteger -> Bool)
-> (NegativeInteger -> NegativeInteger -> Bool)
-> (NegativeInteger -> NegativeInteger -> Bool)
-> (NegativeInteger -> NegativeInteger -> Bool)
-> (NegativeInteger -> NegativeInteger -> NegativeInteger)
-> (NegativeInteger -> NegativeInteger -> NegativeInteger)
-> Ord NegativeInteger
NegativeInteger -> NegativeInteger -> Bool
NegativeInteger -> NegativeInteger -> Ordering
NegativeInteger -> NegativeInteger -> NegativeInteger
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: NegativeInteger -> NegativeInteger -> Ordering
compare :: NegativeInteger -> NegativeInteger -> Ordering
$c< :: NegativeInteger -> NegativeInteger -> Bool
< :: NegativeInteger -> NegativeInteger -> Bool
$c<= :: NegativeInteger -> NegativeInteger -> Bool
<= :: NegativeInteger -> NegativeInteger -> Bool
$c> :: NegativeInteger -> NegativeInteger -> Bool
> :: NegativeInteger -> NegativeInteger -> Bool
$c>= :: NegativeInteger -> NegativeInteger -> Bool
>= :: NegativeInteger -> NegativeInteger -> Bool
$cmax :: NegativeInteger -> NegativeInteger -> NegativeInteger
max :: NegativeInteger -> NegativeInteger -> NegativeInteger
$cmin :: NegativeInteger -> NegativeInteger -> NegativeInteger
min :: NegativeInteger -> NegativeInteger -> NegativeInteger
Ord, ReadPrec [NegativeInteger]
ReadPrec NegativeInteger
Int -> ReadS NegativeInteger
ReadS [NegativeInteger]
(Int -> ReadS NegativeInteger)
-> ReadS [NegativeInteger]
-> ReadPrec NegativeInteger
-> ReadPrec [NegativeInteger]
-> Read NegativeInteger
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS NegativeInteger
readsPrec :: Int -> ReadS NegativeInteger
$creadList :: ReadS [NegativeInteger]
readList :: ReadS [NegativeInteger]
$creadPrec :: ReadPrec NegativeInteger
readPrec :: ReadPrec NegativeInteger
$creadListPrec :: ReadPrec [NegativeInteger]
readListPrec :: ReadPrec [NegativeInteger]
Read, Int -> NegativeInteger -> String -> String
[NegativeInteger] -> String -> String
NegativeInteger -> String
(Int -> NegativeInteger -> String -> String)
-> (NegativeInteger -> String)
-> ([NegativeInteger] -> String -> String)
-> Show NegativeInteger
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> NegativeInteger -> String -> String
showsPrec :: Int -> NegativeInteger -> String -> String
$cshow :: NegativeInteger -> String
show :: NegativeInteger -> String
$cshowList :: [NegativeInteger] -> String -> String
showList :: [NegativeInteger] -> String -> String
Show)

_NegativeInteger :: Name
_NegativeInteger = (String -> Name
Core.Name String
"hydra/langs/xml/schema.NegativeInteger")

newtype NonNegativeInteger = 
  NonNegativeInteger {
    NonNegativeInteger -> Integer
unNonNegativeInteger :: Integer}
  deriving (NonNegativeInteger -> NonNegativeInteger -> Bool
(NonNegativeInteger -> NonNegativeInteger -> Bool)
-> (NonNegativeInteger -> NonNegativeInteger -> Bool)
-> Eq NonNegativeInteger
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NonNegativeInteger -> NonNegativeInteger -> Bool
== :: NonNegativeInteger -> NonNegativeInteger -> Bool
$c/= :: NonNegativeInteger -> NonNegativeInteger -> Bool
/= :: NonNegativeInteger -> NonNegativeInteger -> Bool
Eq, Eq NonNegativeInteger
Eq NonNegativeInteger =>
(NonNegativeInteger -> NonNegativeInteger -> Ordering)
-> (NonNegativeInteger -> NonNegativeInteger -> Bool)
-> (NonNegativeInteger -> NonNegativeInteger -> Bool)
-> (NonNegativeInteger -> NonNegativeInteger -> Bool)
-> (NonNegativeInteger -> NonNegativeInteger -> Bool)
-> (NonNegativeInteger -> NonNegativeInteger -> NonNegativeInteger)
-> (NonNegativeInteger -> NonNegativeInteger -> NonNegativeInteger)
-> Ord NonNegativeInteger
NonNegativeInteger -> NonNegativeInteger -> Bool
NonNegativeInteger -> NonNegativeInteger -> Ordering
NonNegativeInteger -> NonNegativeInteger -> NonNegativeInteger
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: NonNegativeInteger -> NonNegativeInteger -> Ordering
compare :: NonNegativeInteger -> NonNegativeInteger -> Ordering
$c< :: NonNegativeInteger -> NonNegativeInteger -> Bool
< :: NonNegativeInteger -> NonNegativeInteger -> Bool
$c<= :: NonNegativeInteger -> NonNegativeInteger -> Bool
<= :: NonNegativeInteger -> NonNegativeInteger -> Bool
$c> :: NonNegativeInteger -> NonNegativeInteger -> Bool
> :: NonNegativeInteger -> NonNegativeInteger -> Bool
$c>= :: NonNegativeInteger -> NonNegativeInteger -> Bool
>= :: NonNegativeInteger -> NonNegativeInteger -> Bool
$cmax :: NonNegativeInteger -> NonNegativeInteger -> NonNegativeInteger
max :: NonNegativeInteger -> NonNegativeInteger -> NonNegativeInteger
$cmin :: NonNegativeInteger -> NonNegativeInteger -> NonNegativeInteger
min :: NonNegativeInteger -> NonNegativeInteger -> NonNegativeInteger
Ord, ReadPrec [NonNegativeInteger]
ReadPrec NonNegativeInteger
Int -> ReadS NonNegativeInteger
ReadS [NonNegativeInteger]
(Int -> ReadS NonNegativeInteger)
-> ReadS [NonNegativeInteger]
-> ReadPrec NonNegativeInteger
-> ReadPrec [NonNegativeInteger]
-> Read NonNegativeInteger
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS NonNegativeInteger
readsPrec :: Int -> ReadS NonNegativeInteger
$creadList :: ReadS [NonNegativeInteger]
readList :: ReadS [NonNegativeInteger]
$creadPrec :: ReadPrec NonNegativeInteger
readPrec :: ReadPrec NonNegativeInteger
$creadListPrec :: ReadPrec [NonNegativeInteger]
readListPrec :: ReadPrec [NonNegativeInteger]
Read, Int -> NonNegativeInteger -> String -> String
[NonNegativeInteger] -> String -> String
NonNegativeInteger -> String
(Int -> NonNegativeInteger -> String -> String)
-> (NonNegativeInteger -> String)
-> ([NonNegativeInteger] -> String -> String)
-> Show NonNegativeInteger
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> NonNegativeInteger -> String -> String
showsPrec :: Int -> NonNegativeInteger -> String -> String
$cshow :: NonNegativeInteger -> String
show :: NonNegativeInteger -> String
$cshowList :: [NonNegativeInteger] -> String -> String
showList :: [NonNegativeInteger] -> String -> String
Show)

_NonNegativeInteger :: Name
_NonNegativeInteger = (String -> Name
Core.Name String
"hydra/langs/xml/schema.NonNegativeInteger")

newtype NonPositiveInteger = 
  NonPositiveInteger {
    NonPositiveInteger -> Integer
unNonPositiveInteger :: Integer}
  deriving (NonPositiveInteger -> NonPositiveInteger -> Bool
(NonPositiveInteger -> NonPositiveInteger -> Bool)
-> (NonPositiveInteger -> NonPositiveInteger -> Bool)
-> Eq NonPositiveInteger
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NonPositiveInteger -> NonPositiveInteger -> Bool
== :: NonPositiveInteger -> NonPositiveInteger -> Bool
$c/= :: NonPositiveInteger -> NonPositiveInteger -> Bool
/= :: NonPositiveInteger -> NonPositiveInteger -> Bool
Eq, Eq NonPositiveInteger
Eq NonPositiveInteger =>
(NonPositiveInteger -> NonPositiveInteger -> Ordering)
-> (NonPositiveInteger -> NonPositiveInteger -> Bool)
-> (NonPositiveInteger -> NonPositiveInteger -> Bool)
-> (NonPositiveInteger -> NonPositiveInteger -> Bool)
-> (NonPositiveInteger -> NonPositiveInteger -> Bool)
-> (NonPositiveInteger -> NonPositiveInteger -> NonPositiveInteger)
-> (NonPositiveInteger -> NonPositiveInteger -> NonPositiveInteger)
-> Ord NonPositiveInteger
NonPositiveInteger -> NonPositiveInteger -> Bool
NonPositiveInteger -> NonPositiveInteger -> Ordering
NonPositiveInteger -> NonPositiveInteger -> NonPositiveInteger
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: NonPositiveInteger -> NonPositiveInteger -> Ordering
compare :: NonPositiveInteger -> NonPositiveInteger -> Ordering
$c< :: NonPositiveInteger -> NonPositiveInteger -> Bool
< :: NonPositiveInteger -> NonPositiveInteger -> Bool
$c<= :: NonPositiveInteger -> NonPositiveInteger -> Bool
<= :: NonPositiveInteger -> NonPositiveInteger -> Bool
$c> :: NonPositiveInteger -> NonPositiveInteger -> Bool
> :: NonPositiveInteger -> NonPositiveInteger -> Bool
$c>= :: NonPositiveInteger -> NonPositiveInteger -> Bool
>= :: NonPositiveInteger -> NonPositiveInteger -> Bool
$cmax :: NonPositiveInteger -> NonPositiveInteger -> NonPositiveInteger
max :: NonPositiveInteger -> NonPositiveInteger -> NonPositiveInteger
$cmin :: NonPositiveInteger -> NonPositiveInteger -> NonPositiveInteger
min :: NonPositiveInteger -> NonPositiveInteger -> NonPositiveInteger
Ord, ReadPrec [NonPositiveInteger]
ReadPrec NonPositiveInteger
Int -> ReadS NonPositiveInteger
ReadS [NonPositiveInteger]
(Int -> ReadS NonPositiveInteger)
-> ReadS [NonPositiveInteger]
-> ReadPrec NonPositiveInteger
-> ReadPrec [NonPositiveInteger]
-> Read NonPositiveInteger
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS NonPositiveInteger
readsPrec :: Int -> ReadS NonPositiveInteger
$creadList :: ReadS [NonPositiveInteger]
readList :: ReadS [NonPositiveInteger]
$creadPrec :: ReadPrec NonPositiveInteger
readPrec :: ReadPrec NonPositiveInteger
$creadListPrec :: ReadPrec [NonPositiveInteger]
readListPrec :: ReadPrec [NonPositiveInteger]
Read, Int -> NonPositiveInteger -> String -> String
[NonPositiveInteger] -> String -> String
NonPositiveInteger -> String
(Int -> NonPositiveInteger -> String -> String)
-> (NonPositiveInteger -> String)
-> ([NonPositiveInteger] -> String -> String)
-> Show NonPositiveInteger
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> NonPositiveInteger -> String -> String
showsPrec :: Int -> NonPositiveInteger -> String -> String
$cshow :: NonPositiveInteger -> String
show :: NonPositiveInteger -> String
$cshowList :: [NonPositiveInteger] -> String -> String
showList :: [NonPositiveInteger] -> String -> String
Show)

_NonPositiveInteger :: Name
_NonPositiveInteger = (String -> Name
Core.Name String
"hydra/langs/xml/schema.NonPositiveInteger")

newtype NormalizedString = 
  NormalizedString {
    NormalizedString -> String
unNormalizedString :: String}
  deriving (NormalizedString -> NormalizedString -> Bool
(NormalizedString -> NormalizedString -> Bool)
-> (NormalizedString -> NormalizedString -> Bool)
-> Eq NormalizedString
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NormalizedString -> NormalizedString -> Bool
== :: NormalizedString -> NormalizedString -> Bool
$c/= :: NormalizedString -> NormalizedString -> Bool
/= :: NormalizedString -> NormalizedString -> Bool
Eq, Eq NormalizedString
Eq NormalizedString =>
(NormalizedString -> NormalizedString -> Ordering)
-> (NormalizedString -> NormalizedString -> Bool)
-> (NormalizedString -> NormalizedString -> Bool)
-> (NormalizedString -> NormalizedString -> Bool)
-> (NormalizedString -> NormalizedString -> Bool)
-> (NormalizedString -> NormalizedString -> NormalizedString)
-> (NormalizedString -> NormalizedString -> NormalizedString)
-> Ord NormalizedString
NormalizedString -> NormalizedString -> Bool
NormalizedString -> NormalizedString -> Ordering
NormalizedString -> NormalizedString -> NormalizedString
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: NormalizedString -> NormalizedString -> Ordering
compare :: NormalizedString -> NormalizedString -> Ordering
$c< :: NormalizedString -> NormalizedString -> Bool
< :: NormalizedString -> NormalizedString -> Bool
$c<= :: NormalizedString -> NormalizedString -> Bool
<= :: NormalizedString -> NormalizedString -> Bool
$c> :: NormalizedString -> NormalizedString -> Bool
> :: NormalizedString -> NormalizedString -> Bool
$c>= :: NormalizedString -> NormalizedString -> Bool
>= :: NormalizedString -> NormalizedString -> Bool
$cmax :: NormalizedString -> NormalizedString -> NormalizedString
max :: NormalizedString -> NormalizedString -> NormalizedString
$cmin :: NormalizedString -> NormalizedString -> NormalizedString
min :: NormalizedString -> NormalizedString -> NormalizedString
Ord, ReadPrec [NormalizedString]
ReadPrec NormalizedString
Int -> ReadS NormalizedString
ReadS [NormalizedString]
(Int -> ReadS NormalizedString)
-> ReadS [NormalizedString]
-> ReadPrec NormalizedString
-> ReadPrec [NormalizedString]
-> Read NormalizedString
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS NormalizedString
readsPrec :: Int -> ReadS NormalizedString
$creadList :: ReadS [NormalizedString]
readList :: ReadS [NormalizedString]
$creadPrec :: ReadPrec NormalizedString
readPrec :: ReadPrec NormalizedString
$creadListPrec :: ReadPrec [NormalizedString]
readListPrec :: ReadPrec [NormalizedString]
Read, Int -> NormalizedString -> String -> String
[NormalizedString] -> String -> String
NormalizedString -> String
(Int -> NormalizedString -> String -> String)
-> (NormalizedString -> String)
-> ([NormalizedString] -> String -> String)
-> Show NormalizedString
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> NormalizedString -> String -> String
showsPrec :: Int -> NormalizedString -> String -> String
$cshow :: NormalizedString -> String
show :: NormalizedString -> String
$cshowList :: [NormalizedString] -> String -> String
showList :: [NormalizedString] -> String -> String
Show)

_NormalizedString :: Name
_NormalizedString = (String -> Name
Core.Name String
"hydra/langs/xml/schema.NormalizedString")

newtype PositiveInteger = 
  PositiveInteger {
    PositiveInteger -> Integer
unPositiveInteger :: Integer}
  deriving (PositiveInteger -> PositiveInteger -> Bool
(PositiveInteger -> PositiveInteger -> Bool)
-> (PositiveInteger -> PositiveInteger -> Bool)
-> Eq PositiveInteger
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PositiveInteger -> PositiveInteger -> Bool
== :: PositiveInteger -> PositiveInteger -> Bool
$c/= :: PositiveInteger -> PositiveInteger -> Bool
/= :: PositiveInteger -> PositiveInteger -> Bool
Eq, Eq PositiveInteger
Eq PositiveInteger =>
(PositiveInteger -> PositiveInteger -> Ordering)
-> (PositiveInteger -> PositiveInteger -> Bool)
-> (PositiveInteger -> PositiveInteger -> Bool)
-> (PositiveInteger -> PositiveInteger -> Bool)
-> (PositiveInteger -> PositiveInteger -> Bool)
-> (PositiveInteger -> PositiveInteger -> PositiveInteger)
-> (PositiveInteger -> PositiveInteger -> PositiveInteger)
-> Ord PositiveInteger
PositiveInteger -> PositiveInteger -> Bool
PositiveInteger -> PositiveInteger -> Ordering
PositiveInteger -> PositiveInteger -> PositiveInteger
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: PositiveInteger -> PositiveInteger -> Ordering
compare :: PositiveInteger -> PositiveInteger -> Ordering
$c< :: PositiveInteger -> PositiveInteger -> Bool
< :: PositiveInteger -> PositiveInteger -> Bool
$c<= :: PositiveInteger -> PositiveInteger -> Bool
<= :: PositiveInteger -> PositiveInteger -> Bool
$c> :: PositiveInteger -> PositiveInteger -> Bool
> :: PositiveInteger -> PositiveInteger -> Bool
$c>= :: PositiveInteger -> PositiveInteger -> Bool
>= :: PositiveInteger -> PositiveInteger -> Bool
$cmax :: PositiveInteger -> PositiveInteger -> PositiveInteger
max :: PositiveInteger -> PositiveInteger -> PositiveInteger
$cmin :: PositiveInteger -> PositiveInteger -> PositiveInteger
min :: PositiveInteger -> PositiveInteger -> PositiveInteger
Ord, ReadPrec [PositiveInteger]
ReadPrec PositiveInteger
Int -> ReadS PositiveInteger
ReadS [PositiveInteger]
(Int -> ReadS PositiveInteger)
-> ReadS [PositiveInteger]
-> ReadPrec PositiveInteger
-> ReadPrec [PositiveInteger]
-> Read PositiveInteger
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS PositiveInteger
readsPrec :: Int -> ReadS PositiveInteger
$creadList :: ReadS [PositiveInteger]
readList :: ReadS [PositiveInteger]
$creadPrec :: ReadPrec PositiveInteger
readPrec :: ReadPrec PositiveInteger
$creadListPrec :: ReadPrec [PositiveInteger]
readListPrec :: ReadPrec [PositiveInteger]
Read, Int -> PositiveInteger -> String -> String
[PositiveInteger] -> String -> String
PositiveInteger -> String
(Int -> PositiveInteger -> String -> String)
-> (PositiveInteger -> String)
-> ([PositiveInteger] -> String -> String)
-> Show PositiveInteger
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> PositiveInteger -> String -> String
showsPrec :: Int -> PositiveInteger -> String -> String
$cshow :: PositiveInteger -> String
show :: PositiveInteger -> String
$cshowList :: [PositiveInteger] -> String -> String
showList :: [PositiveInteger] -> String -> String
Show)

_PositiveInteger :: Name
_PositiveInteger = (String -> Name
Core.Name String
"hydra/langs/xml/schema.PositiveInteger")

newtype QName = 
  QName {
    QName -> String
unQName :: String}
  deriving (QName -> QName -> Bool
(QName -> QName -> Bool) -> (QName -> QName -> Bool) -> Eq QName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: QName -> QName -> Bool
== :: QName -> QName -> Bool
$c/= :: QName -> QName -> Bool
/= :: QName -> QName -> Bool
Eq, Eq QName
Eq QName =>
(QName -> QName -> Ordering)
-> (QName -> QName -> Bool)
-> (QName -> QName -> Bool)
-> (QName -> QName -> Bool)
-> (QName -> QName -> Bool)
-> (QName -> QName -> QName)
-> (QName -> QName -> QName)
-> Ord QName
QName -> QName -> Bool
QName -> QName -> Ordering
QName -> QName -> QName
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: QName -> QName -> Ordering
compare :: QName -> QName -> Ordering
$c< :: QName -> QName -> Bool
< :: QName -> QName -> Bool
$c<= :: QName -> QName -> Bool
<= :: QName -> QName -> Bool
$c> :: QName -> QName -> Bool
> :: QName -> QName -> Bool
$c>= :: QName -> QName -> Bool
>= :: QName -> QName -> Bool
$cmax :: QName -> QName -> QName
max :: QName -> QName -> QName
$cmin :: QName -> QName -> QName
min :: QName -> QName -> QName
Ord, ReadPrec [QName]
ReadPrec QName
Int -> ReadS QName
ReadS [QName]
(Int -> ReadS QName)
-> ReadS [QName]
-> ReadPrec QName
-> ReadPrec [QName]
-> Read QName
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS QName
readsPrec :: Int -> ReadS QName
$creadList :: ReadS [QName]
readList :: ReadS [QName]
$creadPrec :: ReadPrec QName
readPrec :: ReadPrec QName
$creadListPrec :: ReadPrec [QName]
readListPrec :: ReadPrec [QName]
Read, Int -> QName -> String -> String
[QName] -> String -> String
QName -> String
(Int -> QName -> String -> String)
-> (QName -> String) -> ([QName] -> String -> String) -> Show QName
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> QName -> String -> String
showsPrec :: Int -> QName -> String -> String
$cshow :: QName -> String
show :: QName -> String
$cshowList :: [QName] -> String -> String
showList :: [QName] -> String -> String
Show)

_QName :: Name
_QName = (String -> Name
Core.Name String
"hydra/langs/xml/schema.QName")

newtype Short = 
  Short {
    Short -> Int16
unShort :: Int16}
  deriving (Short -> Short -> Bool
(Short -> Short -> Bool) -> (Short -> Short -> Bool) -> Eq Short
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Short -> Short -> Bool
== :: Short -> Short -> Bool
$c/= :: Short -> Short -> Bool
/= :: Short -> Short -> Bool
Eq, Eq Short
Eq Short =>
(Short -> Short -> Ordering)
-> (Short -> Short -> Bool)
-> (Short -> Short -> Bool)
-> (Short -> Short -> Bool)
-> (Short -> Short -> Bool)
-> (Short -> Short -> Short)
-> (Short -> Short -> Short)
-> Ord Short
Short -> Short -> Bool
Short -> Short -> Ordering
Short -> Short -> Short
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Short -> Short -> Ordering
compare :: Short -> Short -> Ordering
$c< :: Short -> Short -> Bool
< :: Short -> Short -> Bool
$c<= :: Short -> Short -> Bool
<= :: Short -> Short -> Bool
$c> :: Short -> Short -> Bool
> :: Short -> Short -> Bool
$c>= :: Short -> Short -> Bool
>= :: Short -> Short -> Bool
$cmax :: Short -> Short -> Short
max :: Short -> Short -> Short
$cmin :: Short -> Short -> Short
min :: Short -> Short -> Short
Ord, ReadPrec [Short]
ReadPrec Short
Int -> ReadS Short
ReadS [Short]
(Int -> ReadS Short)
-> ReadS [Short]
-> ReadPrec Short
-> ReadPrec [Short]
-> Read Short
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Short
readsPrec :: Int -> ReadS Short
$creadList :: ReadS [Short]
readList :: ReadS [Short]
$creadPrec :: ReadPrec Short
readPrec :: ReadPrec Short
$creadListPrec :: ReadPrec [Short]
readListPrec :: ReadPrec [Short]
Read, Int -> Short -> String -> String
[Short] -> String -> String
Short -> String
(Int -> Short -> String -> String)
-> (Short -> String) -> ([Short] -> String -> String) -> Show Short
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Short -> String -> String
showsPrec :: Int -> Short -> String -> String
$cshow :: Short -> String
show :: Short -> String
$cshowList :: [Short] -> String -> String
showList :: [Short] -> String -> String
Show)

_Short :: Name
_Short = (String -> Name
Core.Name String
"hydra/langs/xml/schema.Short")

newtype String_ = 
  String_ {
    String_ -> String
unString :: String}
  deriving (String_ -> String_ -> Bool
(String_ -> String_ -> Bool)
-> (String_ -> String_ -> Bool) -> Eq String_
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: String_ -> String_ -> Bool
== :: String_ -> String_ -> Bool
$c/= :: String_ -> String_ -> Bool
/= :: String_ -> String_ -> Bool
Eq, Eq String_
Eq String_ =>
(String_ -> String_ -> Ordering)
-> (String_ -> String_ -> Bool)
-> (String_ -> String_ -> Bool)
-> (String_ -> String_ -> Bool)
-> (String_ -> String_ -> Bool)
-> (String_ -> String_ -> String_)
-> (String_ -> String_ -> String_)
-> Ord String_
String_ -> String_ -> Bool
String_ -> String_ -> Ordering
String_ -> String_ -> String_
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: String_ -> String_ -> Ordering
compare :: String_ -> String_ -> Ordering
$c< :: String_ -> String_ -> Bool
< :: String_ -> String_ -> Bool
$c<= :: String_ -> String_ -> Bool
<= :: String_ -> String_ -> Bool
$c> :: String_ -> String_ -> Bool
> :: String_ -> String_ -> Bool
$c>= :: String_ -> String_ -> Bool
>= :: String_ -> String_ -> Bool
$cmax :: String_ -> String_ -> String_
max :: String_ -> String_ -> String_
$cmin :: String_ -> String_ -> String_
min :: String_ -> String_ -> String_
Ord, ReadPrec [String_]
ReadPrec String_
Int -> ReadS String_
ReadS [String_]
(Int -> ReadS String_)
-> ReadS [String_]
-> ReadPrec String_
-> ReadPrec [String_]
-> Read String_
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS String_
readsPrec :: Int -> ReadS String_
$creadList :: ReadS [String_]
readList :: ReadS [String_]
$creadPrec :: ReadPrec String_
readPrec :: ReadPrec String_
$creadListPrec :: ReadPrec [String_]
readListPrec :: ReadPrec [String_]
Read, Int -> String_ -> String -> String
[String_] -> String -> String
String_ -> String
(Int -> String_ -> String -> String)
-> (String_ -> String)
-> ([String_] -> String -> String)
-> Show String_
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> String_ -> String -> String
showsPrec :: Int -> String_ -> String -> String
$cshow :: String_ -> String
show :: String_ -> String
$cshowList :: [String_] -> String -> String
showList :: [String_] -> String -> String
Show)

_String :: Name
_String = (String -> Name
Core.Name String
"hydra/langs/xml/schema.String")

newtype Time = 
  Time {
    Time -> String
unTime :: String}
  deriving (Time -> Time -> Bool
(Time -> Time -> Bool) -> (Time -> Time -> Bool) -> Eq Time
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Time -> Time -> Bool
== :: Time -> Time -> Bool
$c/= :: Time -> Time -> Bool
/= :: Time -> Time -> Bool
Eq, Eq Time
Eq Time =>
(Time -> Time -> Ordering)
-> (Time -> Time -> Bool)
-> (Time -> Time -> Bool)
-> (Time -> Time -> Bool)
-> (Time -> Time -> Bool)
-> (Time -> Time -> Time)
-> (Time -> Time -> Time)
-> Ord Time
Time -> Time -> Bool
Time -> Time -> Ordering
Time -> Time -> Time
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Time -> Time -> Ordering
compare :: Time -> Time -> Ordering
$c< :: Time -> Time -> Bool
< :: Time -> Time -> Bool
$c<= :: Time -> Time -> Bool
<= :: Time -> Time -> Bool
$c> :: Time -> Time -> Bool
> :: Time -> Time -> Bool
$c>= :: Time -> Time -> Bool
>= :: Time -> Time -> Bool
$cmax :: Time -> Time -> Time
max :: Time -> Time -> Time
$cmin :: Time -> Time -> Time
min :: Time -> Time -> Time
Ord, ReadPrec [Time]
ReadPrec Time
Int -> ReadS Time
ReadS [Time]
(Int -> ReadS Time)
-> ReadS [Time] -> ReadPrec Time -> ReadPrec [Time] -> Read Time
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Time
readsPrec :: Int -> ReadS Time
$creadList :: ReadS [Time]
readList :: ReadS [Time]
$creadPrec :: ReadPrec Time
readPrec :: ReadPrec Time
$creadListPrec :: ReadPrec [Time]
readListPrec :: ReadPrec [Time]
Read, Int -> Time -> String -> String
[Time] -> String -> String
Time -> String
(Int -> Time -> String -> String)
-> (Time -> String) -> ([Time] -> String -> String) -> Show Time
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Time -> String -> String
showsPrec :: Int -> Time -> String -> String
$cshow :: Time -> String
show :: Time -> String
$cshowList :: [Time] -> String -> String
showList :: [Time] -> String -> String
Show)

_Time :: Name
_Time = (String -> Name
Core.Name String
"hydra/langs/xml/schema.Time")

newtype Token = 
  Token {
    Token -> String
unToken :: String}
  deriving (Token -> Token -> Bool
(Token -> Token -> Bool) -> (Token -> Token -> Bool) -> Eq Token
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Token -> Token -> Bool
== :: Token -> Token -> Bool
$c/= :: Token -> Token -> Bool
/= :: Token -> Token -> Bool
Eq, Eq Token
Eq Token =>
(Token -> Token -> Ordering)
-> (Token -> Token -> Bool)
-> (Token -> Token -> Bool)
-> (Token -> Token -> Bool)
-> (Token -> Token -> Bool)
-> (Token -> Token -> Token)
-> (Token -> Token -> Token)
-> Ord Token
Token -> Token -> Bool
Token -> Token -> Ordering
Token -> Token -> Token
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Token -> Token -> Ordering
compare :: Token -> Token -> Ordering
$c< :: Token -> Token -> Bool
< :: Token -> Token -> Bool
$c<= :: Token -> Token -> Bool
<= :: Token -> Token -> Bool
$c> :: Token -> Token -> Bool
> :: Token -> Token -> Bool
$c>= :: Token -> Token -> Bool
>= :: Token -> Token -> Bool
$cmax :: Token -> Token -> Token
max :: Token -> Token -> Token
$cmin :: Token -> Token -> Token
min :: Token -> Token -> Token
Ord, ReadPrec [Token]
ReadPrec Token
Int -> ReadS Token
ReadS [Token]
(Int -> ReadS Token)
-> ReadS [Token]
-> ReadPrec Token
-> ReadPrec [Token]
-> Read Token
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Token
readsPrec :: Int -> ReadS Token
$creadList :: ReadS [Token]
readList :: ReadS [Token]
$creadPrec :: ReadPrec Token
readPrec :: ReadPrec Token
$creadListPrec :: ReadPrec [Token]
readListPrec :: ReadPrec [Token]
Read, Int -> Token -> String -> String
[Token] -> String -> String
Token -> String
(Int -> Token -> String -> String)
-> (Token -> String) -> ([Token] -> String -> String) -> Show Token
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Token -> String -> String
showsPrec :: Int -> Token -> String -> String
$cshow :: Token -> String
show :: Token -> String
$cshowList :: [Token] -> String -> String
showList :: [Token] -> String -> String
Show)

_Token :: Name
_Token = (String -> Name
Core.Name String
"hydra/langs/xml/schema.Token")

newtype UnsignedByte = 
  UnsignedByte {
    UnsignedByte -> Int16
unUnsignedByte :: Int16}
  deriving (UnsignedByte -> UnsignedByte -> Bool
(UnsignedByte -> UnsignedByte -> Bool)
-> (UnsignedByte -> UnsignedByte -> Bool) -> Eq UnsignedByte
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: UnsignedByte -> UnsignedByte -> Bool
== :: UnsignedByte -> UnsignedByte -> Bool
$c/= :: UnsignedByte -> UnsignedByte -> Bool
/= :: UnsignedByte -> UnsignedByte -> Bool
Eq, Eq UnsignedByte
Eq UnsignedByte =>
(UnsignedByte -> UnsignedByte -> Ordering)
-> (UnsignedByte -> UnsignedByte -> Bool)
-> (UnsignedByte -> UnsignedByte -> Bool)
-> (UnsignedByte -> UnsignedByte -> Bool)
-> (UnsignedByte -> UnsignedByte -> Bool)
-> (UnsignedByte -> UnsignedByte -> UnsignedByte)
-> (UnsignedByte -> UnsignedByte -> UnsignedByte)
-> Ord UnsignedByte
UnsignedByte -> UnsignedByte -> Bool
UnsignedByte -> UnsignedByte -> Ordering
UnsignedByte -> UnsignedByte -> UnsignedByte
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: UnsignedByte -> UnsignedByte -> Ordering
compare :: UnsignedByte -> UnsignedByte -> Ordering
$c< :: UnsignedByte -> UnsignedByte -> Bool
< :: UnsignedByte -> UnsignedByte -> Bool
$c<= :: UnsignedByte -> UnsignedByte -> Bool
<= :: UnsignedByte -> UnsignedByte -> Bool
$c> :: UnsignedByte -> UnsignedByte -> Bool
> :: UnsignedByte -> UnsignedByte -> Bool
$c>= :: UnsignedByte -> UnsignedByte -> Bool
>= :: UnsignedByte -> UnsignedByte -> Bool
$cmax :: UnsignedByte -> UnsignedByte -> UnsignedByte
max :: UnsignedByte -> UnsignedByte -> UnsignedByte
$cmin :: UnsignedByte -> UnsignedByte -> UnsignedByte
min :: UnsignedByte -> UnsignedByte -> UnsignedByte
Ord, ReadPrec [UnsignedByte]
ReadPrec UnsignedByte
Int -> ReadS UnsignedByte
ReadS [UnsignedByte]
(Int -> ReadS UnsignedByte)
-> ReadS [UnsignedByte]
-> ReadPrec UnsignedByte
-> ReadPrec [UnsignedByte]
-> Read UnsignedByte
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS UnsignedByte
readsPrec :: Int -> ReadS UnsignedByte
$creadList :: ReadS [UnsignedByte]
readList :: ReadS [UnsignedByte]
$creadPrec :: ReadPrec UnsignedByte
readPrec :: ReadPrec UnsignedByte
$creadListPrec :: ReadPrec [UnsignedByte]
readListPrec :: ReadPrec [UnsignedByte]
Read, Int -> UnsignedByte -> String -> String
[UnsignedByte] -> String -> String
UnsignedByte -> String
(Int -> UnsignedByte -> String -> String)
-> (UnsignedByte -> String)
-> ([UnsignedByte] -> String -> String)
-> Show UnsignedByte
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> UnsignedByte -> String -> String
showsPrec :: Int -> UnsignedByte -> String -> String
$cshow :: UnsignedByte -> String
show :: UnsignedByte -> String
$cshowList :: [UnsignedByte] -> String -> String
showList :: [UnsignedByte] -> String -> String
Show)

_UnsignedByte :: Name
_UnsignedByte = (String -> Name
Core.Name String
"hydra/langs/xml/schema.UnsignedByte")

newtype UnsignedInt = 
  UnsignedInt {
    UnsignedInt -> Int64
unUnsignedInt :: Int64}
  deriving (UnsignedInt -> UnsignedInt -> Bool
(UnsignedInt -> UnsignedInt -> Bool)
-> (UnsignedInt -> UnsignedInt -> Bool) -> Eq UnsignedInt
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: UnsignedInt -> UnsignedInt -> Bool
== :: UnsignedInt -> UnsignedInt -> Bool
$c/= :: UnsignedInt -> UnsignedInt -> Bool
/= :: UnsignedInt -> UnsignedInt -> Bool
Eq, Eq UnsignedInt
Eq UnsignedInt =>
(UnsignedInt -> UnsignedInt -> Ordering)
-> (UnsignedInt -> UnsignedInt -> Bool)
-> (UnsignedInt -> UnsignedInt -> Bool)
-> (UnsignedInt -> UnsignedInt -> Bool)
-> (UnsignedInt -> UnsignedInt -> Bool)
-> (UnsignedInt -> UnsignedInt -> UnsignedInt)
-> (UnsignedInt -> UnsignedInt -> UnsignedInt)
-> Ord UnsignedInt
UnsignedInt -> UnsignedInt -> Bool
UnsignedInt -> UnsignedInt -> Ordering
UnsignedInt -> UnsignedInt -> UnsignedInt
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: UnsignedInt -> UnsignedInt -> Ordering
compare :: UnsignedInt -> UnsignedInt -> Ordering
$c< :: UnsignedInt -> UnsignedInt -> Bool
< :: UnsignedInt -> UnsignedInt -> Bool
$c<= :: UnsignedInt -> UnsignedInt -> Bool
<= :: UnsignedInt -> UnsignedInt -> Bool
$c> :: UnsignedInt -> UnsignedInt -> Bool
> :: UnsignedInt -> UnsignedInt -> Bool
$c>= :: UnsignedInt -> UnsignedInt -> Bool
>= :: UnsignedInt -> UnsignedInt -> Bool
$cmax :: UnsignedInt -> UnsignedInt -> UnsignedInt
max :: UnsignedInt -> UnsignedInt -> UnsignedInt
$cmin :: UnsignedInt -> UnsignedInt -> UnsignedInt
min :: UnsignedInt -> UnsignedInt -> UnsignedInt
Ord, ReadPrec [UnsignedInt]
ReadPrec UnsignedInt
Int -> ReadS UnsignedInt
ReadS [UnsignedInt]
(Int -> ReadS UnsignedInt)
-> ReadS [UnsignedInt]
-> ReadPrec UnsignedInt
-> ReadPrec [UnsignedInt]
-> Read UnsignedInt
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS UnsignedInt
readsPrec :: Int -> ReadS UnsignedInt
$creadList :: ReadS [UnsignedInt]
readList :: ReadS [UnsignedInt]
$creadPrec :: ReadPrec UnsignedInt
readPrec :: ReadPrec UnsignedInt
$creadListPrec :: ReadPrec [UnsignedInt]
readListPrec :: ReadPrec [UnsignedInt]
Read, Int -> UnsignedInt -> String -> String
[UnsignedInt] -> String -> String
UnsignedInt -> String
(Int -> UnsignedInt -> String -> String)
-> (UnsignedInt -> String)
-> ([UnsignedInt] -> String -> String)
-> Show UnsignedInt
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> UnsignedInt -> String -> String
showsPrec :: Int -> UnsignedInt -> String -> String
$cshow :: UnsignedInt -> String
show :: UnsignedInt -> String
$cshowList :: [UnsignedInt] -> String -> String
showList :: [UnsignedInt] -> String -> String
Show)

_UnsignedInt :: Name
_UnsignedInt = (String -> Name
Core.Name String
"hydra/langs/xml/schema.UnsignedInt")

newtype UnsignedLong = 
  UnsignedLong {
    UnsignedLong -> Integer
unUnsignedLong :: Integer}
  deriving (UnsignedLong -> UnsignedLong -> Bool
(UnsignedLong -> UnsignedLong -> Bool)
-> (UnsignedLong -> UnsignedLong -> Bool) -> Eq UnsignedLong
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: UnsignedLong -> UnsignedLong -> Bool
== :: UnsignedLong -> UnsignedLong -> Bool
$c/= :: UnsignedLong -> UnsignedLong -> Bool
/= :: UnsignedLong -> UnsignedLong -> Bool
Eq, Eq UnsignedLong
Eq UnsignedLong =>
(UnsignedLong -> UnsignedLong -> Ordering)
-> (UnsignedLong -> UnsignedLong -> Bool)
-> (UnsignedLong -> UnsignedLong -> Bool)
-> (UnsignedLong -> UnsignedLong -> Bool)
-> (UnsignedLong -> UnsignedLong -> Bool)
-> (UnsignedLong -> UnsignedLong -> UnsignedLong)
-> (UnsignedLong -> UnsignedLong -> UnsignedLong)
-> Ord UnsignedLong
UnsignedLong -> UnsignedLong -> Bool
UnsignedLong -> UnsignedLong -> Ordering
UnsignedLong -> UnsignedLong -> UnsignedLong
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: UnsignedLong -> UnsignedLong -> Ordering
compare :: UnsignedLong -> UnsignedLong -> Ordering
$c< :: UnsignedLong -> UnsignedLong -> Bool
< :: UnsignedLong -> UnsignedLong -> Bool
$c<= :: UnsignedLong -> UnsignedLong -> Bool
<= :: UnsignedLong -> UnsignedLong -> Bool
$c> :: UnsignedLong -> UnsignedLong -> Bool
> :: UnsignedLong -> UnsignedLong -> Bool
$c>= :: UnsignedLong -> UnsignedLong -> Bool
>= :: UnsignedLong -> UnsignedLong -> Bool
$cmax :: UnsignedLong -> UnsignedLong -> UnsignedLong
max :: UnsignedLong -> UnsignedLong -> UnsignedLong
$cmin :: UnsignedLong -> UnsignedLong -> UnsignedLong
min :: UnsignedLong -> UnsignedLong -> UnsignedLong
Ord, ReadPrec [UnsignedLong]
ReadPrec UnsignedLong
Int -> ReadS UnsignedLong
ReadS [UnsignedLong]
(Int -> ReadS UnsignedLong)
-> ReadS [UnsignedLong]
-> ReadPrec UnsignedLong
-> ReadPrec [UnsignedLong]
-> Read UnsignedLong
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS UnsignedLong
readsPrec :: Int -> ReadS UnsignedLong
$creadList :: ReadS [UnsignedLong]
readList :: ReadS [UnsignedLong]
$creadPrec :: ReadPrec UnsignedLong
readPrec :: ReadPrec UnsignedLong
$creadListPrec :: ReadPrec [UnsignedLong]
readListPrec :: ReadPrec [UnsignedLong]
Read, Int -> UnsignedLong -> String -> String
[UnsignedLong] -> String -> String
UnsignedLong -> String
(Int -> UnsignedLong -> String -> String)
-> (UnsignedLong -> String)
-> ([UnsignedLong] -> String -> String)
-> Show UnsignedLong
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> UnsignedLong -> String -> String
showsPrec :: Int -> UnsignedLong -> String -> String
$cshow :: UnsignedLong -> String
show :: UnsignedLong -> String
$cshowList :: [UnsignedLong] -> String -> String
showList :: [UnsignedLong] -> String -> String
Show)

_UnsignedLong :: Name
_UnsignedLong = (String -> Name
Core.Name String
"hydra/langs/xml/schema.UnsignedLong")

newtype UnsignedShort = 
  UnsignedShort {
    UnsignedShort -> Int
unUnsignedShort :: Int}
  deriving (UnsignedShort -> UnsignedShort -> Bool
(UnsignedShort -> UnsignedShort -> Bool)
-> (UnsignedShort -> UnsignedShort -> Bool) -> Eq UnsignedShort
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: UnsignedShort -> UnsignedShort -> Bool
== :: UnsignedShort -> UnsignedShort -> Bool
$c/= :: UnsignedShort -> UnsignedShort -> Bool
/= :: UnsignedShort -> UnsignedShort -> Bool
Eq, Eq UnsignedShort
Eq UnsignedShort =>
(UnsignedShort -> UnsignedShort -> Ordering)
-> (UnsignedShort -> UnsignedShort -> Bool)
-> (UnsignedShort -> UnsignedShort -> Bool)
-> (UnsignedShort -> UnsignedShort -> Bool)
-> (UnsignedShort -> UnsignedShort -> Bool)
-> (UnsignedShort -> UnsignedShort -> UnsignedShort)
-> (UnsignedShort -> UnsignedShort -> UnsignedShort)
-> Ord UnsignedShort
UnsignedShort -> UnsignedShort -> Bool
UnsignedShort -> UnsignedShort -> Ordering
UnsignedShort -> UnsignedShort -> UnsignedShort
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: UnsignedShort -> UnsignedShort -> Ordering
compare :: UnsignedShort -> UnsignedShort -> Ordering
$c< :: UnsignedShort -> UnsignedShort -> Bool
< :: UnsignedShort -> UnsignedShort -> Bool
$c<= :: UnsignedShort -> UnsignedShort -> Bool
<= :: UnsignedShort -> UnsignedShort -> Bool
$c> :: UnsignedShort -> UnsignedShort -> Bool
> :: UnsignedShort -> UnsignedShort -> Bool
$c>= :: UnsignedShort -> UnsignedShort -> Bool
>= :: UnsignedShort -> UnsignedShort -> Bool
$cmax :: UnsignedShort -> UnsignedShort -> UnsignedShort
max :: UnsignedShort -> UnsignedShort -> UnsignedShort
$cmin :: UnsignedShort -> UnsignedShort -> UnsignedShort
min :: UnsignedShort -> UnsignedShort -> UnsignedShort
Ord, ReadPrec [UnsignedShort]
ReadPrec UnsignedShort
Int -> ReadS UnsignedShort
ReadS [UnsignedShort]
(Int -> ReadS UnsignedShort)
-> ReadS [UnsignedShort]
-> ReadPrec UnsignedShort
-> ReadPrec [UnsignedShort]
-> Read UnsignedShort
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS UnsignedShort
readsPrec :: Int -> ReadS UnsignedShort
$creadList :: ReadS [UnsignedShort]
readList :: ReadS [UnsignedShort]
$creadPrec :: ReadPrec UnsignedShort
readPrec :: ReadPrec UnsignedShort
$creadListPrec :: ReadPrec [UnsignedShort]
readListPrec :: ReadPrec [UnsignedShort]
Read, Int -> UnsignedShort -> String -> String
[UnsignedShort] -> String -> String
UnsignedShort -> String
(Int -> UnsignedShort -> String -> String)
-> (UnsignedShort -> String)
-> ([UnsignedShort] -> String -> String)
-> Show UnsignedShort
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> UnsignedShort -> String -> String
showsPrec :: Int -> UnsignedShort -> String -> String
$cshow :: UnsignedShort -> String
show :: UnsignedShort -> String
$cshowList :: [UnsignedShort] -> String -> String
showList :: [UnsignedShort] -> String -> String
Show)

_UnsignedShort :: Name
_UnsignedShort = (String -> Name
Core.Name String
"hydra/langs/xml/schema.UnsignedShort")

-- | See https://www.w3.org/TR/xmlschema-2/#non-fundamental
data ConstrainingFacet = 
  ConstrainingFacet {}
  deriving (ConstrainingFacet -> ConstrainingFacet -> Bool
(ConstrainingFacet -> ConstrainingFacet -> Bool)
-> (ConstrainingFacet -> ConstrainingFacet -> Bool)
-> Eq ConstrainingFacet
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ConstrainingFacet -> ConstrainingFacet -> Bool
== :: ConstrainingFacet -> ConstrainingFacet -> Bool
$c/= :: ConstrainingFacet -> ConstrainingFacet -> Bool
/= :: ConstrainingFacet -> ConstrainingFacet -> Bool
Eq, Eq ConstrainingFacet
Eq ConstrainingFacet =>
(ConstrainingFacet -> ConstrainingFacet -> Ordering)
-> (ConstrainingFacet -> ConstrainingFacet -> Bool)
-> (ConstrainingFacet -> ConstrainingFacet -> Bool)
-> (ConstrainingFacet -> ConstrainingFacet -> Bool)
-> (ConstrainingFacet -> ConstrainingFacet -> Bool)
-> (ConstrainingFacet -> ConstrainingFacet -> ConstrainingFacet)
-> (ConstrainingFacet -> ConstrainingFacet -> ConstrainingFacet)
-> Ord ConstrainingFacet
ConstrainingFacet -> ConstrainingFacet -> Bool
ConstrainingFacet -> ConstrainingFacet -> Ordering
ConstrainingFacet -> ConstrainingFacet -> ConstrainingFacet
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ConstrainingFacet -> ConstrainingFacet -> Ordering
compare :: ConstrainingFacet -> ConstrainingFacet -> Ordering
$c< :: ConstrainingFacet -> ConstrainingFacet -> Bool
< :: ConstrainingFacet -> ConstrainingFacet -> Bool
$c<= :: ConstrainingFacet -> ConstrainingFacet -> Bool
<= :: ConstrainingFacet -> ConstrainingFacet -> Bool
$c> :: ConstrainingFacet -> ConstrainingFacet -> Bool
> :: ConstrainingFacet -> ConstrainingFacet -> Bool
$c>= :: ConstrainingFacet -> ConstrainingFacet -> Bool
>= :: ConstrainingFacet -> ConstrainingFacet -> Bool
$cmax :: ConstrainingFacet -> ConstrainingFacet -> ConstrainingFacet
max :: ConstrainingFacet -> ConstrainingFacet -> ConstrainingFacet
$cmin :: ConstrainingFacet -> ConstrainingFacet -> ConstrainingFacet
min :: ConstrainingFacet -> ConstrainingFacet -> ConstrainingFacet
Ord, ReadPrec [ConstrainingFacet]
ReadPrec ConstrainingFacet
Int -> ReadS ConstrainingFacet
ReadS [ConstrainingFacet]
(Int -> ReadS ConstrainingFacet)
-> ReadS [ConstrainingFacet]
-> ReadPrec ConstrainingFacet
-> ReadPrec [ConstrainingFacet]
-> Read ConstrainingFacet
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ConstrainingFacet
readsPrec :: Int -> ReadS ConstrainingFacet
$creadList :: ReadS [ConstrainingFacet]
readList :: ReadS [ConstrainingFacet]
$creadPrec :: ReadPrec ConstrainingFacet
readPrec :: ReadPrec ConstrainingFacet
$creadListPrec :: ReadPrec [ConstrainingFacet]
readListPrec :: ReadPrec [ConstrainingFacet]
Read, Int -> ConstrainingFacet -> String -> String
[ConstrainingFacet] -> String -> String
ConstrainingFacet -> String
(Int -> ConstrainingFacet -> String -> String)
-> (ConstrainingFacet -> String)
-> ([ConstrainingFacet] -> String -> String)
-> Show ConstrainingFacet
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> ConstrainingFacet -> String -> String
showsPrec :: Int -> ConstrainingFacet -> String -> String
$cshow :: ConstrainingFacet -> String
show :: ConstrainingFacet -> String
$cshowList :: [ConstrainingFacet] -> String -> String
showList :: [ConstrainingFacet] -> String -> String
Show)

_ConstrainingFacet :: Name
_ConstrainingFacet = (String -> Name
Core.Name String
"hydra/langs/xml/schema.ConstrainingFacet")

data Datatype = 
  DatatypeAnySimpleType  |
  DatatypeAnyType  |
  DatatypeAnyURI  |
  DatatypeBase64Binary  |
  DatatypeBoolean  |
  DatatypeByte  |
  DatatypeDate  |
  DatatypeDateTime  |
  DatatypeDecimal  |
  DatatypeDouble  |
  DatatypeDuration  |
  DatatypeENTITIES  |
  DatatypeENTITY  |
  DatatypeFloat  |
  DatatypeGDay  |
  DatatypeGMonth  |
  DatatypeGMonthDay  |
  DatatypeGYear  |
  DatatypeGYearMonth  |
  DatatypeHexBinary  |
  DatatypeID  |
  DatatypeIDREF  |
  DatatypeIDREFS  |
  DatatypeInt  |
  DatatypeInteger  |
  DatatypeLanguage  |
  DatatypeLong  |
  DatatypeNMTOKEN  |
  DatatypeNOTATION  |
  DatatypeName  |
  DatatypeNegativeInteger  |
  DatatypeNonNegativeInteger  |
  DatatypeNonPositiveInteger  |
  DatatypeNormalizedString  |
  DatatypePositiveInteger  |
  DatatypeQName  |
  DatatypeShort  |
  DatatypeString  |
  DatatypeTime  |
  DatatypeToken  |
  DatatypeUnsignedByte  |
  DatatypeUnsignedInt  |
  DatatypeUnsignedLong  |
  DatatypeUnsignedShort 
  deriving (Datatype -> Datatype -> Bool
(Datatype -> Datatype -> Bool)
-> (Datatype -> Datatype -> Bool) -> Eq Datatype
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Datatype -> Datatype -> Bool
== :: Datatype -> Datatype -> Bool
$c/= :: Datatype -> Datatype -> Bool
/= :: Datatype -> Datatype -> Bool
Eq, Eq Datatype
Eq Datatype =>
(Datatype -> Datatype -> Ordering)
-> (Datatype -> Datatype -> Bool)
-> (Datatype -> Datatype -> Bool)
-> (Datatype -> Datatype -> Bool)
-> (Datatype -> Datatype -> Bool)
-> (Datatype -> Datatype -> Datatype)
-> (Datatype -> Datatype -> Datatype)
-> Ord Datatype
Datatype -> Datatype -> Bool
Datatype -> Datatype -> Ordering
Datatype -> Datatype -> Datatype
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Datatype -> Datatype -> Ordering
compare :: Datatype -> Datatype -> Ordering
$c< :: Datatype -> Datatype -> Bool
< :: Datatype -> Datatype -> Bool
$c<= :: Datatype -> Datatype -> Bool
<= :: Datatype -> Datatype -> Bool
$c> :: Datatype -> Datatype -> Bool
> :: Datatype -> Datatype -> Bool
$c>= :: Datatype -> Datatype -> Bool
>= :: Datatype -> Datatype -> Bool
$cmax :: Datatype -> Datatype -> Datatype
max :: Datatype -> Datatype -> Datatype
$cmin :: Datatype -> Datatype -> Datatype
min :: Datatype -> Datatype -> Datatype
Ord, ReadPrec [Datatype]
ReadPrec Datatype
Int -> ReadS Datatype
ReadS [Datatype]
(Int -> ReadS Datatype)
-> ReadS [Datatype]
-> ReadPrec Datatype
-> ReadPrec [Datatype]
-> Read Datatype
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Datatype
readsPrec :: Int -> ReadS Datatype
$creadList :: ReadS [Datatype]
readList :: ReadS [Datatype]
$creadPrec :: ReadPrec Datatype
readPrec :: ReadPrec Datatype
$creadListPrec :: ReadPrec [Datatype]
readListPrec :: ReadPrec [Datatype]
Read, Int -> Datatype -> String -> String
[Datatype] -> String -> String
Datatype -> String
(Int -> Datatype -> String -> String)
-> (Datatype -> String)
-> ([Datatype] -> String -> String)
-> Show Datatype
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Datatype -> String -> String
showsPrec :: Int -> Datatype -> String -> String
$cshow :: Datatype -> String
show :: Datatype -> String
$cshowList :: [Datatype] -> String -> String
showList :: [Datatype] -> String -> String
Show)

_Datatype :: Name
_Datatype = (String -> Name
Core.Name String
"hydra/langs/xml/schema.Datatype")

_Datatype_anySimpleType :: Name
_Datatype_anySimpleType = (String -> Name
Core.Name String
"anySimpleType")

_Datatype_anyType :: Name
_Datatype_anyType = (String -> Name
Core.Name String
"anyType")

_Datatype_anyURI :: Name
_Datatype_anyURI = (String -> Name
Core.Name String
"anyURI")

_Datatype_base64Binary :: Name
_Datatype_base64Binary = (String -> Name
Core.Name String
"base64Binary")

_Datatype_boolean :: Name
_Datatype_boolean = (String -> Name
Core.Name String
"boolean")

_Datatype_byte :: Name
_Datatype_byte = (String -> Name
Core.Name String
"byte")

_Datatype_date :: Name
_Datatype_date = (String -> Name
Core.Name String
"date")

_Datatype_dateTime :: Name
_Datatype_dateTime = (String -> Name
Core.Name String
"dateTime")

_Datatype_decimal :: Name
_Datatype_decimal = (String -> Name
Core.Name String
"decimal")

_Datatype_double :: Name
_Datatype_double = (String -> Name
Core.Name String
"double")

_Datatype_duration :: Name
_Datatype_duration = (String -> Name
Core.Name String
"duration")

_Datatype_ENTITIES :: Name
_Datatype_ENTITIES = (String -> Name
Core.Name String
"ENTITIES")

_Datatype_ENTITY :: Name
_Datatype_ENTITY = (String -> Name
Core.Name String
"ENTITY")

_Datatype_float :: Name
_Datatype_float = (String -> Name
Core.Name String
"float")

_Datatype_gDay :: Name
_Datatype_gDay = (String -> Name
Core.Name String
"gDay")

_Datatype_gMonth :: Name
_Datatype_gMonth = (String -> Name
Core.Name String
"gMonth")

_Datatype_gMonthDay :: Name
_Datatype_gMonthDay = (String -> Name
Core.Name String
"gMonthDay")

_Datatype_gYear :: Name
_Datatype_gYear = (String -> Name
Core.Name String
"gYear")

_Datatype_gYearMonth :: Name
_Datatype_gYearMonth = (String -> Name
Core.Name String
"gYearMonth")

_Datatype_hexBinary :: Name
_Datatype_hexBinary = (String -> Name
Core.Name String
"hexBinary")

_Datatype_ID :: Name
_Datatype_ID = (String -> Name
Core.Name String
"ID")

_Datatype_IDREF :: Name
_Datatype_IDREF = (String -> Name
Core.Name String
"IDREF")

_Datatype_IDREFS :: Name
_Datatype_IDREFS = (String -> Name
Core.Name String
"IDREFS")

_Datatype_int :: Name
_Datatype_int = (String -> Name
Core.Name String
"int")

_Datatype_integer :: Name
_Datatype_integer = (String -> Name
Core.Name String
"integer")

_Datatype_language :: Name
_Datatype_language = (String -> Name
Core.Name String
"language")

_Datatype_long :: Name
_Datatype_long = (String -> Name
Core.Name String
"long")

_Datatype_NMTOKEN :: Name
_Datatype_NMTOKEN = (String -> Name
Core.Name String
"NMTOKEN")

_Datatype_NOTATION :: Name
_Datatype_NOTATION = (String -> Name
Core.Name String
"NOTATION")

_Datatype_name :: Name
_Datatype_name = (String -> Name
Core.Name String
"name")

_Datatype_negativeInteger :: Name
_Datatype_negativeInteger = (String -> Name
Core.Name String
"negativeInteger")

_Datatype_nonNegativeInteger :: Name
_Datatype_nonNegativeInteger = (String -> Name
Core.Name String
"nonNegativeInteger")

_Datatype_nonPositiveInteger :: Name
_Datatype_nonPositiveInteger = (String -> Name
Core.Name String
"nonPositiveInteger")

_Datatype_normalizedString :: Name
_Datatype_normalizedString = (String -> Name
Core.Name String
"normalizedString")

_Datatype_positiveInteger :: Name
_Datatype_positiveInteger = (String -> Name
Core.Name String
"positiveInteger")

_Datatype_qName :: Name
_Datatype_qName = (String -> Name
Core.Name String
"qName")

_Datatype_short :: Name
_Datatype_short = (String -> Name
Core.Name String
"short")

_Datatype_string :: Name
_Datatype_string = (String -> Name
Core.Name String
"string")

_Datatype_time :: Name
_Datatype_time = (String -> Name
Core.Name String
"time")

_Datatype_token :: Name
_Datatype_token = (String -> Name
Core.Name String
"token")

_Datatype_unsignedByte :: Name
_Datatype_unsignedByte = (String -> Name
Core.Name String
"unsignedByte")

_Datatype_unsignedInt :: Name
_Datatype_unsignedInt = (String -> Name
Core.Name String
"unsignedInt")

_Datatype_unsignedLong :: Name
_Datatype_unsignedLong = (String -> Name
Core.Name String
"unsignedLong")

_Datatype_unsignedShort :: Name
_Datatype_unsignedShort = (String -> Name
Core.Name String
"unsignedShort")