-- | A Shex model. Based on the BNF at:
-- |   https://github.com/shexSpec/grammar/blob/master/bnf

module Hydra.Ext.Shex.Syntax where

import qualified Hydra.Core as Core
import Data.List
import Data.Map
import Data.Set

data ShexDoc = 
  ShexDoc {
    ShexDoc -> [Directive]
shexDocListOfDirective :: [Directive],
    ShexDoc -> Maybe ShexDoc_Sequence_Option
shexDocSequence :: (Maybe ShexDoc_Sequence_Option),
    ShexDoc -> PrefixDecl
shexDocPrefixDecl :: PrefixDecl}
  deriving (ShexDoc -> ShexDoc -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ShexDoc -> ShexDoc -> Bool
$c/= :: ShexDoc -> ShexDoc -> Bool
== :: ShexDoc -> ShexDoc -> Bool
$c== :: ShexDoc -> ShexDoc -> Bool
Eq, Eq ShexDoc
ShexDoc -> ShexDoc -> Bool
ShexDoc -> ShexDoc -> Ordering
ShexDoc -> ShexDoc -> ShexDoc
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
min :: ShexDoc -> ShexDoc -> ShexDoc
$cmin :: ShexDoc -> ShexDoc -> ShexDoc
max :: ShexDoc -> ShexDoc -> ShexDoc
$cmax :: ShexDoc -> ShexDoc -> ShexDoc
>= :: ShexDoc -> ShexDoc -> Bool
$c>= :: ShexDoc -> ShexDoc -> Bool
> :: ShexDoc -> ShexDoc -> Bool
$c> :: ShexDoc -> ShexDoc -> Bool
<= :: ShexDoc -> ShexDoc -> Bool
$c<= :: ShexDoc -> ShexDoc -> Bool
< :: ShexDoc -> ShexDoc -> Bool
$c< :: ShexDoc -> ShexDoc -> Bool
compare :: ShexDoc -> ShexDoc -> Ordering
$ccompare :: ShexDoc -> ShexDoc -> Ordering
Ord, ReadPrec [ShexDoc]
ReadPrec ShexDoc
Int -> ReadS ShexDoc
ReadS [ShexDoc]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ShexDoc]
$creadListPrec :: ReadPrec [ShexDoc]
readPrec :: ReadPrec ShexDoc
$creadPrec :: ReadPrec ShexDoc
readList :: ReadS [ShexDoc]
$creadList :: ReadS [ShexDoc]
readsPrec :: Int -> ReadS ShexDoc
$creadsPrec :: Int -> ReadS ShexDoc
Read, Int -> ShexDoc -> ShowS
[ShexDoc] -> ShowS
ShexDoc -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ShexDoc] -> ShowS
$cshowList :: [ShexDoc] -> ShowS
show :: ShexDoc -> String
$cshow :: ShexDoc -> String
showsPrec :: Int -> ShexDoc -> ShowS
$cshowsPrec :: Int -> ShexDoc -> ShowS
Show)

_ShexDoc :: Name
_ShexDoc = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.ShexDoc")

_ShexDoc_listOfDirective :: FieldName
_ShexDoc_listOfDirective = (String -> FieldName
Core.FieldName String
"listOfDirective")

_ShexDoc_sequence :: FieldName
_ShexDoc_sequence = (String -> FieldName
Core.FieldName String
"sequence")

_ShexDoc_prefixDecl :: FieldName
_ShexDoc_prefixDecl = (String -> FieldName
Core.FieldName String
"prefixDecl")

data ShexDoc_Sequence_Option = 
  ShexDoc_Sequence_Option {
    ShexDoc_Sequence_Option -> ShexDoc_Sequence_Option_Alts
shexDoc_Sequence_OptionAlts :: ShexDoc_Sequence_Option_Alts,
    ShexDoc_Sequence_Option -> [Statement]
shexDoc_Sequence_OptionListOfStatement :: [Statement]}
  deriving (ShexDoc_Sequence_Option -> ShexDoc_Sequence_Option -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ShexDoc_Sequence_Option -> ShexDoc_Sequence_Option -> Bool
$c/= :: ShexDoc_Sequence_Option -> ShexDoc_Sequence_Option -> Bool
== :: ShexDoc_Sequence_Option -> ShexDoc_Sequence_Option -> Bool
$c== :: ShexDoc_Sequence_Option -> ShexDoc_Sequence_Option -> Bool
Eq, Eq ShexDoc_Sequence_Option
ShexDoc_Sequence_Option -> ShexDoc_Sequence_Option -> Bool
ShexDoc_Sequence_Option -> ShexDoc_Sequence_Option -> Ordering
ShexDoc_Sequence_Option
-> ShexDoc_Sequence_Option -> ShexDoc_Sequence_Option
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
min :: ShexDoc_Sequence_Option
-> ShexDoc_Sequence_Option -> ShexDoc_Sequence_Option
$cmin :: ShexDoc_Sequence_Option
-> ShexDoc_Sequence_Option -> ShexDoc_Sequence_Option
max :: ShexDoc_Sequence_Option
-> ShexDoc_Sequence_Option -> ShexDoc_Sequence_Option
$cmax :: ShexDoc_Sequence_Option
-> ShexDoc_Sequence_Option -> ShexDoc_Sequence_Option
>= :: ShexDoc_Sequence_Option -> ShexDoc_Sequence_Option -> Bool
$c>= :: ShexDoc_Sequence_Option -> ShexDoc_Sequence_Option -> Bool
> :: ShexDoc_Sequence_Option -> ShexDoc_Sequence_Option -> Bool
$c> :: ShexDoc_Sequence_Option -> ShexDoc_Sequence_Option -> Bool
<= :: ShexDoc_Sequence_Option -> ShexDoc_Sequence_Option -> Bool
$c<= :: ShexDoc_Sequence_Option -> ShexDoc_Sequence_Option -> Bool
< :: ShexDoc_Sequence_Option -> ShexDoc_Sequence_Option -> Bool
$c< :: ShexDoc_Sequence_Option -> ShexDoc_Sequence_Option -> Bool
compare :: ShexDoc_Sequence_Option -> ShexDoc_Sequence_Option -> Ordering
$ccompare :: ShexDoc_Sequence_Option -> ShexDoc_Sequence_Option -> Ordering
Ord, ReadPrec [ShexDoc_Sequence_Option]
ReadPrec ShexDoc_Sequence_Option
Int -> ReadS ShexDoc_Sequence_Option
ReadS [ShexDoc_Sequence_Option]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ShexDoc_Sequence_Option]
$creadListPrec :: ReadPrec [ShexDoc_Sequence_Option]
readPrec :: ReadPrec ShexDoc_Sequence_Option
$creadPrec :: ReadPrec ShexDoc_Sequence_Option
readList :: ReadS [ShexDoc_Sequence_Option]
$creadList :: ReadS [ShexDoc_Sequence_Option]
readsPrec :: Int -> ReadS ShexDoc_Sequence_Option
$creadsPrec :: Int -> ReadS ShexDoc_Sequence_Option
Read, Int -> ShexDoc_Sequence_Option -> ShowS
[ShexDoc_Sequence_Option] -> ShowS
ShexDoc_Sequence_Option -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ShexDoc_Sequence_Option] -> ShowS
$cshowList :: [ShexDoc_Sequence_Option] -> ShowS
show :: ShexDoc_Sequence_Option -> String
$cshow :: ShexDoc_Sequence_Option -> String
showsPrec :: Int -> ShexDoc_Sequence_Option -> ShowS
$cshowsPrec :: Int -> ShexDoc_Sequence_Option -> ShowS
Show)

_ShexDoc_Sequence_Option :: Name
_ShexDoc_Sequence_Option = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.ShexDoc.Sequence.Option")

_ShexDoc_Sequence_Option_alts :: FieldName
_ShexDoc_Sequence_Option_alts = (String -> FieldName
Core.FieldName String
"alts")

_ShexDoc_Sequence_Option_listOfStatement :: FieldName
_ShexDoc_Sequence_Option_listOfStatement = (String -> FieldName
Core.FieldName String
"listOfStatement")

data ShexDoc_Sequence_Option_Alts = 
  ShexDoc_Sequence_Option_AltsNotStartAction NotStartAction |
  ShexDoc_Sequence_Option_AltsStartActions StartActions
  deriving (ShexDoc_Sequence_Option_Alts
-> ShexDoc_Sequence_Option_Alts -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ShexDoc_Sequence_Option_Alts
-> ShexDoc_Sequence_Option_Alts -> Bool
$c/= :: ShexDoc_Sequence_Option_Alts
-> ShexDoc_Sequence_Option_Alts -> Bool
== :: ShexDoc_Sequence_Option_Alts
-> ShexDoc_Sequence_Option_Alts -> Bool
$c== :: ShexDoc_Sequence_Option_Alts
-> ShexDoc_Sequence_Option_Alts -> Bool
Eq, Eq ShexDoc_Sequence_Option_Alts
ShexDoc_Sequence_Option_Alts
-> ShexDoc_Sequence_Option_Alts -> Bool
ShexDoc_Sequence_Option_Alts
-> ShexDoc_Sequence_Option_Alts -> Ordering
ShexDoc_Sequence_Option_Alts
-> ShexDoc_Sequence_Option_Alts -> ShexDoc_Sequence_Option_Alts
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
min :: ShexDoc_Sequence_Option_Alts
-> ShexDoc_Sequence_Option_Alts -> ShexDoc_Sequence_Option_Alts
$cmin :: ShexDoc_Sequence_Option_Alts
-> ShexDoc_Sequence_Option_Alts -> ShexDoc_Sequence_Option_Alts
max :: ShexDoc_Sequence_Option_Alts
-> ShexDoc_Sequence_Option_Alts -> ShexDoc_Sequence_Option_Alts
$cmax :: ShexDoc_Sequence_Option_Alts
-> ShexDoc_Sequence_Option_Alts -> ShexDoc_Sequence_Option_Alts
>= :: ShexDoc_Sequence_Option_Alts
-> ShexDoc_Sequence_Option_Alts -> Bool
$c>= :: ShexDoc_Sequence_Option_Alts
-> ShexDoc_Sequence_Option_Alts -> Bool
> :: ShexDoc_Sequence_Option_Alts
-> ShexDoc_Sequence_Option_Alts -> Bool
$c> :: ShexDoc_Sequence_Option_Alts
-> ShexDoc_Sequence_Option_Alts -> Bool
<= :: ShexDoc_Sequence_Option_Alts
-> ShexDoc_Sequence_Option_Alts -> Bool
$c<= :: ShexDoc_Sequence_Option_Alts
-> ShexDoc_Sequence_Option_Alts -> Bool
< :: ShexDoc_Sequence_Option_Alts
-> ShexDoc_Sequence_Option_Alts -> Bool
$c< :: ShexDoc_Sequence_Option_Alts
-> ShexDoc_Sequence_Option_Alts -> Bool
compare :: ShexDoc_Sequence_Option_Alts
-> ShexDoc_Sequence_Option_Alts -> Ordering
$ccompare :: ShexDoc_Sequence_Option_Alts
-> ShexDoc_Sequence_Option_Alts -> Ordering
Ord, ReadPrec [ShexDoc_Sequence_Option_Alts]
ReadPrec ShexDoc_Sequence_Option_Alts
Int -> ReadS ShexDoc_Sequence_Option_Alts
ReadS [ShexDoc_Sequence_Option_Alts]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ShexDoc_Sequence_Option_Alts]
$creadListPrec :: ReadPrec [ShexDoc_Sequence_Option_Alts]
readPrec :: ReadPrec ShexDoc_Sequence_Option_Alts
$creadPrec :: ReadPrec ShexDoc_Sequence_Option_Alts
readList :: ReadS [ShexDoc_Sequence_Option_Alts]
$creadList :: ReadS [ShexDoc_Sequence_Option_Alts]
readsPrec :: Int -> ReadS ShexDoc_Sequence_Option_Alts
$creadsPrec :: Int -> ReadS ShexDoc_Sequence_Option_Alts
Read, Int -> ShexDoc_Sequence_Option_Alts -> ShowS
[ShexDoc_Sequence_Option_Alts] -> ShowS
ShexDoc_Sequence_Option_Alts -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ShexDoc_Sequence_Option_Alts] -> ShowS
$cshowList :: [ShexDoc_Sequence_Option_Alts] -> ShowS
show :: ShexDoc_Sequence_Option_Alts -> String
$cshow :: ShexDoc_Sequence_Option_Alts -> String
showsPrec :: Int -> ShexDoc_Sequence_Option_Alts -> ShowS
$cshowsPrec :: Int -> ShexDoc_Sequence_Option_Alts -> ShowS
Show)

_ShexDoc_Sequence_Option_Alts :: Name
_ShexDoc_Sequence_Option_Alts = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.ShexDoc.Sequence.Option.Alts")

_ShexDoc_Sequence_Option_Alts_notStartAction :: FieldName
_ShexDoc_Sequence_Option_Alts_notStartAction = (String -> FieldName
Core.FieldName String
"notStartAction")

_ShexDoc_Sequence_Option_Alts_startActions :: FieldName
_ShexDoc_Sequence_Option_Alts_startActions = (String -> FieldName
Core.FieldName String
"startActions")

data Directive = 
  DirectiveBaseDecl BaseDecl |
  DirectivePrefixDecl PrefixDecl
  deriving (Directive -> Directive -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Directive -> Directive -> Bool
$c/= :: Directive -> Directive -> Bool
== :: Directive -> Directive -> Bool
$c== :: Directive -> Directive -> Bool
Eq, Eq Directive
Directive -> Directive -> Bool
Directive -> Directive -> Ordering
Directive -> Directive -> Directive
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
min :: Directive -> Directive -> Directive
$cmin :: Directive -> Directive -> Directive
max :: Directive -> Directive -> Directive
$cmax :: Directive -> Directive -> Directive
>= :: Directive -> Directive -> Bool
$c>= :: Directive -> Directive -> Bool
> :: Directive -> Directive -> Bool
$c> :: Directive -> Directive -> Bool
<= :: Directive -> Directive -> Bool
$c<= :: Directive -> Directive -> Bool
< :: Directive -> Directive -> Bool
$c< :: Directive -> Directive -> Bool
compare :: Directive -> Directive -> Ordering
$ccompare :: Directive -> Directive -> Ordering
Ord, ReadPrec [Directive]
ReadPrec Directive
Int -> ReadS Directive
ReadS [Directive]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Directive]
$creadListPrec :: ReadPrec [Directive]
readPrec :: ReadPrec Directive
$creadPrec :: ReadPrec Directive
readList :: ReadS [Directive]
$creadList :: ReadS [Directive]
readsPrec :: Int -> ReadS Directive
$creadsPrec :: Int -> ReadS Directive
Read, Int -> Directive -> ShowS
[Directive] -> ShowS
Directive -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Directive] -> ShowS
$cshowList :: [Directive] -> ShowS
show :: Directive -> String
$cshow :: Directive -> String
showsPrec :: Int -> Directive -> ShowS
$cshowsPrec :: Int -> Directive -> ShowS
Show)

_Directive :: Name
_Directive = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.Directive")

_Directive_baseDecl :: FieldName
_Directive_baseDecl = (String -> FieldName
Core.FieldName String
"baseDecl")

_Directive_prefixDecl :: FieldName
_Directive_prefixDecl = (String -> FieldName
Core.FieldName String
"prefixDecl")

data BaseDecl = 
  BaseDecl {
    BaseDecl -> IriRef
baseDeclIriRef :: IriRef}
  deriving (BaseDecl -> BaseDecl -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BaseDecl -> BaseDecl -> Bool
$c/= :: BaseDecl -> BaseDecl -> Bool
== :: BaseDecl -> BaseDecl -> Bool
$c== :: BaseDecl -> BaseDecl -> Bool
Eq, Eq BaseDecl
BaseDecl -> BaseDecl -> Bool
BaseDecl -> BaseDecl -> Ordering
BaseDecl -> BaseDecl -> BaseDecl
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
min :: BaseDecl -> BaseDecl -> BaseDecl
$cmin :: BaseDecl -> BaseDecl -> BaseDecl
max :: BaseDecl -> BaseDecl -> BaseDecl
$cmax :: BaseDecl -> BaseDecl -> BaseDecl
>= :: BaseDecl -> BaseDecl -> Bool
$c>= :: BaseDecl -> BaseDecl -> Bool
> :: BaseDecl -> BaseDecl -> Bool
$c> :: BaseDecl -> BaseDecl -> Bool
<= :: BaseDecl -> BaseDecl -> Bool
$c<= :: BaseDecl -> BaseDecl -> Bool
< :: BaseDecl -> BaseDecl -> Bool
$c< :: BaseDecl -> BaseDecl -> Bool
compare :: BaseDecl -> BaseDecl -> Ordering
$ccompare :: BaseDecl -> BaseDecl -> Ordering
Ord, ReadPrec [BaseDecl]
ReadPrec BaseDecl
Int -> ReadS BaseDecl
ReadS [BaseDecl]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [BaseDecl]
$creadListPrec :: ReadPrec [BaseDecl]
readPrec :: ReadPrec BaseDecl
$creadPrec :: ReadPrec BaseDecl
readList :: ReadS [BaseDecl]
$creadList :: ReadS [BaseDecl]
readsPrec :: Int -> ReadS BaseDecl
$creadsPrec :: Int -> ReadS BaseDecl
Read, Int -> BaseDecl -> ShowS
[BaseDecl] -> ShowS
BaseDecl -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BaseDecl] -> ShowS
$cshowList :: [BaseDecl] -> ShowS
show :: BaseDecl -> String
$cshow :: BaseDecl -> String
showsPrec :: Int -> BaseDecl -> ShowS
$cshowsPrec :: Int -> BaseDecl -> ShowS
Show)

_BaseDecl :: Name
_BaseDecl = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.BaseDecl")

_BaseDecl_iriRef :: FieldName
_BaseDecl_iriRef = (String -> FieldName
Core.FieldName String
"iriRef")

data PrefixDecl = 
  PrefixDecl {
    PrefixDecl -> PnameNs
prefixDeclPnameNs :: PnameNs,
    PrefixDecl -> IriRef
prefixDeclIriRef :: IriRef}
  deriving (PrefixDecl -> PrefixDecl -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PrefixDecl -> PrefixDecl -> Bool
$c/= :: PrefixDecl -> PrefixDecl -> Bool
== :: PrefixDecl -> PrefixDecl -> Bool
$c== :: PrefixDecl -> PrefixDecl -> Bool
Eq, Eq PrefixDecl
PrefixDecl -> PrefixDecl -> Bool
PrefixDecl -> PrefixDecl -> Ordering
PrefixDecl -> PrefixDecl -> PrefixDecl
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
min :: PrefixDecl -> PrefixDecl -> PrefixDecl
$cmin :: PrefixDecl -> PrefixDecl -> PrefixDecl
max :: PrefixDecl -> PrefixDecl -> PrefixDecl
$cmax :: PrefixDecl -> PrefixDecl -> PrefixDecl
>= :: PrefixDecl -> PrefixDecl -> Bool
$c>= :: PrefixDecl -> PrefixDecl -> Bool
> :: PrefixDecl -> PrefixDecl -> Bool
$c> :: PrefixDecl -> PrefixDecl -> Bool
<= :: PrefixDecl -> PrefixDecl -> Bool
$c<= :: PrefixDecl -> PrefixDecl -> Bool
< :: PrefixDecl -> PrefixDecl -> Bool
$c< :: PrefixDecl -> PrefixDecl -> Bool
compare :: PrefixDecl -> PrefixDecl -> Ordering
$ccompare :: PrefixDecl -> PrefixDecl -> Ordering
Ord, ReadPrec [PrefixDecl]
ReadPrec PrefixDecl
Int -> ReadS PrefixDecl
ReadS [PrefixDecl]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [PrefixDecl]
$creadListPrec :: ReadPrec [PrefixDecl]
readPrec :: ReadPrec PrefixDecl
$creadPrec :: ReadPrec PrefixDecl
readList :: ReadS [PrefixDecl]
$creadList :: ReadS [PrefixDecl]
readsPrec :: Int -> ReadS PrefixDecl
$creadsPrec :: Int -> ReadS PrefixDecl
Read, Int -> PrefixDecl -> ShowS
[PrefixDecl] -> ShowS
PrefixDecl -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PrefixDecl] -> ShowS
$cshowList :: [PrefixDecl] -> ShowS
show :: PrefixDecl -> String
$cshow :: PrefixDecl -> String
showsPrec :: Int -> PrefixDecl -> ShowS
$cshowsPrec :: Int -> PrefixDecl -> ShowS
Show)

_PrefixDecl :: Name
_PrefixDecl = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.PrefixDecl")

_PrefixDecl_pnameNs :: FieldName
_PrefixDecl_pnameNs = (String -> FieldName
Core.FieldName String
"pnameNs")

_PrefixDecl_iriRef :: FieldName
_PrefixDecl_iriRef = (String -> FieldName
Core.FieldName String
"iriRef")

data NotStartAction = 
  NotStartActionStart NotStartAction_Start |
  NotStartActionShapeExprDecl NotStartAction_ShapeExprDecl
  deriving (NotStartAction -> NotStartAction -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NotStartAction -> NotStartAction -> Bool
$c/= :: NotStartAction -> NotStartAction -> Bool
== :: NotStartAction -> NotStartAction -> Bool
$c== :: NotStartAction -> NotStartAction -> Bool
Eq, Eq NotStartAction
NotStartAction -> NotStartAction -> Bool
NotStartAction -> NotStartAction -> Ordering
NotStartAction -> NotStartAction -> NotStartAction
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
min :: NotStartAction -> NotStartAction -> NotStartAction
$cmin :: NotStartAction -> NotStartAction -> NotStartAction
max :: NotStartAction -> NotStartAction -> NotStartAction
$cmax :: NotStartAction -> NotStartAction -> NotStartAction
>= :: NotStartAction -> NotStartAction -> Bool
$c>= :: NotStartAction -> NotStartAction -> Bool
> :: NotStartAction -> NotStartAction -> Bool
$c> :: NotStartAction -> NotStartAction -> Bool
<= :: NotStartAction -> NotStartAction -> Bool
$c<= :: NotStartAction -> NotStartAction -> Bool
< :: NotStartAction -> NotStartAction -> Bool
$c< :: NotStartAction -> NotStartAction -> Bool
compare :: NotStartAction -> NotStartAction -> Ordering
$ccompare :: NotStartAction -> NotStartAction -> Ordering
Ord, ReadPrec [NotStartAction]
ReadPrec NotStartAction
Int -> ReadS NotStartAction
ReadS [NotStartAction]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [NotStartAction]
$creadListPrec :: ReadPrec [NotStartAction]
readPrec :: ReadPrec NotStartAction
$creadPrec :: ReadPrec NotStartAction
readList :: ReadS [NotStartAction]
$creadList :: ReadS [NotStartAction]
readsPrec :: Int -> ReadS NotStartAction
$creadsPrec :: Int -> ReadS NotStartAction
Read, Int -> NotStartAction -> ShowS
[NotStartAction] -> ShowS
NotStartAction -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [NotStartAction] -> ShowS
$cshowList :: [NotStartAction] -> ShowS
show :: NotStartAction -> String
$cshow :: NotStartAction -> String
showsPrec :: Int -> NotStartAction -> ShowS
$cshowsPrec :: Int -> NotStartAction -> ShowS
Show)

_NotStartAction :: Name
_NotStartAction = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.NotStartAction")

_NotStartAction_start :: FieldName
_NotStartAction_start = (String -> FieldName
Core.FieldName String
"start")

_NotStartAction_shapeExprDecl :: FieldName
_NotStartAction_shapeExprDecl = (String -> FieldName
Core.FieldName String
"shapeExprDecl")

data NotStartAction_Start = 
  NotStartAction_Start {
    NotStartAction_Start -> ShapeExpression
notStartAction_StartShapeExpression :: ShapeExpression}
  deriving (NotStartAction_Start -> NotStartAction_Start -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NotStartAction_Start -> NotStartAction_Start -> Bool
$c/= :: NotStartAction_Start -> NotStartAction_Start -> Bool
== :: NotStartAction_Start -> NotStartAction_Start -> Bool
$c== :: NotStartAction_Start -> NotStartAction_Start -> Bool
Eq, Eq NotStartAction_Start
NotStartAction_Start -> NotStartAction_Start -> Bool
NotStartAction_Start -> NotStartAction_Start -> Ordering
NotStartAction_Start
-> NotStartAction_Start -> NotStartAction_Start
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
min :: NotStartAction_Start
-> NotStartAction_Start -> NotStartAction_Start
$cmin :: NotStartAction_Start
-> NotStartAction_Start -> NotStartAction_Start
max :: NotStartAction_Start
-> NotStartAction_Start -> NotStartAction_Start
$cmax :: NotStartAction_Start
-> NotStartAction_Start -> NotStartAction_Start
>= :: NotStartAction_Start -> NotStartAction_Start -> Bool
$c>= :: NotStartAction_Start -> NotStartAction_Start -> Bool
> :: NotStartAction_Start -> NotStartAction_Start -> Bool
$c> :: NotStartAction_Start -> NotStartAction_Start -> Bool
<= :: NotStartAction_Start -> NotStartAction_Start -> Bool
$c<= :: NotStartAction_Start -> NotStartAction_Start -> Bool
< :: NotStartAction_Start -> NotStartAction_Start -> Bool
$c< :: NotStartAction_Start -> NotStartAction_Start -> Bool
compare :: NotStartAction_Start -> NotStartAction_Start -> Ordering
$ccompare :: NotStartAction_Start -> NotStartAction_Start -> Ordering
Ord, ReadPrec [NotStartAction_Start]
ReadPrec NotStartAction_Start
Int -> ReadS NotStartAction_Start
ReadS [NotStartAction_Start]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [NotStartAction_Start]
$creadListPrec :: ReadPrec [NotStartAction_Start]
readPrec :: ReadPrec NotStartAction_Start
$creadPrec :: ReadPrec NotStartAction_Start
readList :: ReadS [NotStartAction_Start]
$creadList :: ReadS [NotStartAction_Start]
readsPrec :: Int -> ReadS NotStartAction_Start
$creadsPrec :: Int -> ReadS NotStartAction_Start
Read, Int -> NotStartAction_Start -> ShowS
[NotStartAction_Start] -> ShowS
NotStartAction_Start -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [NotStartAction_Start] -> ShowS
$cshowList :: [NotStartAction_Start] -> ShowS
show :: NotStartAction_Start -> String
$cshow :: NotStartAction_Start -> String
showsPrec :: Int -> NotStartAction_Start -> ShowS
$cshowsPrec :: Int -> NotStartAction_Start -> ShowS
Show)

_NotStartAction_Start :: Name
_NotStartAction_Start = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.NotStartAction.Start")

_NotStartAction_Start_shapeExpression :: FieldName
_NotStartAction_Start_shapeExpression = (String -> FieldName
Core.FieldName String
"shapeExpression")

data NotStartAction_ShapeExprDecl = 
  NotStartAction_ShapeExprDecl {
    NotStartAction_ShapeExprDecl -> ShapeExprLabel
notStartAction_ShapeExprDeclShapeExprLabel :: ShapeExprLabel,
    NotStartAction_ShapeExprDecl -> NotStartAction_ShapeExprDecl_Alts
notStartAction_ShapeExprDeclAlts :: NotStartAction_ShapeExprDecl_Alts}
  deriving (NotStartAction_ShapeExprDecl
-> NotStartAction_ShapeExprDecl -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NotStartAction_ShapeExprDecl
-> NotStartAction_ShapeExprDecl -> Bool
$c/= :: NotStartAction_ShapeExprDecl
-> NotStartAction_ShapeExprDecl -> Bool
== :: NotStartAction_ShapeExprDecl
-> NotStartAction_ShapeExprDecl -> Bool
$c== :: NotStartAction_ShapeExprDecl
-> NotStartAction_ShapeExprDecl -> Bool
Eq, Eq NotStartAction_ShapeExprDecl
NotStartAction_ShapeExprDecl
-> NotStartAction_ShapeExprDecl -> Bool
NotStartAction_ShapeExprDecl
-> NotStartAction_ShapeExprDecl -> Ordering
NotStartAction_ShapeExprDecl
-> NotStartAction_ShapeExprDecl -> NotStartAction_ShapeExprDecl
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
min :: NotStartAction_ShapeExprDecl
-> NotStartAction_ShapeExprDecl -> NotStartAction_ShapeExprDecl
$cmin :: NotStartAction_ShapeExprDecl
-> NotStartAction_ShapeExprDecl -> NotStartAction_ShapeExprDecl
max :: NotStartAction_ShapeExprDecl
-> NotStartAction_ShapeExprDecl -> NotStartAction_ShapeExprDecl
$cmax :: NotStartAction_ShapeExprDecl
-> NotStartAction_ShapeExprDecl -> NotStartAction_ShapeExprDecl
>= :: NotStartAction_ShapeExprDecl
-> NotStartAction_ShapeExprDecl -> Bool
$c>= :: NotStartAction_ShapeExprDecl
-> NotStartAction_ShapeExprDecl -> Bool
> :: NotStartAction_ShapeExprDecl
-> NotStartAction_ShapeExprDecl -> Bool
$c> :: NotStartAction_ShapeExprDecl
-> NotStartAction_ShapeExprDecl -> Bool
<= :: NotStartAction_ShapeExprDecl
-> NotStartAction_ShapeExprDecl -> Bool
$c<= :: NotStartAction_ShapeExprDecl
-> NotStartAction_ShapeExprDecl -> Bool
< :: NotStartAction_ShapeExprDecl
-> NotStartAction_ShapeExprDecl -> Bool
$c< :: NotStartAction_ShapeExprDecl
-> NotStartAction_ShapeExprDecl -> Bool
compare :: NotStartAction_ShapeExprDecl
-> NotStartAction_ShapeExprDecl -> Ordering
$ccompare :: NotStartAction_ShapeExprDecl
-> NotStartAction_ShapeExprDecl -> Ordering
Ord, ReadPrec [NotStartAction_ShapeExprDecl]
ReadPrec NotStartAction_ShapeExprDecl
Int -> ReadS NotStartAction_ShapeExprDecl
ReadS [NotStartAction_ShapeExprDecl]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [NotStartAction_ShapeExprDecl]
$creadListPrec :: ReadPrec [NotStartAction_ShapeExprDecl]
readPrec :: ReadPrec NotStartAction_ShapeExprDecl
$creadPrec :: ReadPrec NotStartAction_ShapeExprDecl
readList :: ReadS [NotStartAction_ShapeExprDecl]
$creadList :: ReadS [NotStartAction_ShapeExprDecl]
readsPrec :: Int -> ReadS NotStartAction_ShapeExprDecl
$creadsPrec :: Int -> ReadS NotStartAction_ShapeExprDecl
Read, Int -> NotStartAction_ShapeExprDecl -> ShowS
[NotStartAction_ShapeExprDecl] -> ShowS
NotStartAction_ShapeExprDecl -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [NotStartAction_ShapeExprDecl] -> ShowS
$cshowList :: [NotStartAction_ShapeExprDecl] -> ShowS
show :: NotStartAction_ShapeExprDecl -> String
$cshow :: NotStartAction_ShapeExprDecl -> String
showsPrec :: Int -> NotStartAction_ShapeExprDecl -> ShowS
$cshowsPrec :: Int -> NotStartAction_ShapeExprDecl -> ShowS
Show)

_NotStartAction_ShapeExprDecl :: Name
_NotStartAction_ShapeExprDecl = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.NotStartAction.ShapeExprDecl")

_NotStartAction_ShapeExprDecl_shapeExprLabel :: FieldName
_NotStartAction_ShapeExprDecl_shapeExprLabel = (String -> FieldName
Core.FieldName String
"shapeExprLabel")

_NotStartAction_ShapeExprDecl_alts :: FieldName
_NotStartAction_ShapeExprDecl_alts = (String -> FieldName
Core.FieldName String
"alts")

data NotStartAction_ShapeExprDecl_Alts = 
  NotStartAction_ShapeExprDecl_AltsShapeExpression ShapeExpression |
  NotStartAction_ShapeExprDecl_AltsEXTERNAL 
  deriving (NotStartAction_ShapeExprDecl_Alts
-> NotStartAction_ShapeExprDecl_Alts -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NotStartAction_ShapeExprDecl_Alts
-> NotStartAction_ShapeExprDecl_Alts -> Bool
$c/= :: NotStartAction_ShapeExprDecl_Alts
-> NotStartAction_ShapeExprDecl_Alts -> Bool
== :: NotStartAction_ShapeExprDecl_Alts
-> NotStartAction_ShapeExprDecl_Alts -> Bool
$c== :: NotStartAction_ShapeExprDecl_Alts
-> NotStartAction_ShapeExprDecl_Alts -> Bool
Eq, Eq NotStartAction_ShapeExprDecl_Alts
NotStartAction_ShapeExprDecl_Alts
-> NotStartAction_ShapeExprDecl_Alts -> Bool
NotStartAction_ShapeExprDecl_Alts
-> NotStartAction_ShapeExprDecl_Alts -> Ordering
NotStartAction_ShapeExprDecl_Alts
-> NotStartAction_ShapeExprDecl_Alts
-> NotStartAction_ShapeExprDecl_Alts
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
min :: NotStartAction_ShapeExprDecl_Alts
-> NotStartAction_ShapeExprDecl_Alts
-> NotStartAction_ShapeExprDecl_Alts
$cmin :: NotStartAction_ShapeExprDecl_Alts
-> NotStartAction_ShapeExprDecl_Alts
-> NotStartAction_ShapeExprDecl_Alts
max :: NotStartAction_ShapeExprDecl_Alts
-> NotStartAction_ShapeExprDecl_Alts
-> NotStartAction_ShapeExprDecl_Alts
$cmax :: NotStartAction_ShapeExprDecl_Alts
-> NotStartAction_ShapeExprDecl_Alts
-> NotStartAction_ShapeExprDecl_Alts
>= :: NotStartAction_ShapeExprDecl_Alts
-> NotStartAction_ShapeExprDecl_Alts -> Bool
$c>= :: NotStartAction_ShapeExprDecl_Alts
-> NotStartAction_ShapeExprDecl_Alts -> Bool
> :: NotStartAction_ShapeExprDecl_Alts
-> NotStartAction_ShapeExprDecl_Alts -> Bool
$c> :: NotStartAction_ShapeExprDecl_Alts
-> NotStartAction_ShapeExprDecl_Alts -> Bool
<= :: NotStartAction_ShapeExprDecl_Alts
-> NotStartAction_ShapeExprDecl_Alts -> Bool
$c<= :: NotStartAction_ShapeExprDecl_Alts
-> NotStartAction_ShapeExprDecl_Alts -> Bool
< :: NotStartAction_ShapeExprDecl_Alts
-> NotStartAction_ShapeExprDecl_Alts -> Bool
$c< :: NotStartAction_ShapeExprDecl_Alts
-> NotStartAction_ShapeExprDecl_Alts -> Bool
compare :: NotStartAction_ShapeExprDecl_Alts
-> NotStartAction_ShapeExprDecl_Alts -> Ordering
$ccompare :: NotStartAction_ShapeExprDecl_Alts
-> NotStartAction_ShapeExprDecl_Alts -> Ordering
Ord, ReadPrec [NotStartAction_ShapeExprDecl_Alts]
ReadPrec NotStartAction_ShapeExprDecl_Alts
Int -> ReadS NotStartAction_ShapeExprDecl_Alts
ReadS [NotStartAction_ShapeExprDecl_Alts]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [NotStartAction_ShapeExprDecl_Alts]
$creadListPrec :: ReadPrec [NotStartAction_ShapeExprDecl_Alts]
readPrec :: ReadPrec NotStartAction_ShapeExprDecl_Alts
$creadPrec :: ReadPrec NotStartAction_ShapeExprDecl_Alts
readList :: ReadS [NotStartAction_ShapeExprDecl_Alts]
$creadList :: ReadS [NotStartAction_ShapeExprDecl_Alts]
readsPrec :: Int -> ReadS NotStartAction_ShapeExprDecl_Alts
$creadsPrec :: Int -> ReadS NotStartAction_ShapeExprDecl_Alts
Read, Int -> NotStartAction_ShapeExprDecl_Alts -> ShowS
[NotStartAction_ShapeExprDecl_Alts] -> ShowS
NotStartAction_ShapeExprDecl_Alts -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [NotStartAction_ShapeExprDecl_Alts] -> ShowS
$cshowList :: [NotStartAction_ShapeExprDecl_Alts] -> ShowS
show :: NotStartAction_ShapeExprDecl_Alts -> String
$cshow :: NotStartAction_ShapeExprDecl_Alts -> String
showsPrec :: Int -> NotStartAction_ShapeExprDecl_Alts -> ShowS
$cshowsPrec :: Int -> NotStartAction_ShapeExprDecl_Alts -> ShowS
Show)

_NotStartAction_ShapeExprDecl_Alts :: Name
_NotStartAction_ShapeExprDecl_Alts = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.NotStartAction.ShapeExprDecl.Alts")

_NotStartAction_ShapeExprDecl_Alts_shapeExpression :: FieldName
_NotStartAction_ShapeExprDecl_Alts_shapeExpression = (String -> FieldName
Core.FieldName String
"shapeExpression")

_NotStartAction_ShapeExprDecl_Alts_eXTERNAL :: FieldName
_NotStartAction_ShapeExprDecl_Alts_eXTERNAL = (String -> FieldName
Core.FieldName String
"eXTERNAL")

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

_StartActions :: Name
_StartActions = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.StartActions")

data Statement = 
  StatementDirective Directive |
  StatementNotStartAction NotStartAction
  deriving (Statement -> Statement -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Statement -> Statement -> Bool
$c/= :: Statement -> Statement -> Bool
== :: Statement -> Statement -> Bool
$c== :: Statement -> Statement -> Bool
Eq, Eq Statement
Statement -> Statement -> Bool
Statement -> Statement -> Ordering
Statement -> Statement -> Statement
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
min :: Statement -> Statement -> Statement
$cmin :: Statement -> Statement -> Statement
max :: Statement -> Statement -> Statement
$cmax :: Statement -> Statement -> Statement
>= :: Statement -> Statement -> Bool
$c>= :: Statement -> Statement -> Bool
> :: Statement -> Statement -> Bool
$c> :: Statement -> Statement -> Bool
<= :: Statement -> Statement -> Bool
$c<= :: Statement -> Statement -> Bool
< :: Statement -> Statement -> Bool
$c< :: Statement -> Statement -> Bool
compare :: Statement -> Statement -> Ordering
$ccompare :: Statement -> Statement -> Ordering
Ord, ReadPrec [Statement]
ReadPrec Statement
Int -> ReadS Statement
ReadS [Statement]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Statement]
$creadListPrec :: ReadPrec [Statement]
readPrec :: ReadPrec Statement
$creadPrec :: ReadPrec Statement
readList :: ReadS [Statement]
$creadList :: ReadS [Statement]
readsPrec :: Int -> ReadS Statement
$creadsPrec :: Int -> ReadS Statement
Read, Int -> Statement -> ShowS
[Statement] -> ShowS
Statement -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Statement] -> ShowS
$cshowList :: [Statement] -> ShowS
show :: Statement -> String
$cshow :: Statement -> String
showsPrec :: Int -> Statement -> ShowS
$cshowsPrec :: Int -> Statement -> ShowS
Show)

_Statement :: Name
_Statement = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.Statement")

_Statement_directive :: FieldName
_Statement_directive = (String -> FieldName
Core.FieldName String
"directive")

_Statement_notStartAction :: FieldName
_Statement_notStartAction = (String -> FieldName
Core.FieldName String
"notStartAction")

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

_ShapeExpression :: Name
_ShapeExpression = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.ShapeExpression")

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

_InlineShapeExpression :: Name
_InlineShapeExpression = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.InlineShapeExpression")

data ShapeOr = 
  ShapeOr {
    ShapeOr -> ShapeAnd
shapeOrShapeAnd :: ShapeAnd,
    ShapeOr -> [ShapeOr_ListOfSequence_Elmt]
shapeOrListOfSequence :: [ShapeOr_ListOfSequence_Elmt]}
  deriving (ShapeOr -> ShapeOr -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ShapeOr -> ShapeOr -> Bool
$c/= :: ShapeOr -> ShapeOr -> Bool
== :: ShapeOr -> ShapeOr -> Bool
$c== :: ShapeOr -> ShapeOr -> Bool
Eq, Eq ShapeOr
ShapeOr -> ShapeOr -> Bool
ShapeOr -> ShapeOr -> Ordering
ShapeOr -> ShapeOr -> ShapeOr
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
min :: ShapeOr -> ShapeOr -> ShapeOr
$cmin :: ShapeOr -> ShapeOr -> ShapeOr
max :: ShapeOr -> ShapeOr -> ShapeOr
$cmax :: ShapeOr -> ShapeOr -> ShapeOr
>= :: ShapeOr -> ShapeOr -> Bool
$c>= :: ShapeOr -> ShapeOr -> Bool
> :: ShapeOr -> ShapeOr -> Bool
$c> :: ShapeOr -> ShapeOr -> Bool
<= :: ShapeOr -> ShapeOr -> Bool
$c<= :: ShapeOr -> ShapeOr -> Bool
< :: ShapeOr -> ShapeOr -> Bool
$c< :: ShapeOr -> ShapeOr -> Bool
compare :: ShapeOr -> ShapeOr -> Ordering
$ccompare :: ShapeOr -> ShapeOr -> Ordering
Ord, ReadPrec [ShapeOr]
ReadPrec ShapeOr
Int -> ReadS ShapeOr
ReadS [ShapeOr]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ShapeOr]
$creadListPrec :: ReadPrec [ShapeOr]
readPrec :: ReadPrec ShapeOr
$creadPrec :: ReadPrec ShapeOr
readList :: ReadS [ShapeOr]
$creadList :: ReadS [ShapeOr]
readsPrec :: Int -> ReadS ShapeOr
$creadsPrec :: Int -> ReadS ShapeOr
Read, Int -> ShapeOr -> ShowS
[ShapeOr] -> ShowS
ShapeOr -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ShapeOr] -> ShowS
$cshowList :: [ShapeOr] -> ShowS
show :: ShapeOr -> String
$cshow :: ShapeOr -> String
showsPrec :: Int -> ShapeOr -> ShowS
$cshowsPrec :: Int -> ShapeOr -> ShowS
Show)

_ShapeOr :: Name
_ShapeOr = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.ShapeOr")

_ShapeOr_shapeAnd :: FieldName
_ShapeOr_shapeAnd = (String -> FieldName
Core.FieldName String
"shapeAnd")

_ShapeOr_listOfSequence :: FieldName
_ShapeOr_listOfSequence = (String -> FieldName
Core.FieldName String
"listOfSequence")

data ShapeOr_ListOfSequence_Elmt = 
  ShapeOr_ListOfSequence_Elmt {
    ShapeOr_ListOfSequence_Elmt -> ShapeAnd
shapeOr_ListOfSequence_ElmtShapeAnd :: ShapeAnd}
  deriving (ShapeOr_ListOfSequence_Elmt -> ShapeOr_ListOfSequence_Elmt -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ShapeOr_ListOfSequence_Elmt -> ShapeOr_ListOfSequence_Elmt -> Bool
$c/= :: ShapeOr_ListOfSequence_Elmt -> ShapeOr_ListOfSequence_Elmt -> Bool
== :: ShapeOr_ListOfSequence_Elmt -> ShapeOr_ListOfSequence_Elmt -> Bool
$c== :: ShapeOr_ListOfSequence_Elmt -> ShapeOr_ListOfSequence_Elmt -> Bool
Eq, Eq ShapeOr_ListOfSequence_Elmt
ShapeOr_ListOfSequence_Elmt -> ShapeOr_ListOfSequence_Elmt -> Bool
ShapeOr_ListOfSequence_Elmt
-> ShapeOr_ListOfSequence_Elmt -> Ordering
ShapeOr_ListOfSequence_Elmt
-> ShapeOr_ListOfSequence_Elmt -> ShapeOr_ListOfSequence_Elmt
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
min :: ShapeOr_ListOfSequence_Elmt
-> ShapeOr_ListOfSequence_Elmt -> ShapeOr_ListOfSequence_Elmt
$cmin :: ShapeOr_ListOfSequence_Elmt
-> ShapeOr_ListOfSequence_Elmt -> ShapeOr_ListOfSequence_Elmt
max :: ShapeOr_ListOfSequence_Elmt
-> ShapeOr_ListOfSequence_Elmt -> ShapeOr_ListOfSequence_Elmt
$cmax :: ShapeOr_ListOfSequence_Elmt
-> ShapeOr_ListOfSequence_Elmt -> ShapeOr_ListOfSequence_Elmt
>= :: ShapeOr_ListOfSequence_Elmt -> ShapeOr_ListOfSequence_Elmt -> Bool
$c>= :: ShapeOr_ListOfSequence_Elmt -> ShapeOr_ListOfSequence_Elmt -> Bool
> :: ShapeOr_ListOfSequence_Elmt -> ShapeOr_ListOfSequence_Elmt -> Bool
$c> :: ShapeOr_ListOfSequence_Elmt -> ShapeOr_ListOfSequence_Elmt -> Bool
<= :: ShapeOr_ListOfSequence_Elmt -> ShapeOr_ListOfSequence_Elmt -> Bool
$c<= :: ShapeOr_ListOfSequence_Elmt -> ShapeOr_ListOfSequence_Elmt -> Bool
< :: ShapeOr_ListOfSequence_Elmt -> ShapeOr_ListOfSequence_Elmt -> Bool
$c< :: ShapeOr_ListOfSequence_Elmt -> ShapeOr_ListOfSequence_Elmt -> Bool
compare :: ShapeOr_ListOfSequence_Elmt
-> ShapeOr_ListOfSequence_Elmt -> Ordering
$ccompare :: ShapeOr_ListOfSequence_Elmt
-> ShapeOr_ListOfSequence_Elmt -> Ordering
Ord, ReadPrec [ShapeOr_ListOfSequence_Elmt]
ReadPrec ShapeOr_ListOfSequence_Elmt
Int -> ReadS ShapeOr_ListOfSequence_Elmt
ReadS [ShapeOr_ListOfSequence_Elmt]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ShapeOr_ListOfSequence_Elmt]
$creadListPrec :: ReadPrec [ShapeOr_ListOfSequence_Elmt]
readPrec :: ReadPrec ShapeOr_ListOfSequence_Elmt
$creadPrec :: ReadPrec ShapeOr_ListOfSequence_Elmt
readList :: ReadS [ShapeOr_ListOfSequence_Elmt]
$creadList :: ReadS [ShapeOr_ListOfSequence_Elmt]
readsPrec :: Int -> ReadS ShapeOr_ListOfSequence_Elmt
$creadsPrec :: Int -> ReadS ShapeOr_ListOfSequence_Elmt
Read, Int -> ShapeOr_ListOfSequence_Elmt -> ShowS
[ShapeOr_ListOfSequence_Elmt] -> ShowS
ShapeOr_ListOfSequence_Elmt -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ShapeOr_ListOfSequence_Elmt] -> ShowS
$cshowList :: [ShapeOr_ListOfSequence_Elmt] -> ShowS
show :: ShapeOr_ListOfSequence_Elmt -> String
$cshow :: ShapeOr_ListOfSequence_Elmt -> String
showsPrec :: Int -> ShapeOr_ListOfSequence_Elmt -> ShowS
$cshowsPrec :: Int -> ShapeOr_ListOfSequence_Elmt -> ShowS
Show)

_ShapeOr_ListOfSequence_Elmt :: Name
_ShapeOr_ListOfSequence_Elmt = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.ShapeOr.ListOfSequence.Elmt")

_ShapeOr_ListOfSequence_Elmt_shapeAnd :: FieldName
_ShapeOr_ListOfSequence_Elmt_shapeAnd = (String -> FieldName
Core.FieldName String
"shapeAnd")

data InlineShapeOr = 
  InlineShapeOr {
    InlineShapeOr -> ShapeAnd
inlineShapeOrShapeAnd :: ShapeAnd,
    InlineShapeOr -> [InlineShapeOr_ListOfSequence_Elmt]
inlineShapeOrListOfSequence :: [InlineShapeOr_ListOfSequence_Elmt]}
  deriving (InlineShapeOr -> InlineShapeOr -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: InlineShapeOr -> InlineShapeOr -> Bool
$c/= :: InlineShapeOr -> InlineShapeOr -> Bool
== :: InlineShapeOr -> InlineShapeOr -> Bool
$c== :: InlineShapeOr -> InlineShapeOr -> Bool
Eq, Eq InlineShapeOr
InlineShapeOr -> InlineShapeOr -> Bool
InlineShapeOr -> InlineShapeOr -> Ordering
InlineShapeOr -> InlineShapeOr -> InlineShapeOr
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
min :: InlineShapeOr -> InlineShapeOr -> InlineShapeOr
$cmin :: InlineShapeOr -> InlineShapeOr -> InlineShapeOr
max :: InlineShapeOr -> InlineShapeOr -> InlineShapeOr
$cmax :: InlineShapeOr -> InlineShapeOr -> InlineShapeOr
>= :: InlineShapeOr -> InlineShapeOr -> Bool
$c>= :: InlineShapeOr -> InlineShapeOr -> Bool
> :: InlineShapeOr -> InlineShapeOr -> Bool
$c> :: InlineShapeOr -> InlineShapeOr -> Bool
<= :: InlineShapeOr -> InlineShapeOr -> Bool
$c<= :: InlineShapeOr -> InlineShapeOr -> Bool
< :: InlineShapeOr -> InlineShapeOr -> Bool
$c< :: InlineShapeOr -> InlineShapeOr -> Bool
compare :: InlineShapeOr -> InlineShapeOr -> Ordering
$ccompare :: InlineShapeOr -> InlineShapeOr -> Ordering
Ord, ReadPrec [InlineShapeOr]
ReadPrec InlineShapeOr
Int -> ReadS InlineShapeOr
ReadS [InlineShapeOr]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [InlineShapeOr]
$creadListPrec :: ReadPrec [InlineShapeOr]
readPrec :: ReadPrec InlineShapeOr
$creadPrec :: ReadPrec InlineShapeOr
readList :: ReadS [InlineShapeOr]
$creadList :: ReadS [InlineShapeOr]
readsPrec :: Int -> ReadS InlineShapeOr
$creadsPrec :: Int -> ReadS InlineShapeOr
Read, Int -> InlineShapeOr -> ShowS
[InlineShapeOr] -> ShowS
InlineShapeOr -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [InlineShapeOr] -> ShowS
$cshowList :: [InlineShapeOr] -> ShowS
show :: InlineShapeOr -> String
$cshow :: InlineShapeOr -> String
showsPrec :: Int -> InlineShapeOr -> ShowS
$cshowsPrec :: Int -> InlineShapeOr -> ShowS
Show)

_InlineShapeOr :: Name
_InlineShapeOr = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.InlineShapeOr")

_InlineShapeOr_shapeAnd :: FieldName
_InlineShapeOr_shapeAnd = (String -> FieldName
Core.FieldName String
"shapeAnd")

_InlineShapeOr_listOfSequence :: FieldName
_InlineShapeOr_listOfSequence = (String -> FieldName
Core.FieldName String
"listOfSequence")

data InlineShapeOr_ListOfSequence_Elmt = 
  InlineShapeOr_ListOfSequence_Elmt {
    InlineShapeOr_ListOfSequence_Elmt -> InlineShapeAnd
inlineShapeOr_ListOfSequence_ElmtInlineShapeAnd :: InlineShapeAnd}
  deriving (InlineShapeOr_ListOfSequence_Elmt
-> InlineShapeOr_ListOfSequence_Elmt -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: InlineShapeOr_ListOfSequence_Elmt
-> InlineShapeOr_ListOfSequence_Elmt -> Bool
$c/= :: InlineShapeOr_ListOfSequence_Elmt
-> InlineShapeOr_ListOfSequence_Elmt -> Bool
== :: InlineShapeOr_ListOfSequence_Elmt
-> InlineShapeOr_ListOfSequence_Elmt -> Bool
$c== :: InlineShapeOr_ListOfSequence_Elmt
-> InlineShapeOr_ListOfSequence_Elmt -> Bool
Eq, Eq InlineShapeOr_ListOfSequence_Elmt
InlineShapeOr_ListOfSequence_Elmt
-> InlineShapeOr_ListOfSequence_Elmt -> Bool
InlineShapeOr_ListOfSequence_Elmt
-> InlineShapeOr_ListOfSequence_Elmt -> Ordering
InlineShapeOr_ListOfSequence_Elmt
-> InlineShapeOr_ListOfSequence_Elmt
-> InlineShapeOr_ListOfSequence_Elmt
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
min :: InlineShapeOr_ListOfSequence_Elmt
-> InlineShapeOr_ListOfSequence_Elmt
-> InlineShapeOr_ListOfSequence_Elmt
$cmin :: InlineShapeOr_ListOfSequence_Elmt
-> InlineShapeOr_ListOfSequence_Elmt
-> InlineShapeOr_ListOfSequence_Elmt
max :: InlineShapeOr_ListOfSequence_Elmt
-> InlineShapeOr_ListOfSequence_Elmt
-> InlineShapeOr_ListOfSequence_Elmt
$cmax :: InlineShapeOr_ListOfSequence_Elmt
-> InlineShapeOr_ListOfSequence_Elmt
-> InlineShapeOr_ListOfSequence_Elmt
>= :: InlineShapeOr_ListOfSequence_Elmt
-> InlineShapeOr_ListOfSequence_Elmt -> Bool
$c>= :: InlineShapeOr_ListOfSequence_Elmt
-> InlineShapeOr_ListOfSequence_Elmt -> Bool
> :: InlineShapeOr_ListOfSequence_Elmt
-> InlineShapeOr_ListOfSequence_Elmt -> Bool
$c> :: InlineShapeOr_ListOfSequence_Elmt
-> InlineShapeOr_ListOfSequence_Elmt -> Bool
<= :: InlineShapeOr_ListOfSequence_Elmt
-> InlineShapeOr_ListOfSequence_Elmt -> Bool
$c<= :: InlineShapeOr_ListOfSequence_Elmt
-> InlineShapeOr_ListOfSequence_Elmt -> Bool
< :: InlineShapeOr_ListOfSequence_Elmt
-> InlineShapeOr_ListOfSequence_Elmt -> Bool
$c< :: InlineShapeOr_ListOfSequence_Elmt
-> InlineShapeOr_ListOfSequence_Elmt -> Bool
compare :: InlineShapeOr_ListOfSequence_Elmt
-> InlineShapeOr_ListOfSequence_Elmt -> Ordering
$ccompare :: InlineShapeOr_ListOfSequence_Elmt
-> InlineShapeOr_ListOfSequence_Elmt -> Ordering
Ord, ReadPrec [InlineShapeOr_ListOfSequence_Elmt]
ReadPrec InlineShapeOr_ListOfSequence_Elmt
Int -> ReadS InlineShapeOr_ListOfSequence_Elmt
ReadS [InlineShapeOr_ListOfSequence_Elmt]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [InlineShapeOr_ListOfSequence_Elmt]
$creadListPrec :: ReadPrec [InlineShapeOr_ListOfSequence_Elmt]
readPrec :: ReadPrec InlineShapeOr_ListOfSequence_Elmt
$creadPrec :: ReadPrec InlineShapeOr_ListOfSequence_Elmt
readList :: ReadS [InlineShapeOr_ListOfSequence_Elmt]
$creadList :: ReadS [InlineShapeOr_ListOfSequence_Elmt]
readsPrec :: Int -> ReadS InlineShapeOr_ListOfSequence_Elmt
$creadsPrec :: Int -> ReadS InlineShapeOr_ListOfSequence_Elmt
Read, Int -> InlineShapeOr_ListOfSequence_Elmt -> ShowS
[InlineShapeOr_ListOfSequence_Elmt] -> ShowS
InlineShapeOr_ListOfSequence_Elmt -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [InlineShapeOr_ListOfSequence_Elmt] -> ShowS
$cshowList :: [InlineShapeOr_ListOfSequence_Elmt] -> ShowS
show :: InlineShapeOr_ListOfSequence_Elmt -> String
$cshow :: InlineShapeOr_ListOfSequence_Elmt -> String
showsPrec :: Int -> InlineShapeOr_ListOfSequence_Elmt -> ShowS
$cshowsPrec :: Int -> InlineShapeOr_ListOfSequence_Elmt -> ShowS
Show)

_InlineShapeOr_ListOfSequence_Elmt :: Name
_InlineShapeOr_ListOfSequence_Elmt = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.InlineShapeOr.ListOfSequence.Elmt")

_InlineShapeOr_ListOfSequence_Elmt_inlineShapeAnd :: FieldName
_InlineShapeOr_ListOfSequence_Elmt_inlineShapeAnd = (String -> FieldName
Core.FieldName String
"inlineShapeAnd")

data ShapeAnd = 
  ShapeAnd {
    ShapeAnd -> ShapeNot
shapeAndShapeNot :: ShapeNot,
    ShapeAnd -> [ShapeAnd_ListOfSequence_Elmt]
shapeAndListOfSequence :: [ShapeAnd_ListOfSequence_Elmt]}
  deriving (ShapeAnd -> ShapeAnd -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ShapeAnd -> ShapeAnd -> Bool
$c/= :: ShapeAnd -> ShapeAnd -> Bool
== :: ShapeAnd -> ShapeAnd -> Bool
$c== :: ShapeAnd -> ShapeAnd -> Bool
Eq, Eq ShapeAnd
ShapeAnd -> ShapeAnd -> Bool
ShapeAnd -> ShapeAnd -> Ordering
ShapeAnd -> ShapeAnd -> ShapeAnd
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
min :: ShapeAnd -> ShapeAnd -> ShapeAnd
$cmin :: ShapeAnd -> ShapeAnd -> ShapeAnd
max :: ShapeAnd -> ShapeAnd -> ShapeAnd
$cmax :: ShapeAnd -> ShapeAnd -> ShapeAnd
>= :: ShapeAnd -> ShapeAnd -> Bool
$c>= :: ShapeAnd -> ShapeAnd -> Bool
> :: ShapeAnd -> ShapeAnd -> Bool
$c> :: ShapeAnd -> ShapeAnd -> Bool
<= :: ShapeAnd -> ShapeAnd -> Bool
$c<= :: ShapeAnd -> ShapeAnd -> Bool
< :: ShapeAnd -> ShapeAnd -> Bool
$c< :: ShapeAnd -> ShapeAnd -> Bool
compare :: ShapeAnd -> ShapeAnd -> Ordering
$ccompare :: ShapeAnd -> ShapeAnd -> Ordering
Ord, ReadPrec [ShapeAnd]
ReadPrec ShapeAnd
Int -> ReadS ShapeAnd
ReadS [ShapeAnd]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ShapeAnd]
$creadListPrec :: ReadPrec [ShapeAnd]
readPrec :: ReadPrec ShapeAnd
$creadPrec :: ReadPrec ShapeAnd
readList :: ReadS [ShapeAnd]
$creadList :: ReadS [ShapeAnd]
readsPrec :: Int -> ReadS ShapeAnd
$creadsPrec :: Int -> ReadS ShapeAnd
Read, Int -> ShapeAnd -> ShowS
[ShapeAnd] -> ShowS
ShapeAnd -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ShapeAnd] -> ShowS
$cshowList :: [ShapeAnd] -> ShowS
show :: ShapeAnd -> String
$cshow :: ShapeAnd -> String
showsPrec :: Int -> ShapeAnd -> ShowS
$cshowsPrec :: Int -> ShapeAnd -> ShowS
Show)

_ShapeAnd :: Name
_ShapeAnd = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.ShapeAnd")

_ShapeAnd_shapeNot :: FieldName
_ShapeAnd_shapeNot = (String -> FieldName
Core.FieldName String
"shapeNot")

_ShapeAnd_listOfSequence :: FieldName
_ShapeAnd_listOfSequence = (String -> FieldName
Core.FieldName String
"listOfSequence")

data ShapeAnd_ListOfSequence_Elmt = 
  ShapeAnd_ListOfSequence_Elmt {
    ShapeAnd_ListOfSequence_Elmt -> ShapeNot
shapeAnd_ListOfSequence_ElmtShapeNot :: ShapeNot}
  deriving (ShapeAnd_ListOfSequence_Elmt
-> ShapeAnd_ListOfSequence_Elmt -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ShapeAnd_ListOfSequence_Elmt
-> ShapeAnd_ListOfSequence_Elmt -> Bool
$c/= :: ShapeAnd_ListOfSequence_Elmt
-> ShapeAnd_ListOfSequence_Elmt -> Bool
== :: ShapeAnd_ListOfSequence_Elmt
-> ShapeAnd_ListOfSequence_Elmt -> Bool
$c== :: ShapeAnd_ListOfSequence_Elmt
-> ShapeAnd_ListOfSequence_Elmt -> Bool
Eq, Eq ShapeAnd_ListOfSequence_Elmt
ShapeAnd_ListOfSequence_Elmt
-> ShapeAnd_ListOfSequence_Elmt -> Bool
ShapeAnd_ListOfSequence_Elmt
-> ShapeAnd_ListOfSequence_Elmt -> Ordering
ShapeAnd_ListOfSequence_Elmt
-> ShapeAnd_ListOfSequence_Elmt -> ShapeAnd_ListOfSequence_Elmt
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
min :: ShapeAnd_ListOfSequence_Elmt
-> ShapeAnd_ListOfSequence_Elmt -> ShapeAnd_ListOfSequence_Elmt
$cmin :: ShapeAnd_ListOfSequence_Elmt
-> ShapeAnd_ListOfSequence_Elmt -> ShapeAnd_ListOfSequence_Elmt
max :: ShapeAnd_ListOfSequence_Elmt
-> ShapeAnd_ListOfSequence_Elmt -> ShapeAnd_ListOfSequence_Elmt
$cmax :: ShapeAnd_ListOfSequence_Elmt
-> ShapeAnd_ListOfSequence_Elmt -> ShapeAnd_ListOfSequence_Elmt
>= :: ShapeAnd_ListOfSequence_Elmt
-> ShapeAnd_ListOfSequence_Elmt -> Bool
$c>= :: ShapeAnd_ListOfSequence_Elmt
-> ShapeAnd_ListOfSequence_Elmt -> Bool
> :: ShapeAnd_ListOfSequence_Elmt
-> ShapeAnd_ListOfSequence_Elmt -> Bool
$c> :: ShapeAnd_ListOfSequence_Elmt
-> ShapeAnd_ListOfSequence_Elmt -> Bool
<= :: ShapeAnd_ListOfSequence_Elmt
-> ShapeAnd_ListOfSequence_Elmt -> Bool
$c<= :: ShapeAnd_ListOfSequence_Elmt
-> ShapeAnd_ListOfSequence_Elmt -> Bool
< :: ShapeAnd_ListOfSequence_Elmt
-> ShapeAnd_ListOfSequence_Elmt -> Bool
$c< :: ShapeAnd_ListOfSequence_Elmt
-> ShapeAnd_ListOfSequence_Elmt -> Bool
compare :: ShapeAnd_ListOfSequence_Elmt
-> ShapeAnd_ListOfSequence_Elmt -> Ordering
$ccompare :: ShapeAnd_ListOfSequence_Elmt
-> ShapeAnd_ListOfSequence_Elmt -> Ordering
Ord, ReadPrec [ShapeAnd_ListOfSequence_Elmt]
ReadPrec ShapeAnd_ListOfSequence_Elmt
Int -> ReadS ShapeAnd_ListOfSequence_Elmt
ReadS [ShapeAnd_ListOfSequence_Elmt]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ShapeAnd_ListOfSequence_Elmt]
$creadListPrec :: ReadPrec [ShapeAnd_ListOfSequence_Elmt]
readPrec :: ReadPrec ShapeAnd_ListOfSequence_Elmt
$creadPrec :: ReadPrec ShapeAnd_ListOfSequence_Elmt
readList :: ReadS [ShapeAnd_ListOfSequence_Elmt]
$creadList :: ReadS [ShapeAnd_ListOfSequence_Elmt]
readsPrec :: Int -> ReadS ShapeAnd_ListOfSequence_Elmt
$creadsPrec :: Int -> ReadS ShapeAnd_ListOfSequence_Elmt
Read, Int -> ShapeAnd_ListOfSequence_Elmt -> ShowS
[ShapeAnd_ListOfSequence_Elmt] -> ShowS
ShapeAnd_ListOfSequence_Elmt -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ShapeAnd_ListOfSequence_Elmt] -> ShowS
$cshowList :: [ShapeAnd_ListOfSequence_Elmt] -> ShowS
show :: ShapeAnd_ListOfSequence_Elmt -> String
$cshow :: ShapeAnd_ListOfSequence_Elmt -> String
showsPrec :: Int -> ShapeAnd_ListOfSequence_Elmt -> ShowS
$cshowsPrec :: Int -> ShapeAnd_ListOfSequence_Elmt -> ShowS
Show)

_ShapeAnd_ListOfSequence_Elmt :: Name
_ShapeAnd_ListOfSequence_Elmt = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.ShapeAnd.ListOfSequence.Elmt")

_ShapeAnd_ListOfSequence_Elmt_shapeNot :: FieldName
_ShapeAnd_ListOfSequence_Elmt_shapeNot = (String -> FieldName
Core.FieldName String
"shapeNot")

data InlineShapeAnd = 
  InlineShapeAnd {
    InlineShapeAnd -> InlineShapeNot
inlineShapeAndInlineShapeNot :: InlineShapeNot,
    InlineShapeAnd -> [InlineShapeAnd_ListOfSequence_Elmt]
inlineShapeAndListOfSequence :: [InlineShapeAnd_ListOfSequence_Elmt]}
  deriving (InlineShapeAnd -> InlineShapeAnd -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: InlineShapeAnd -> InlineShapeAnd -> Bool
$c/= :: InlineShapeAnd -> InlineShapeAnd -> Bool
== :: InlineShapeAnd -> InlineShapeAnd -> Bool
$c== :: InlineShapeAnd -> InlineShapeAnd -> Bool
Eq, Eq InlineShapeAnd
InlineShapeAnd -> InlineShapeAnd -> Bool
InlineShapeAnd -> InlineShapeAnd -> Ordering
InlineShapeAnd -> InlineShapeAnd -> InlineShapeAnd
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
min :: InlineShapeAnd -> InlineShapeAnd -> InlineShapeAnd
$cmin :: InlineShapeAnd -> InlineShapeAnd -> InlineShapeAnd
max :: InlineShapeAnd -> InlineShapeAnd -> InlineShapeAnd
$cmax :: InlineShapeAnd -> InlineShapeAnd -> InlineShapeAnd
>= :: InlineShapeAnd -> InlineShapeAnd -> Bool
$c>= :: InlineShapeAnd -> InlineShapeAnd -> Bool
> :: InlineShapeAnd -> InlineShapeAnd -> Bool
$c> :: InlineShapeAnd -> InlineShapeAnd -> Bool
<= :: InlineShapeAnd -> InlineShapeAnd -> Bool
$c<= :: InlineShapeAnd -> InlineShapeAnd -> Bool
< :: InlineShapeAnd -> InlineShapeAnd -> Bool
$c< :: InlineShapeAnd -> InlineShapeAnd -> Bool
compare :: InlineShapeAnd -> InlineShapeAnd -> Ordering
$ccompare :: InlineShapeAnd -> InlineShapeAnd -> Ordering
Ord, ReadPrec [InlineShapeAnd]
ReadPrec InlineShapeAnd
Int -> ReadS InlineShapeAnd
ReadS [InlineShapeAnd]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [InlineShapeAnd]
$creadListPrec :: ReadPrec [InlineShapeAnd]
readPrec :: ReadPrec InlineShapeAnd
$creadPrec :: ReadPrec InlineShapeAnd
readList :: ReadS [InlineShapeAnd]
$creadList :: ReadS [InlineShapeAnd]
readsPrec :: Int -> ReadS InlineShapeAnd
$creadsPrec :: Int -> ReadS InlineShapeAnd
Read, Int -> InlineShapeAnd -> ShowS
[InlineShapeAnd] -> ShowS
InlineShapeAnd -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [InlineShapeAnd] -> ShowS
$cshowList :: [InlineShapeAnd] -> ShowS
show :: InlineShapeAnd -> String
$cshow :: InlineShapeAnd -> String
showsPrec :: Int -> InlineShapeAnd -> ShowS
$cshowsPrec :: Int -> InlineShapeAnd -> ShowS
Show)

_InlineShapeAnd :: Name
_InlineShapeAnd = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.InlineShapeAnd")

_InlineShapeAnd_inlineShapeNot :: FieldName
_InlineShapeAnd_inlineShapeNot = (String -> FieldName
Core.FieldName String
"inlineShapeNot")

_InlineShapeAnd_listOfSequence :: FieldName
_InlineShapeAnd_listOfSequence = (String -> FieldName
Core.FieldName String
"listOfSequence")

data InlineShapeAnd_ListOfSequence_Elmt = 
  InlineShapeAnd_ListOfSequence_Elmt {
    InlineShapeAnd_ListOfSequence_Elmt -> InlineShapeNot
inlineShapeAnd_ListOfSequence_ElmtInlineShapeNot :: InlineShapeNot}
  deriving (InlineShapeAnd_ListOfSequence_Elmt
-> InlineShapeAnd_ListOfSequence_Elmt -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: InlineShapeAnd_ListOfSequence_Elmt
-> InlineShapeAnd_ListOfSequence_Elmt -> Bool
$c/= :: InlineShapeAnd_ListOfSequence_Elmt
-> InlineShapeAnd_ListOfSequence_Elmt -> Bool
== :: InlineShapeAnd_ListOfSequence_Elmt
-> InlineShapeAnd_ListOfSequence_Elmt -> Bool
$c== :: InlineShapeAnd_ListOfSequence_Elmt
-> InlineShapeAnd_ListOfSequence_Elmt -> Bool
Eq, Eq InlineShapeAnd_ListOfSequence_Elmt
InlineShapeAnd_ListOfSequence_Elmt
-> InlineShapeAnd_ListOfSequence_Elmt -> Bool
InlineShapeAnd_ListOfSequence_Elmt
-> InlineShapeAnd_ListOfSequence_Elmt -> Ordering
InlineShapeAnd_ListOfSequence_Elmt
-> InlineShapeAnd_ListOfSequence_Elmt
-> InlineShapeAnd_ListOfSequence_Elmt
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
min :: InlineShapeAnd_ListOfSequence_Elmt
-> InlineShapeAnd_ListOfSequence_Elmt
-> InlineShapeAnd_ListOfSequence_Elmt
$cmin :: InlineShapeAnd_ListOfSequence_Elmt
-> InlineShapeAnd_ListOfSequence_Elmt
-> InlineShapeAnd_ListOfSequence_Elmt
max :: InlineShapeAnd_ListOfSequence_Elmt
-> InlineShapeAnd_ListOfSequence_Elmt
-> InlineShapeAnd_ListOfSequence_Elmt
$cmax :: InlineShapeAnd_ListOfSequence_Elmt
-> InlineShapeAnd_ListOfSequence_Elmt
-> InlineShapeAnd_ListOfSequence_Elmt
>= :: InlineShapeAnd_ListOfSequence_Elmt
-> InlineShapeAnd_ListOfSequence_Elmt -> Bool
$c>= :: InlineShapeAnd_ListOfSequence_Elmt
-> InlineShapeAnd_ListOfSequence_Elmt -> Bool
> :: InlineShapeAnd_ListOfSequence_Elmt
-> InlineShapeAnd_ListOfSequence_Elmt -> Bool
$c> :: InlineShapeAnd_ListOfSequence_Elmt
-> InlineShapeAnd_ListOfSequence_Elmt -> Bool
<= :: InlineShapeAnd_ListOfSequence_Elmt
-> InlineShapeAnd_ListOfSequence_Elmt -> Bool
$c<= :: InlineShapeAnd_ListOfSequence_Elmt
-> InlineShapeAnd_ListOfSequence_Elmt -> Bool
< :: InlineShapeAnd_ListOfSequence_Elmt
-> InlineShapeAnd_ListOfSequence_Elmt -> Bool
$c< :: InlineShapeAnd_ListOfSequence_Elmt
-> InlineShapeAnd_ListOfSequence_Elmt -> Bool
compare :: InlineShapeAnd_ListOfSequence_Elmt
-> InlineShapeAnd_ListOfSequence_Elmt -> Ordering
$ccompare :: InlineShapeAnd_ListOfSequence_Elmt
-> InlineShapeAnd_ListOfSequence_Elmt -> Ordering
Ord, ReadPrec [InlineShapeAnd_ListOfSequence_Elmt]
ReadPrec InlineShapeAnd_ListOfSequence_Elmt
Int -> ReadS InlineShapeAnd_ListOfSequence_Elmt
ReadS [InlineShapeAnd_ListOfSequence_Elmt]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [InlineShapeAnd_ListOfSequence_Elmt]
$creadListPrec :: ReadPrec [InlineShapeAnd_ListOfSequence_Elmt]
readPrec :: ReadPrec InlineShapeAnd_ListOfSequence_Elmt
$creadPrec :: ReadPrec InlineShapeAnd_ListOfSequence_Elmt
readList :: ReadS [InlineShapeAnd_ListOfSequence_Elmt]
$creadList :: ReadS [InlineShapeAnd_ListOfSequence_Elmt]
readsPrec :: Int -> ReadS InlineShapeAnd_ListOfSequence_Elmt
$creadsPrec :: Int -> ReadS InlineShapeAnd_ListOfSequence_Elmt
Read, Int -> InlineShapeAnd_ListOfSequence_Elmt -> ShowS
[InlineShapeAnd_ListOfSequence_Elmt] -> ShowS
InlineShapeAnd_ListOfSequence_Elmt -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [InlineShapeAnd_ListOfSequence_Elmt] -> ShowS
$cshowList :: [InlineShapeAnd_ListOfSequence_Elmt] -> ShowS
show :: InlineShapeAnd_ListOfSequence_Elmt -> String
$cshow :: InlineShapeAnd_ListOfSequence_Elmt -> String
showsPrec :: Int -> InlineShapeAnd_ListOfSequence_Elmt -> ShowS
$cshowsPrec :: Int -> InlineShapeAnd_ListOfSequence_Elmt -> ShowS
Show)

_InlineShapeAnd_ListOfSequence_Elmt :: Name
_InlineShapeAnd_ListOfSequence_Elmt = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.InlineShapeAnd.ListOfSequence.Elmt")

_InlineShapeAnd_ListOfSequence_Elmt_inlineShapeNot :: FieldName
_InlineShapeAnd_ListOfSequence_Elmt_inlineShapeNot = (String -> FieldName
Core.FieldName String
"inlineShapeNot")

data ShapeNot = 
  ShapeNot {
    ShapeNot -> Maybe ()
shapeNotNOT :: (Maybe ()),
    ShapeNot -> ShapeAtom
shapeNotShapeAtom :: ShapeAtom}
  deriving (ShapeNot -> ShapeNot -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ShapeNot -> ShapeNot -> Bool
$c/= :: ShapeNot -> ShapeNot -> Bool
== :: ShapeNot -> ShapeNot -> Bool
$c== :: ShapeNot -> ShapeNot -> Bool
Eq, Eq ShapeNot
ShapeNot -> ShapeNot -> Bool
ShapeNot -> ShapeNot -> Ordering
ShapeNot -> ShapeNot -> ShapeNot
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
min :: ShapeNot -> ShapeNot -> ShapeNot
$cmin :: ShapeNot -> ShapeNot -> ShapeNot
max :: ShapeNot -> ShapeNot -> ShapeNot
$cmax :: ShapeNot -> ShapeNot -> ShapeNot
>= :: ShapeNot -> ShapeNot -> Bool
$c>= :: ShapeNot -> ShapeNot -> Bool
> :: ShapeNot -> ShapeNot -> Bool
$c> :: ShapeNot -> ShapeNot -> Bool
<= :: ShapeNot -> ShapeNot -> Bool
$c<= :: ShapeNot -> ShapeNot -> Bool
< :: ShapeNot -> ShapeNot -> Bool
$c< :: ShapeNot -> ShapeNot -> Bool
compare :: ShapeNot -> ShapeNot -> Ordering
$ccompare :: ShapeNot -> ShapeNot -> Ordering
Ord, ReadPrec [ShapeNot]
ReadPrec ShapeNot
Int -> ReadS ShapeNot
ReadS [ShapeNot]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ShapeNot]
$creadListPrec :: ReadPrec [ShapeNot]
readPrec :: ReadPrec ShapeNot
$creadPrec :: ReadPrec ShapeNot
readList :: ReadS [ShapeNot]
$creadList :: ReadS [ShapeNot]
readsPrec :: Int -> ReadS ShapeNot
$creadsPrec :: Int -> ReadS ShapeNot
Read, Int -> ShapeNot -> ShowS
[ShapeNot] -> ShowS
ShapeNot -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ShapeNot] -> ShowS
$cshowList :: [ShapeNot] -> ShowS
show :: ShapeNot -> String
$cshow :: ShapeNot -> String
showsPrec :: Int -> ShapeNot -> ShowS
$cshowsPrec :: Int -> ShapeNot -> ShowS
Show)

_ShapeNot :: Name
_ShapeNot = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.ShapeNot")

_ShapeNot_nOT :: FieldName
_ShapeNot_nOT = (String -> FieldName
Core.FieldName String
"nOT")

_ShapeNot_shapeAtom :: FieldName
_ShapeNot_shapeAtom = (String -> FieldName
Core.FieldName String
"shapeAtom")

data InlineShapeNot = 
  InlineShapeNot {
    InlineShapeNot -> Maybe ()
inlineShapeNotNOT :: (Maybe ()),
    InlineShapeNot -> InlineShapeAtom
inlineShapeNotInlineShapeAtom :: InlineShapeAtom}
  deriving (InlineShapeNot -> InlineShapeNot -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: InlineShapeNot -> InlineShapeNot -> Bool
$c/= :: InlineShapeNot -> InlineShapeNot -> Bool
== :: InlineShapeNot -> InlineShapeNot -> Bool
$c== :: InlineShapeNot -> InlineShapeNot -> Bool
Eq, Eq InlineShapeNot
InlineShapeNot -> InlineShapeNot -> Bool
InlineShapeNot -> InlineShapeNot -> Ordering
InlineShapeNot -> InlineShapeNot -> InlineShapeNot
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
min :: InlineShapeNot -> InlineShapeNot -> InlineShapeNot
$cmin :: InlineShapeNot -> InlineShapeNot -> InlineShapeNot
max :: InlineShapeNot -> InlineShapeNot -> InlineShapeNot
$cmax :: InlineShapeNot -> InlineShapeNot -> InlineShapeNot
>= :: InlineShapeNot -> InlineShapeNot -> Bool
$c>= :: InlineShapeNot -> InlineShapeNot -> Bool
> :: InlineShapeNot -> InlineShapeNot -> Bool
$c> :: InlineShapeNot -> InlineShapeNot -> Bool
<= :: InlineShapeNot -> InlineShapeNot -> Bool
$c<= :: InlineShapeNot -> InlineShapeNot -> Bool
< :: InlineShapeNot -> InlineShapeNot -> Bool
$c< :: InlineShapeNot -> InlineShapeNot -> Bool
compare :: InlineShapeNot -> InlineShapeNot -> Ordering
$ccompare :: InlineShapeNot -> InlineShapeNot -> Ordering
Ord, ReadPrec [InlineShapeNot]
ReadPrec InlineShapeNot
Int -> ReadS InlineShapeNot
ReadS [InlineShapeNot]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [InlineShapeNot]
$creadListPrec :: ReadPrec [InlineShapeNot]
readPrec :: ReadPrec InlineShapeNot
$creadPrec :: ReadPrec InlineShapeNot
readList :: ReadS [InlineShapeNot]
$creadList :: ReadS [InlineShapeNot]
readsPrec :: Int -> ReadS InlineShapeNot
$creadsPrec :: Int -> ReadS InlineShapeNot
Read, Int -> InlineShapeNot -> ShowS
[InlineShapeNot] -> ShowS
InlineShapeNot -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [InlineShapeNot] -> ShowS
$cshowList :: [InlineShapeNot] -> ShowS
show :: InlineShapeNot -> String
$cshow :: InlineShapeNot -> String
showsPrec :: Int -> InlineShapeNot -> ShowS
$cshowsPrec :: Int -> InlineShapeNot -> ShowS
Show)

_InlineShapeNot :: Name
_InlineShapeNot = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.InlineShapeNot")

_InlineShapeNot_nOT :: FieldName
_InlineShapeNot_nOT = (String -> FieldName
Core.FieldName String
"nOT")

_InlineShapeNot_inlineShapeAtom :: FieldName
_InlineShapeNot_inlineShapeAtom = (String -> FieldName
Core.FieldName String
"inlineShapeAtom")

data ShapeAtom = 
  ShapeAtomSequence ShapeAtom_Sequence |
  ShapeAtomShapeOrRef ShapeOrRef |
  ShapeAtomSequence2 ShapeAtom_Sequence2 |
  ShapeAtomPeriod 
  deriving (ShapeAtom -> ShapeAtom -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ShapeAtom -> ShapeAtom -> Bool
$c/= :: ShapeAtom -> ShapeAtom -> Bool
== :: ShapeAtom -> ShapeAtom -> Bool
$c== :: ShapeAtom -> ShapeAtom -> Bool
Eq, Eq ShapeAtom
ShapeAtom -> ShapeAtom -> Bool
ShapeAtom -> ShapeAtom -> Ordering
ShapeAtom -> ShapeAtom -> ShapeAtom
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
min :: ShapeAtom -> ShapeAtom -> ShapeAtom
$cmin :: ShapeAtom -> ShapeAtom -> ShapeAtom
max :: ShapeAtom -> ShapeAtom -> ShapeAtom
$cmax :: ShapeAtom -> ShapeAtom -> ShapeAtom
>= :: ShapeAtom -> ShapeAtom -> Bool
$c>= :: ShapeAtom -> ShapeAtom -> Bool
> :: ShapeAtom -> ShapeAtom -> Bool
$c> :: ShapeAtom -> ShapeAtom -> Bool
<= :: ShapeAtom -> ShapeAtom -> Bool
$c<= :: ShapeAtom -> ShapeAtom -> Bool
< :: ShapeAtom -> ShapeAtom -> Bool
$c< :: ShapeAtom -> ShapeAtom -> Bool
compare :: ShapeAtom -> ShapeAtom -> Ordering
$ccompare :: ShapeAtom -> ShapeAtom -> Ordering
Ord, ReadPrec [ShapeAtom]
ReadPrec ShapeAtom
Int -> ReadS ShapeAtom
ReadS [ShapeAtom]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ShapeAtom]
$creadListPrec :: ReadPrec [ShapeAtom]
readPrec :: ReadPrec ShapeAtom
$creadPrec :: ReadPrec ShapeAtom
readList :: ReadS [ShapeAtom]
$creadList :: ReadS [ShapeAtom]
readsPrec :: Int -> ReadS ShapeAtom
$creadsPrec :: Int -> ReadS ShapeAtom
Read, Int -> ShapeAtom -> ShowS
[ShapeAtom] -> ShowS
ShapeAtom -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ShapeAtom] -> ShowS
$cshowList :: [ShapeAtom] -> ShowS
show :: ShapeAtom -> String
$cshow :: ShapeAtom -> String
showsPrec :: Int -> ShapeAtom -> ShowS
$cshowsPrec :: Int -> ShapeAtom -> ShowS
Show)

_ShapeAtom :: Name
_ShapeAtom = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.ShapeAtom")

_ShapeAtom_sequence :: FieldName
_ShapeAtom_sequence = (String -> FieldName
Core.FieldName String
"sequence")

_ShapeAtom_shapeOrRef :: FieldName
_ShapeAtom_shapeOrRef = (String -> FieldName
Core.FieldName String
"shapeOrRef")

_ShapeAtom_sequence2 :: FieldName
_ShapeAtom_sequence2 = (String -> FieldName
Core.FieldName String
"sequence2")

_ShapeAtom_period :: FieldName
_ShapeAtom_period = (String -> FieldName
Core.FieldName String
"period")

data ShapeAtom_Sequence = 
  ShapeAtom_Sequence {
    ShapeAtom_Sequence -> NodeConstraint
shapeAtom_SequenceNodeConstraint :: NodeConstraint,
    ShapeAtom_Sequence -> Maybe ShapeOrRef
shapeAtom_SequenceShapeOrRef :: (Maybe ShapeOrRef)}
  deriving (ShapeAtom_Sequence -> ShapeAtom_Sequence -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ShapeAtom_Sequence -> ShapeAtom_Sequence -> Bool
$c/= :: ShapeAtom_Sequence -> ShapeAtom_Sequence -> Bool
== :: ShapeAtom_Sequence -> ShapeAtom_Sequence -> Bool
$c== :: ShapeAtom_Sequence -> ShapeAtom_Sequence -> Bool
Eq, Eq ShapeAtom_Sequence
ShapeAtom_Sequence -> ShapeAtom_Sequence -> Bool
ShapeAtom_Sequence -> ShapeAtom_Sequence -> Ordering
ShapeAtom_Sequence -> ShapeAtom_Sequence -> ShapeAtom_Sequence
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
min :: ShapeAtom_Sequence -> ShapeAtom_Sequence -> ShapeAtom_Sequence
$cmin :: ShapeAtom_Sequence -> ShapeAtom_Sequence -> ShapeAtom_Sequence
max :: ShapeAtom_Sequence -> ShapeAtom_Sequence -> ShapeAtom_Sequence
$cmax :: ShapeAtom_Sequence -> ShapeAtom_Sequence -> ShapeAtom_Sequence
>= :: ShapeAtom_Sequence -> ShapeAtom_Sequence -> Bool
$c>= :: ShapeAtom_Sequence -> ShapeAtom_Sequence -> Bool
> :: ShapeAtom_Sequence -> ShapeAtom_Sequence -> Bool
$c> :: ShapeAtom_Sequence -> ShapeAtom_Sequence -> Bool
<= :: ShapeAtom_Sequence -> ShapeAtom_Sequence -> Bool
$c<= :: ShapeAtom_Sequence -> ShapeAtom_Sequence -> Bool
< :: ShapeAtom_Sequence -> ShapeAtom_Sequence -> Bool
$c< :: ShapeAtom_Sequence -> ShapeAtom_Sequence -> Bool
compare :: ShapeAtom_Sequence -> ShapeAtom_Sequence -> Ordering
$ccompare :: ShapeAtom_Sequence -> ShapeAtom_Sequence -> Ordering
Ord, ReadPrec [ShapeAtom_Sequence]
ReadPrec ShapeAtom_Sequence
Int -> ReadS ShapeAtom_Sequence
ReadS [ShapeAtom_Sequence]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ShapeAtom_Sequence]
$creadListPrec :: ReadPrec [ShapeAtom_Sequence]
readPrec :: ReadPrec ShapeAtom_Sequence
$creadPrec :: ReadPrec ShapeAtom_Sequence
readList :: ReadS [ShapeAtom_Sequence]
$creadList :: ReadS [ShapeAtom_Sequence]
readsPrec :: Int -> ReadS ShapeAtom_Sequence
$creadsPrec :: Int -> ReadS ShapeAtom_Sequence
Read, Int -> ShapeAtom_Sequence -> ShowS
[ShapeAtom_Sequence] -> ShowS
ShapeAtom_Sequence -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ShapeAtom_Sequence] -> ShowS
$cshowList :: [ShapeAtom_Sequence] -> ShowS
show :: ShapeAtom_Sequence -> String
$cshow :: ShapeAtom_Sequence -> String
showsPrec :: Int -> ShapeAtom_Sequence -> ShowS
$cshowsPrec :: Int -> ShapeAtom_Sequence -> ShowS
Show)

_ShapeAtom_Sequence :: Name
_ShapeAtom_Sequence = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.ShapeAtom.Sequence")

_ShapeAtom_Sequence_nodeConstraint :: FieldName
_ShapeAtom_Sequence_nodeConstraint = (String -> FieldName
Core.FieldName String
"nodeConstraint")

_ShapeAtom_Sequence_shapeOrRef :: FieldName
_ShapeAtom_Sequence_shapeOrRef = (String -> FieldName
Core.FieldName String
"shapeOrRef")

data ShapeAtom_Sequence2 = 
  ShapeAtom_Sequence2 {
    ShapeAtom_Sequence2 -> ShapeExpression
shapeAtom_Sequence2ShapeExpression :: ShapeExpression}
  deriving (ShapeAtom_Sequence2 -> ShapeAtom_Sequence2 -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ShapeAtom_Sequence2 -> ShapeAtom_Sequence2 -> Bool
$c/= :: ShapeAtom_Sequence2 -> ShapeAtom_Sequence2 -> Bool
== :: ShapeAtom_Sequence2 -> ShapeAtom_Sequence2 -> Bool
$c== :: ShapeAtom_Sequence2 -> ShapeAtom_Sequence2 -> Bool
Eq, Eq ShapeAtom_Sequence2
ShapeAtom_Sequence2 -> ShapeAtom_Sequence2 -> Bool
ShapeAtom_Sequence2 -> ShapeAtom_Sequence2 -> Ordering
ShapeAtom_Sequence2 -> ShapeAtom_Sequence2 -> ShapeAtom_Sequence2
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
min :: ShapeAtom_Sequence2 -> ShapeAtom_Sequence2 -> ShapeAtom_Sequence2
$cmin :: ShapeAtom_Sequence2 -> ShapeAtom_Sequence2 -> ShapeAtom_Sequence2
max :: ShapeAtom_Sequence2 -> ShapeAtom_Sequence2 -> ShapeAtom_Sequence2
$cmax :: ShapeAtom_Sequence2 -> ShapeAtom_Sequence2 -> ShapeAtom_Sequence2
>= :: ShapeAtom_Sequence2 -> ShapeAtom_Sequence2 -> Bool
$c>= :: ShapeAtom_Sequence2 -> ShapeAtom_Sequence2 -> Bool
> :: ShapeAtom_Sequence2 -> ShapeAtom_Sequence2 -> Bool
$c> :: ShapeAtom_Sequence2 -> ShapeAtom_Sequence2 -> Bool
<= :: ShapeAtom_Sequence2 -> ShapeAtom_Sequence2 -> Bool
$c<= :: ShapeAtom_Sequence2 -> ShapeAtom_Sequence2 -> Bool
< :: ShapeAtom_Sequence2 -> ShapeAtom_Sequence2 -> Bool
$c< :: ShapeAtom_Sequence2 -> ShapeAtom_Sequence2 -> Bool
compare :: ShapeAtom_Sequence2 -> ShapeAtom_Sequence2 -> Ordering
$ccompare :: ShapeAtom_Sequence2 -> ShapeAtom_Sequence2 -> Ordering
Ord, ReadPrec [ShapeAtom_Sequence2]
ReadPrec ShapeAtom_Sequence2
Int -> ReadS ShapeAtom_Sequence2
ReadS [ShapeAtom_Sequence2]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ShapeAtom_Sequence2]
$creadListPrec :: ReadPrec [ShapeAtom_Sequence2]
readPrec :: ReadPrec ShapeAtom_Sequence2
$creadPrec :: ReadPrec ShapeAtom_Sequence2
readList :: ReadS [ShapeAtom_Sequence2]
$creadList :: ReadS [ShapeAtom_Sequence2]
readsPrec :: Int -> ReadS ShapeAtom_Sequence2
$creadsPrec :: Int -> ReadS ShapeAtom_Sequence2
Read, Int -> ShapeAtom_Sequence2 -> ShowS
[ShapeAtom_Sequence2] -> ShowS
ShapeAtom_Sequence2 -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ShapeAtom_Sequence2] -> ShowS
$cshowList :: [ShapeAtom_Sequence2] -> ShowS
show :: ShapeAtom_Sequence2 -> String
$cshow :: ShapeAtom_Sequence2 -> String
showsPrec :: Int -> ShapeAtom_Sequence2 -> ShowS
$cshowsPrec :: Int -> ShapeAtom_Sequence2 -> ShowS
Show)

_ShapeAtom_Sequence2 :: Name
_ShapeAtom_Sequence2 = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.ShapeAtom.Sequence2")

_ShapeAtom_Sequence2_shapeExpression :: FieldName
_ShapeAtom_Sequence2_shapeExpression = (String -> FieldName
Core.FieldName String
"shapeExpression")

data InlineShapeAtom = 
  InlineShapeAtomSequence InlineShapeAtom_Sequence |
  InlineShapeAtomSequence2 InlineShapeAtom_Sequence2 |
  InlineShapeAtomSequence3 InlineShapeAtom_Sequence3 |
  InlineShapeAtomPeriod 
  deriving (InlineShapeAtom -> InlineShapeAtom -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: InlineShapeAtom -> InlineShapeAtom -> Bool
$c/= :: InlineShapeAtom -> InlineShapeAtom -> Bool
== :: InlineShapeAtom -> InlineShapeAtom -> Bool
$c== :: InlineShapeAtom -> InlineShapeAtom -> Bool
Eq, Eq InlineShapeAtom
InlineShapeAtom -> InlineShapeAtom -> Bool
InlineShapeAtom -> InlineShapeAtom -> Ordering
InlineShapeAtom -> InlineShapeAtom -> InlineShapeAtom
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
min :: InlineShapeAtom -> InlineShapeAtom -> InlineShapeAtom
$cmin :: InlineShapeAtom -> InlineShapeAtom -> InlineShapeAtom
max :: InlineShapeAtom -> InlineShapeAtom -> InlineShapeAtom
$cmax :: InlineShapeAtom -> InlineShapeAtom -> InlineShapeAtom
>= :: InlineShapeAtom -> InlineShapeAtom -> Bool
$c>= :: InlineShapeAtom -> InlineShapeAtom -> Bool
> :: InlineShapeAtom -> InlineShapeAtom -> Bool
$c> :: InlineShapeAtom -> InlineShapeAtom -> Bool
<= :: InlineShapeAtom -> InlineShapeAtom -> Bool
$c<= :: InlineShapeAtom -> InlineShapeAtom -> Bool
< :: InlineShapeAtom -> InlineShapeAtom -> Bool
$c< :: InlineShapeAtom -> InlineShapeAtom -> Bool
compare :: InlineShapeAtom -> InlineShapeAtom -> Ordering
$ccompare :: InlineShapeAtom -> InlineShapeAtom -> Ordering
Ord, ReadPrec [InlineShapeAtom]
ReadPrec InlineShapeAtom
Int -> ReadS InlineShapeAtom
ReadS [InlineShapeAtom]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [InlineShapeAtom]
$creadListPrec :: ReadPrec [InlineShapeAtom]
readPrec :: ReadPrec InlineShapeAtom
$creadPrec :: ReadPrec InlineShapeAtom
readList :: ReadS [InlineShapeAtom]
$creadList :: ReadS [InlineShapeAtom]
readsPrec :: Int -> ReadS InlineShapeAtom
$creadsPrec :: Int -> ReadS InlineShapeAtom
Read, Int -> InlineShapeAtom -> ShowS
[InlineShapeAtom] -> ShowS
InlineShapeAtom -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [InlineShapeAtom] -> ShowS
$cshowList :: [InlineShapeAtom] -> ShowS
show :: InlineShapeAtom -> String
$cshow :: InlineShapeAtom -> String
showsPrec :: Int -> InlineShapeAtom -> ShowS
$cshowsPrec :: Int -> InlineShapeAtom -> ShowS
Show)

_InlineShapeAtom :: Name
_InlineShapeAtom = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.InlineShapeAtom")

_InlineShapeAtom_sequence :: FieldName
_InlineShapeAtom_sequence = (String -> FieldName
Core.FieldName String
"sequence")

_InlineShapeAtom_sequence2 :: FieldName
_InlineShapeAtom_sequence2 = (String -> FieldName
Core.FieldName String
"sequence2")

_InlineShapeAtom_sequence3 :: FieldName
_InlineShapeAtom_sequence3 = (String -> FieldName
Core.FieldName String
"sequence3")

_InlineShapeAtom_period :: FieldName
_InlineShapeAtom_period = (String -> FieldName
Core.FieldName String
"period")

data InlineShapeAtom_Sequence = 
  InlineShapeAtom_Sequence {
    InlineShapeAtom_Sequence -> NodeConstraint
inlineShapeAtom_SequenceNodeConstraint :: NodeConstraint,
    InlineShapeAtom_Sequence -> Maybe InlineShapeOrRef
inlineShapeAtom_SequenceInlineShapeOrRef :: (Maybe InlineShapeOrRef)}
  deriving (InlineShapeAtom_Sequence -> InlineShapeAtom_Sequence -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: InlineShapeAtom_Sequence -> InlineShapeAtom_Sequence -> Bool
$c/= :: InlineShapeAtom_Sequence -> InlineShapeAtom_Sequence -> Bool
== :: InlineShapeAtom_Sequence -> InlineShapeAtom_Sequence -> Bool
$c== :: InlineShapeAtom_Sequence -> InlineShapeAtom_Sequence -> Bool
Eq, Eq InlineShapeAtom_Sequence
InlineShapeAtom_Sequence -> InlineShapeAtom_Sequence -> Bool
InlineShapeAtom_Sequence -> InlineShapeAtom_Sequence -> Ordering
InlineShapeAtom_Sequence
-> InlineShapeAtom_Sequence -> InlineShapeAtom_Sequence
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
min :: InlineShapeAtom_Sequence
-> InlineShapeAtom_Sequence -> InlineShapeAtom_Sequence
$cmin :: InlineShapeAtom_Sequence
-> InlineShapeAtom_Sequence -> InlineShapeAtom_Sequence
max :: InlineShapeAtom_Sequence
-> InlineShapeAtom_Sequence -> InlineShapeAtom_Sequence
$cmax :: InlineShapeAtom_Sequence
-> InlineShapeAtom_Sequence -> InlineShapeAtom_Sequence
>= :: InlineShapeAtom_Sequence -> InlineShapeAtom_Sequence -> Bool
$c>= :: InlineShapeAtom_Sequence -> InlineShapeAtom_Sequence -> Bool
> :: InlineShapeAtom_Sequence -> InlineShapeAtom_Sequence -> Bool
$c> :: InlineShapeAtom_Sequence -> InlineShapeAtom_Sequence -> Bool
<= :: InlineShapeAtom_Sequence -> InlineShapeAtom_Sequence -> Bool
$c<= :: InlineShapeAtom_Sequence -> InlineShapeAtom_Sequence -> Bool
< :: InlineShapeAtom_Sequence -> InlineShapeAtom_Sequence -> Bool
$c< :: InlineShapeAtom_Sequence -> InlineShapeAtom_Sequence -> Bool
compare :: InlineShapeAtom_Sequence -> InlineShapeAtom_Sequence -> Ordering
$ccompare :: InlineShapeAtom_Sequence -> InlineShapeAtom_Sequence -> Ordering
Ord, ReadPrec [InlineShapeAtom_Sequence]
ReadPrec InlineShapeAtom_Sequence
Int -> ReadS InlineShapeAtom_Sequence
ReadS [InlineShapeAtom_Sequence]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [InlineShapeAtom_Sequence]
$creadListPrec :: ReadPrec [InlineShapeAtom_Sequence]
readPrec :: ReadPrec InlineShapeAtom_Sequence
$creadPrec :: ReadPrec InlineShapeAtom_Sequence
readList :: ReadS [InlineShapeAtom_Sequence]
$creadList :: ReadS [InlineShapeAtom_Sequence]
readsPrec :: Int -> ReadS InlineShapeAtom_Sequence
$creadsPrec :: Int -> ReadS InlineShapeAtom_Sequence
Read, Int -> InlineShapeAtom_Sequence -> ShowS
[InlineShapeAtom_Sequence] -> ShowS
InlineShapeAtom_Sequence -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [InlineShapeAtom_Sequence] -> ShowS
$cshowList :: [InlineShapeAtom_Sequence] -> ShowS
show :: InlineShapeAtom_Sequence -> String
$cshow :: InlineShapeAtom_Sequence -> String
showsPrec :: Int -> InlineShapeAtom_Sequence -> ShowS
$cshowsPrec :: Int -> InlineShapeAtom_Sequence -> ShowS
Show)

_InlineShapeAtom_Sequence :: Name
_InlineShapeAtom_Sequence = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.InlineShapeAtom.Sequence")

_InlineShapeAtom_Sequence_nodeConstraint :: FieldName
_InlineShapeAtom_Sequence_nodeConstraint = (String -> FieldName
Core.FieldName String
"nodeConstraint")

_InlineShapeAtom_Sequence_inlineShapeOrRef :: FieldName
_InlineShapeAtom_Sequence_inlineShapeOrRef = (String -> FieldName
Core.FieldName String
"inlineShapeOrRef")

data InlineShapeAtom_Sequence2 = 
  InlineShapeAtom_Sequence2 {
    InlineShapeAtom_Sequence2 -> InlineShapeOrRef
inlineShapeAtom_Sequence2InlineShapeOrRef :: InlineShapeOrRef,
    InlineShapeAtom_Sequence2 -> Maybe NodeConstraint
inlineShapeAtom_Sequence2NodeConstraint :: (Maybe NodeConstraint)}
  deriving (InlineShapeAtom_Sequence2 -> InlineShapeAtom_Sequence2 -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: InlineShapeAtom_Sequence2 -> InlineShapeAtom_Sequence2 -> Bool
$c/= :: InlineShapeAtom_Sequence2 -> InlineShapeAtom_Sequence2 -> Bool
== :: InlineShapeAtom_Sequence2 -> InlineShapeAtom_Sequence2 -> Bool
$c== :: InlineShapeAtom_Sequence2 -> InlineShapeAtom_Sequence2 -> Bool
Eq, Eq InlineShapeAtom_Sequence2
InlineShapeAtom_Sequence2 -> InlineShapeAtom_Sequence2 -> Bool
InlineShapeAtom_Sequence2 -> InlineShapeAtom_Sequence2 -> Ordering
InlineShapeAtom_Sequence2
-> InlineShapeAtom_Sequence2 -> InlineShapeAtom_Sequence2
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
min :: InlineShapeAtom_Sequence2
-> InlineShapeAtom_Sequence2 -> InlineShapeAtom_Sequence2
$cmin :: InlineShapeAtom_Sequence2
-> InlineShapeAtom_Sequence2 -> InlineShapeAtom_Sequence2
max :: InlineShapeAtom_Sequence2
-> InlineShapeAtom_Sequence2 -> InlineShapeAtom_Sequence2
$cmax :: InlineShapeAtom_Sequence2
-> InlineShapeAtom_Sequence2 -> InlineShapeAtom_Sequence2
>= :: InlineShapeAtom_Sequence2 -> InlineShapeAtom_Sequence2 -> Bool
$c>= :: InlineShapeAtom_Sequence2 -> InlineShapeAtom_Sequence2 -> Bool
> :: InlineShapeAtom_Sequence2 -> InlineShapeAtom_Sequence2 -> Bool
$c> :: InlineShapeAtom_Sequence2 -> InlineShapeAtom_Sequence2 -> Bool
<= :: InlineShapeAtom_Sequence2 -> InlineShapeAtom_Sequence2 -> Bool
$c<= :: InlineShapeAtom_Sequence2 -> InlineShapeAtom_Sequence2 -> Bool
< :: InlineShapeAtom_Sequence2 -> InlineShapeAtom_Sequence2 -> Bool
$c< :: InlineShapeAtom_Sequence2 -> InlineShapeAtom_Sequence2 -> Bool
compare :: InlineShapeAtom_Sequence2 -> InlineShapeAtom_Sequence2 -> Ordering
$ccompare :: InlineShapeAtom_Sequence2 -> InlineShapeAtom_Sequence2 -> Ordering
Ord, ReadPrec [InlineShapeAtom_Sequence2]
ReadPrec InlineShapeAtom_Sequence2
Int -> ReadS InlineShapeAtom_Sequence2
ReadS [InlineShapeAtom_Sequence2]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [InlineShapeAtom_Sequence2]
$creadListPrec :: ReadPrec [InlineShapeAtom_Sequence2]
readPrec :: ReadPrec InlineShapeAtom_Sequence2
$creadPrec :: ReadPrec InlineShapeAtom_Sequence2
readList :: ReadS [InlineShapeAtom_Sequence2]
$creadList :: ReadS [InlineShapeAtom_Sequence2]
readsPrec :: Int -> ReadS InlineShapeAtom_Sequence2
$creadsPrec :: Int -> ReadS InlineShapeAtom_Sequence2
Read, Int -> InlineShapeAtom_Sequence2 -> ShowS
[InlineShapeAtom_Sequence2] -> ShowS
InlineShapeAtom_Sequence2 -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [InlineShapeAtom_Sequence2] -> ShowS
$cshowList :: [InlineShapeAtom_Sequence2] -> ShowS
show :: InlineShapeAtom_Sequence2 -> String
$cshow :: InlineShapeAtom_Sequence2 -> String
showsPrec :: Int -> InlineShapeAtom_Sequence2 -> ShowS
$cshowsPrec :: Int -> InlineShapeAtom_Sequence2 -> ShowS
Show)

_InlineShapeAtom_Sequence2 :: Name
_InlineShapeAtom_Sequence2 = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.InlineShapeAtom.Sequence2")

_InlineShapeAtom_Sequence2_inlineShapeOrRef :: FieldName
_InlineShapeAtom_Sequence2_inlineShapeOrRef = (String -> FieldName
Core.FieldName String
"inlineShapeOrRef")

_InlineShapeAtom_Sequence2_nodeConstraint :: FieldName
_InlineShapeAtom_Sequence2_nodeConstraint = (String -> FieldName
Core.FieldName String
"nodeConstraint")

data InlineShapeAtom_Sequence3 = 
  InlineShapeAtom_Sequence3 {
    InlineShapeAtom_Sequence3 -> ShapeExpression
inlineShapeAtom_Sequence3ShapeExpression :: ShapeExpression}
  deriving (InlineShapeAtom_Sequence3 -> InlineShapeAtom_Sequence3 -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: InlineShapeAtom_Sequence3 -> InlineShapeAtom_Sequence3 -> Bool
$c/= :: InlineShapeAtom_Sequence3 -> InlineShapeAtom_Sequence3 -> Bool
== :: InlineShapeAtom_Sequence3 -> InlineShapeAtom_Sequence3 -> Bool
$c== :: InlineShapeAtom_Sequence3 -> InlineShapeAtom_Sequence3 -> Bool
Eq, Eq InlineShapeAtom_Sequence3
InlineShapeAtom_Sequence3 -> InlineShapeAtom_Sequence3 -> Bool
InlineShapeAtom_Sequence3 -> InlineShapeAtom_Sequence3 -> Ordering
InlineShapeAtom_Sequence3
-> InlineShapeAtom_Sequence3 -> InlineShapeAtom_Sequence3
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
min :: InlineShapeAtom_Sequence3
-> InlineShapeAtom_Sequence3 -> InlineShapeAtom_Sequence3
$cmin :: InlineShapeAtom_Sequence3
-> InlineShapeAtom_Sequence3 -> InlineShapeAtom_Sequence3
max :: InlineShapeAtom_Sequence3
-> InlineShapeAtom_Sequence3 -> InlineShapeAtom_Sequence3
$cmax :: InlineShapeAtom_Sequence3
-> InlineShapeAtom_Sequence3 -> InlineShapeAtom_Sequence3
>= :: InlineShapeAtom_Sequence3 -> InlineShapeAtom_Sequence3 -> Bool
$c>= :: InlineShapeAtom_Sequence3 -> InlineShapeAtom_Sequence3 -> Bool
> :: InlineShapeAtom_Sequence3 -> InlineShapeAtom_Sequence3 -> Bool
$c> :: InlineShapeAtom_Sequence3 -> InlineShapeAtom_Sequence3 -> Bool
<= :: InlineShapeAtom_Sequence3 -> InlineShapeAtom_Sequence3 -> Bool
$c<= :: InlineShapeAtom_Sequence3 -> InlineShapeAtom_Sequence3 -> Bool
< :: InlineShapeAtom_Sequence3 -> InlineShapeAtom_Sequence3 -> Bool
$c< :: InlineShapeAtom_Sequence3 -> InlineShapeAtom_Sequence3 -> Bool
compare :: InlineShapeAtom_Sequence3 -> InlineShapeAtom_Sequence3 -> Ordering
$ccompare :: InlineShapeAtom_Sequence3 -> InlineShapeAtom_Sequence3 -> Ordering
Ord, ReadPrec [InlineShapeAtom_Sequence3]
ReadPrec InlineShapeAtom_Sequence3
Int -> ReadS InlineShapeAtom_Sequence3
ReadS [InlineShapeAtom_Sequence3]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [InlineShapeAtom_Sequence3]
$creadListPrec :: ReadPrec [InlineShapeAtom_Sequence3]
readPrec :: ReadPrec InlineShapeAtom_Sequence3
$creadPrec :: ReadPrec InlineShapeAtom_Sequence3
readList :: ReadS [InlineShapeAtom_Sequence3]
$creadList :: ReadS [InlineShapeAtom_Sequence3]
readsPrec :: Int -> ReadS InlineShapeAtom_Sequence3
$creadsPrec :: Int -> ReadS InlineShapeAtom_Sequence3
Read, Int -> InlineShapeAtom_Sequence3 -> ShowS
[InlineShapeAtom_Sequence3] -> ShowS
InlineShapeAtom_Sequence3 -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [InlineShapeAtom_Sequence3] -> ShowS
$cshowList :: [InlineShapeAtom_Sequence3] -> ShowS
show :: InlineShapeAtom_Sequence3 -> String
$cshow :: InlineShapeAtom_Sequence3 -> String
showsPrec :: Int -> InlineShapeAtom_Sequence3 -> ShowS
$cshowsPrec :: Int -> InlineShapeAtom_Sequence3 -> ShowS
Show)

_InlineShapeAtom_Sequence3 :: Name
_InlineShapeAtom_Sequence3 = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.InlineShapeAtom.Sequence3")

_InlineShapeAtom_Sequence3_shapeExpression :: FieldName
_InlineShapeAtom_Sequence3_shapeExpression = (String -> FieldName
Core.FieldName String
"shapeExpression")

data ShapeOrRef = 
  ShapeOrRefShapeDefinition ShapeDefinition |
  ShapeOrRefAtpNameLn AtpNameLn |
  ShapeOrRefAtpNameNs AtpNameNs |
  ShapeOrRefSequence ShapeOrRef_Sequence
  deriving (ShapeOrRef -> ShapeOrRef -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ShapeOrRef -> ShapeOrRef -> Bool
$c/= :: ShapeOrRef -> ShapeOrRef -> Bool
== :: ShapeOrRef -> ShapeOrRef -> Bool
$c== :: ShapeOrRef -> ShapeOrRef -> Bool
Eq, Eq ShapeOrRef
ShapeOrRef -> ShapeOrRef -> Bool
ShapeOrRef -> ShapeOrRef -> Ordering
ShapeOrRef -> ShapeOrRef -> ShapeOrRef
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
min :: ShapeOrRef -> ShapeOrRef -> ShapeOrRef
$cmin :: ShapeOrRef -> ShapeOrRef -> ShapeOrRef
max :: ShapeOrRef -> ShapeOrRef -> ShapeOrRef
$cmax :: ShapeOrRef -> ShapeOrRef -> ShapeOrRef
>= :: ShapeOrRef -> ShapeOrRef -> Bool
$c>= :: ShapeOrRef -> ShapeOrRef -> Bool
> :: ShapeOrRef -> ShapeOrRef -> Bool
$c> :: ShapeOrRef -> ShapeOrRef -> Bool
<= :: ShapeOrRef -> ShapeOrRef -> Bool
$c<= :: ShapeOrRef -> ShapeOrRef -> Bool
< :: ShapeOrRef -> ShapeOrRef -> Bool
$c< :: ShapeOrRef -> ShapeOrRef -> Bool
compare :: ShapeOrRef -> ShapeOrRef -> Ordering
$ccompare :: ShapeOrRef -> ShapeOrRef -> Ordering
Ord, ReadPrec [ShapeOrRef]
ReadPrec ShapeOrRef
Int -> ReadS ShapeOrRef
ReadS [ShapeOrRef]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ShapeOrRef]
$creadListPrec :: ReadPrec [ShapeOrRef]
readPrec :: ReadPrec ShapeOrRef
$creadPrec :: ReadPrec ShapeOrRef
readList :: ReadS [ShapeOrRef]
$creadList :: ReadS [ShapeOrRef]
readsPrec :: Int -> ReadS ShapeOrRef
$creadsPrec :: Int -> ReadS ShapeOrRef
Read, Int -> ShapeOrRef -> ShowS
[ShapeOrRef] -> ShowS
ShapeOrRef -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ShapeOrRef] -> ShowS
$cshowList :: [ShapeOrRef] -> ShowS
show :: ShapeOrRef -> String
$cshow :: ShapeOrRef -> String
showsPrec :: Int -> ShapeOrRef -> ShowS
$cshowsPrec :: Int -> ShapeOrRef -> ShowS
Show)

_ShapeOrRef :: Name
_ShapeOrRef = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.ShapeOrRef")

_ShapeOrRef_shapeDefinition :: FieldName
_ShapeOrRef_shapeDefinition = (String -> FieldName
Core.FieldName String
"shapeDefinition")

_ShapeOrRef_atpNameLn :: FieldName
_ShapeOrRef_atpNameLn = (String -> FieldName
Core.FieldName String
"atpNameLn")

_ShapeOrRef_atpNameNs :: FieldName
_ShapeOrRef_atpNameNs = (String -> FieldName
Core.FieldName String
"atpNameNs")

_ShapeOrRef_sequence :: FieldName
_ShapeOrRef_sequence = (String -> FieldName
Core.FieldName String
"sequence")

data ShapeOrRef_Sequence = 
  ShapeOrRef_Sequence {
    ShapeOrRef_Sequence -> ShapeExprLabel
shapeOrRef_SequenceShapeExprLabel :: ShapeExprLabel}
  deriving (ShapeOrRef_Sequence -> ShapeOrRef_Sequence -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ShapeOrRef_Sequence -> ShapeOrRef_Sequence -> Bool
$c/= :: ShapeOrRef_Sequence -> ShapeOrRef_Sequence -> Bool
== :: ShapeOrRef_Sequence -> ShapeOrRef_Sequence -> Bool
$c== :: ShapeOrRef_Sequence -> ShapeOrRef_Sequence -> Bool
Eq, Eq ShapeOrRef_Sequence
ShapeOrRef_Sequence -> ShapeOrRef_Sequence -> Bool
ShapeOrRef_Sequence -> ShapeOrRef_Sequence -> Ordering
ShapeOrRef_Sequence -> ShapeOrRef_Sequence -> ShapeOrRef_Sequence
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
min :: ShapeOrRef_Sequence -> ShapeOrRef_Sequence -> ShapeOrRef_Sequence
$cmin :: ShapeOrRef_Sequence -> ShapeOrRef_Sequence -> ShapeOrRef_Sequence
max :: ShapeOrRef_Sequence -> ShapeOrRef_Sequence -> ShapeOrRef_Sequence
$cmax :: ShapeOrRef_Sequence -> ShapeOrRef_Sequence -> ShapeOrRef_Sequence
>= :: ShapeOrRef_Sequence -> ShapeOrRef_Sequence -> Bool
$c>= :: ShapeOrRef_Sequence -> ShapeOrRef_Sequence -> Bool
> :: ShapeOrRef_Sequence -> ShapeOrRef_Sequence -> Bool
$c> :: ShapeOrRef_Sequence -> ShapeOrRef_Sequence -> Bool
<= :: ShapeOrRef_Sequence -> ShapeOrRef_Sequence -> Bool
$c<= :: ShapeOrRef_Sequence -> ShapeOrRef_Sequence -> Bool
< :: ShapeOrRef_Sequence -> ShapeOrRef_Sequence -> Bool
$c< :: ShapeOrRef_Sequence -> ShapeOrRef_Sequence -> Bool
compare :: ShapeOrRef_Sequence -> ShapeOrRef_Sequence -> Ordering
$ccompare :: ShapeOrRef_Sequence -> ShapeOrRef_Sequence -> Ordering
Ord, ReadPrec [ShapeOrRef_Sequence]
ReadPrec ShapeOrRef_Sequence
Int -> ReadS ShapeOrRef_Sequence
ReadS [ShapeOrRef_Sequence]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ShapeOrRef_Sequence]
$creadListPrec :: ReadPrec [ShapeOrRef_Sequence]
readPrec :: ReadPrec ShapeOrRef_Sequence
$creadPrec :: ReadPrec ShapeOrRef_Sequence
readList :: ReadS [ShapeOrRef_Sequence]
$creadList :: ReadS [ShapeOrRef_Sequence]
readsPrec :: Int -> ReadS ShapeOrRef_Sequence
$creadsPrec :: Int -> ReadS ShapeOrRef_Sequence
Read, Int -> ShapeOrRef_Sequence -> ShowS
[ShapeOrRef_Sequence] -> ShowS
ShapeOrRef_Sequence -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ShapeOrRef_Sequence] -> ShowS
$cshowList :: [ShapeOrRef_Sequence] -> ShowS
show :: ShapeOrRef_Sequence -> String
$cshow :: ShapeOrRef_Sequence -> String
showsPrec :: Int -> ShapeOrRef_Sequence -> ShowS
$cshowsPrec :: Int -> ShapeOrRef_Sequence -> ShowS
Show)

_ShapeOrRef_Sequence :: Name
_ShapeOrRef_Sequence = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.ShapeOrRef.Sequence")

_ShapeOrRef_Sequence_shapeExprLabel :: FieldName
_ShapeOrRef_Sequence_shapeExprLabel = (String -> FieldName
Core.FieldName String
"shapeExprLabel")

data InlineShapeOrRef = 
  InlineShapeOrRefInlineShapeDefinition InlineShapeDefinition |
  InlineShapeOrRefAtpNameLn AtpNameLn |
  InlineShapeOrRefAtpNameNs AtpNameNs |
  InlineShapeOrRefSequence InlineShapeOrRef_Sequence
  deriving (InlineShapeOrRef -> InlineShapeOrRef -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: InlineShapeOrRef -> InlineShapeOrRef -> Bool
$c/= :: InlineShapeOrRef -> InlineShapeOrRef -> Bool
== :: InlineShapeOrRef -> InlineShapeOrRef -> Bool
$c== :: InlineShapeOrRef -> InlineShapeOrRef -> Bool
Eq, Eq InlineShapeOrRef
InlineShapeOrRef -> InlineShapeOrRef -> Bool
InlineShapeOrRef -> InlineShapeOrRef -> Ordering
InlineShapeOrRef -> InlineShapeOrRef -> InlineShapeOrRef
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
min :: InlineShapeOrRef -> InlineShapeOrRef -> InlineShapeOrRef
$cmin :: InlineShapeOrRef -> InlineShapeOrRef -> InlineShapeOrRef
max :: InlineShapeOrRef -> InlineShapeOrRef -> InlineShapeOrRef
$cmax :: InlineShapeOrRef -> InlineShapeOrRef -> InlineShapeOrRef
>= :: InlineShapeOrRef -> InlineShapeOrRef -> Bool
$c>= :: InlineShapeOrRef -> InlineShapeOrRef -> Bool
> :: InlineShapeOrRef -> InlineShapeOrRef -> Bool
$c> :: InlineShapeOrRef -> InlineShapeOrRef -> Bool
<= :: InlineShapeOrRef -> InlineShapeOrRef -> Bool
$c<= :: InlineShapeOrRef -> InlineShapeOrRef -> Bool
< :: InlineShapeOrRef -> InlineShapeOrRef -> Bool
$c< :: InlineShapeOrRef -> InlineShapeOrRef -> Bool
compare :: InlineShapeOrRef -> InlineShapeOrRef -> Ordering
$ccompare :: InlineShapeOrRef -> InlineShapeOrRef -> Ordering
Ord, ReadPrec [InlineShapeOrRef]
ReadPrec InlineShapeOrRef
Int -> ReadS InlineShapeOrRef
ReadS [InlineShapeOrRef]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [InlineShapeOrRef]
$creadListPrec :: ReadPrec [InlineShapeOrRef]
readPrec :: ReadPrec InlineShapeOrRef
$creadPrec :: ReadPrec InlineShapeOrRef
readList :: ReadS [InlineShapeOrRef]
$creadList :: ReadS [InlineShapeOrRef]
readsPrec :: Int -> ReadS InlineShapeOrRef
$creadsPrec :: Int -> ReadS InlineShapeOrRef
Read, Int -> InlineShapeOrRef -> ShowS
[InlineShapeOrRef] -> ShowS
InlineShapeOrRef -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [InlineShapeOrRef] -> ShowS
$cshowList :: [InlineShapeOrRef] -> ShowS
show :: InlineShapeOrRef -> String
$cshow :: InlineShapeOrRef -> String
showsPrec :: Int -> InlineShapeOrRef -> ShowS
$cshowsPrec :: Int -> InlineShapeOrRef -> ShowS
Show)

_InlineShapeOrRef :: Name
_InlineShapeOrRef = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.InlineShapeOrRef")

_InlineShapeOrRef_inlineShapeDefinition :: FieldName
_InlineShapeOrRef_inlineShapeDefinition = (String -> FieldName
Core.FieldName String
"inlineShapeDefinition")

_InlineShapeOrRef_atpNameLn :: FieldName
_InlineShapeOrRef_atpNameLn = (String -> FieldName
Core.FieldName String
"atpNameLn")

_InlineShapeOrRef_atpNameNs :: FieldName
_InlineShapeOrRef_atpNameNs = (String -> FieldName
Core.FieldName String
"atpNameNs")

_InlineShapeOrRef_sequence :: FieldName
_InlineShapeOrRef_sequence = (String -> FieldName
Core.FieldName String
"sequence")

data InlineShapeOrRef_Sequence = 
  InlineShapeOrRef_Sequence {
    InlineShapeOrRef_Sequence -> ShapeExprLabel
inlineShapeOrRef_SequenceShapeExprLabel :: ShapeExprLabel}
  deriving (InlineShapeOrRef_Sequence -> InlineShapeOrRef_Sequence -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: InlineShapeOrRef_Sequence -> InlineShapeOrRef_Sequence -> Bool
$c/= :: InlineShapeOrRef_Sequence -> InlineShapeOrRef_Sequence -> Bool
== :: InlineShapeOrRef_Sequence -> InlineShapeOrRef_Sequence -> Bool
$c== :: InlineShapeOrRef_Sequence -> InlineShapeOrRef_Sequence -> Bool
Eq, Eq InlineShapeOrRef_Sequence
InlineShapeOrRef_Sequence -> InlineShapeOrRef_Sequence -> Bool
InlineShapeOrRef_Sequence -> InlineShapeOrRef_Sequence -> Ordering
InlineShapeOrRef_Sequence
-> InlineShapeOrRef_Sequence -> InlineShapeOrRef_Sequence
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
min :: InlineShapeOrRef_Sequence
-> InlineShapeOrRef_Sequence -> InlineShapeOrRef_Sequence
$cmin :: InlineShapeOrRef_Sequence
-> InlineShapeOrRef_Sequence -> InlineShapeOrRef_Sequence
max :: InlineShapeOrRef_Sequence
-> InlineShapeOrRef_Sequence -> InlineShapeOrRef_Sequence
$cmax :: InlineShapeOrRef_Sequence
-> InlineShapeOrRef_Sequence -> InlineShapeOrRef_Sequence
>= :: InlineShapeOrRef_Sequence -> InlineShapeOrRef_Sequence -> Bool
$c>= :: InlineShapeOrRef_Sequence -> InlineShapeOrRef_Sequence -> Bool
> :: InlineShapeOrRef_Sequence -> InlineShapeOrRef_Sequence -> Bool
$c> :: InlineShapeOrRef_Sequence -> InlineShapeOrRef_Sequence -> Bool
<= :: InlineShapeOrRef_Sequence -> InlineShapeOrRef_Sequence -> Bool
$c<= :: InlineShapeOrRef_Sequence -> InlineShapeOrRef_Sequence -> Bool
< :: InlineShapeOrRef_Sequence -> InlineShapeOrRef_Sequence -> Bool
$c< :: InlineShapeOrRef_Sequence -> InlineShapeOrRef_Sequence -> Bool
compare :: InlineShapeOrRef_Sequence -> InlineShapeOrRef_Sequence -> Ordering
$ccompare :: InlineShapeOrRef_Sequence -> InlineShapeOrRef_Sequence -> Ordering
Ord, ReadPrec [InlineShapeOrRef_Sequence]
ReadPrec InlineShapeOrRef_Sequence
Int -> ReadS InlineShapeOrRef_Sequence
ReadS [InlineShapeOrRef_Sequence]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [InlineShapeOrRef_Sequence]
$creadListPrec :: ReadPrec [InlineShapeOrRef_Sequence]
readPrec :: ReadPrec InlineShapeOrRef_Sequence
$creadPrec :: ReadPrec InlineShapeOrRef_Sequence
readList :: ReadS [InlineShapeOrRef_Sequence]
$creadList :: ReadS [InlineShapeOrRef_Sequence]
readsPrec :: Int -> ReadS InlineShapeOrRef_Sequence
$creadsPrec :: Int -> ReadS InlineShapeOrRef_Sequence
Read, Int -> InlineShapeOrRef_Sequence -> ShowS
[InlineShapeOrRef_Sequence] -> ShowS
InlineShapeOrRef_Sequence -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [InlineShapeOrRef_Sequence] -> ShowS
$cshowList :: [InlineShapeOrRef_Sequence] -> ShowS
show :: InlineShapeOrRef_Sequence -> String
$cshow :: InlineShapeOrRef_Sequence -> String
showsPrec :: Int -> InlineShapeOrRef_Sequence -> ShowS
$cshowsPrec :: Int -> InlineShapeOrRef_Sequence -> ShowS
Show)

_InlineShapeOrRef_Sequence :: Name
_InlineShapeOrRef_Sequence = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.InlineShapeOrRef.Sequence")

_InlineShapeOrRef_Sequence_shapeExprLabel :: FieldName
_InlineShapeOrRef_Sequence_shapeExprLabel = (String -> FieldName
Core.FieldName String
"shapeExprLabel")

data NodeConstraint = 
  NodeConstraintSequence NodeConstraint_Sequence |
  NodeConstraintSequence2 NodeConstraint_Sequence2 |
  NodeConstraintSequence3 NodeConstraint_Sequence3 |
  NodeConstraintSequence4 NodeConstraint_Sequence4 |
  NodeConstraintSequence5 NodeConstraint_Sequence5 |
  NodeConstraintListOfXsFacet [XsFacet]
  deriving (NodeConstraint -> NodeConstraint -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NodeConstraint -> NodeConstraint -> Bool
$c/= :: NodeConstraint -> NodeConstraint -> Bool
== :: NodeConstraint -> NodeConstraint -> Bool
$c== :: NodeConstraint -> NodeConstraint -> Bool
Eq, Eq NodeConstraint
NodeConstraint -> NodeConstraint -> Bool
NodeConstraint -> NodeConstraint -> Ordering
NodeConstraint -> NodeConstraint -> NodeConstraint
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
min :: NodeConstraint -> NodeConstraint -> NodeConstraint
$cmin :: NodeConstraint -> NodeConstraint -> NodeConstraint
max :: NodeConstraint -> NodeConstraint -> NodeConstraint
$cmax :: NodeConstraint -> NodeConstraint -> NodeConstraint
>= :: NodeConstraint -> NodeConstraint -> Bool
$c>= :: NodeConstraint -> NodeConstraint -> Bool
> :: NodeConstraint -> NodeConstraint -> Bool
$c> :: NodeConstraint -> NodeConstraint -> Bool
<= :: NodeConstraint -> NodeConstraint -> Bool
$c<= :: NodeConstraint -> NodeConstraint -> Bool
< :: NodeConstraint -> NodeConstraint -> Bool
$c< :: NodeConstraint -> NodeConstraint -> Bool
compare :: NodeConstraint -> NodeConstraint -> Ordering
$ccompare :: NodeConstraint -> NodeConstraint -> Ordering
Ord, ReadPrec [NodeConstraint]
ReadPrec NodeConstraint
Int -> ReadS NodeConstraint
ReadS [NodeConstraint]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [NodeConstraint]
$creadListPrec :: ReadPrec [NodeConstraint]
readPrec :: ReadPrec NodeConstraint
$creadPrec :: ReadPrec NodeConstraint
readList :: ReadS [NodeConstraint]
$creadList :: ReadS [NodeConstraint]
readsPrec :: Int -> ReadS NodeConstraint
$creadsPrec :: Int -> ReadS NodeConstraint
Read, Int -> NodeConstraint -> ShowS
[NodeConstraint] -> ShowS
NodeConstraint -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [NodeConstraint] -> ShowS
$cshowList :: [NodeConstraint] -> ShowS
show :: NodeConstraint -> String
$cshow :: NodeConstraint -> String
showsPrec :: Int -> NodeConstraint -> ShowS
$cshowsPrec :: Int -> NodeConstraint -> ShowS
Show)

_NodeConstraint :: Name
_NodeConstraint = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.NodeConstraint")

_NodeConstraint_sequence :: FieldName
_NodeConstraint_sequence = (String -> FieldName
Core.FieldName String
"sequence")

_NodeConstraint_sequence2 :: FieldName
_NodeConstraint_sequence2 = (String -> FieldName
Core.FieldName String
"sequence2")

_NodeConstraint_sequence3 :: FieldName
_NodeConstraint_sequence3 = (String -> FieldName
Core.FieldName String
"sequence3")

_NodeConstraint_sequence4 :: FieldName
_NodeConstraint_sequence4 = (String -> FieldName
Core.FieldName String
"sequence4")

_NodeConstraint_sequence5 :: FieldName
_NodeConstraint_sequence5 = (String -> FieldName
Core.FieldName String
"sequence5")

_NodeConstraint_listOfXsFacet :: FieldName
_NodeConstraint_listOfXsFacet = (String -> FieldName
Core.FieldName String
"listOfXsFacet")

data NodeConstraint_Sequence = 
  NodeConstraint_Sequence {
    NodeConstraint_Sequence -> [XsFacet]
nodeConstraint_SequenceListOfXsFacet :: [XsFacet]}
  deriving (NodeConstraint_Sequence -> NodeConstraint_Sequence -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NodeConstraint_Sequence -> NodeConstraint_Sequence -> Bool
$c/= :: NodeConstraint_Sequence -> NodeConstraint_Sequence -> Bool
== :: NodeConstraint_Sequence -> NodeConstraint_Sequence -> Bool
$c== :: NodeConstraint_Sequence -> NodeConstraint_Sequence -> Bool
Eq, Eq NodeConstraint_Sequence
NodeConstraint_Sequence -> NodeConstraint_Sequence -> Bool
NodeConstraint_Sequence -> NodeConstraint_Sequence -> Ordering
NodeConstraint_Sequence
-> NodeConstraint_Sequence -> NodeConstraint_Sequence
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
min :: NodeConstraint_Sequence
-> NodeConstraint_Sequence -> NodeConstraint_Sequence
$cmin :: NodeConstraint_Sequence
-> NodeConstraint_Sequence -> NodeConstraint_Sequence
max :: NodeConstraint_Sequence
-> NodeConstraint_Sequence -> NodeConstraint_Sequence
$cmax :: NodeConstraint_Sequence
-> NodeConstraint_Sequence -> NodeConstraint_Sequence
>= :: NodeConstraint_Sequence -> NodeConstraint_Sequence -> Bool
$c>= :: NodeConstraint_Sequence -> NodeConstraint_Sequence -> Bool
> :: NodeConstraint_Sequence -> NodeConstraint_Sequence -> Bool
$c> :: NodeConstraint_Sequence -> NodeConstraint_Sequence -> Bool
<= :: NodeConstraint_Sequence -> NodeConstraint_Sequence -> Bool
$c<= :: NodeConstraint_Sequence -> NodeConstraint_Sequence -> Bool
< :: NodeConstraint_Sequence -> NodeConstraint_Sequence -> Bool
$c< :: NodeConstraint_Sequence -> NodeConstraint_Sequence -> Bool
compare :: NodeConstraint_Sequence -> NodeConstraint_Sequence -> Ordering
$ccompare :: NodeConstraint_Sequence -> NodeConstraint_Sequence -> Ordering
Ord, ReadPrec [NodeConstraint_Sequence]
ReadPrec NodeConstraint_Sequence
Int -> ReadS NodeConstraint_Sequence
ReadS [NodeConstraint_Sequence]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [NodeConstraint_Sequence]
$creadListPrec :: ReadPrec [NodeConstraint_Sequence]
readPrec :: ReadPrec NodeConstraint_Sequence
$creadPrec :: ReadPrec NodeConstraint_Sequence
readList :: ReadS [NodeConstraint_Sequence]
$creadList :: ReadS [NodeConstraint_Sequence]
readsPrec :: Int -> ReadS NodeConstraint_Sequence
$creadsPrec :: Int -> ReadS NodeConstraint_Sequence
Read, Int -> NodeConstraint_Sequence -> ShowS
[NodeConstraint_Sequence] -> ShowS
NodeConstraint_Sequence -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [NodeConstraint_Sequence] -> ShowS
$cshowList :: [NodeConstraint_Sequence] -> ShowS
show :: NodeConstraint_Sequence -> String
$cshow :: NodeConstraint_Sequence -> String
showsPrec :: Int -> NodeConstraint_Sequence -> ShowS
$cshowsPrec :: Int -> NodeConstraint_Sequence -> ShowS
Show)

_NodeConstraint_Sequence :: Name
_NodeConstraint_Sequence = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.NodeConstraint.Sequence")

_NodeConstraint_Sequence_listOfXsFacet :: FieldName
_NodeConstraint_Sequence_listOfXsFacet = (String -> FieldName
Core.FieldName String
"listOfXsFacet")

data NodeConstraint_Sequence2 = 
  NodeConstraint_Sequence2 {
    NodeConstraint_Sequence2 -> NonLiteralKind
nodeConstraint_Sequence2NonLiteralKind :: NonLiteralKind,
    NodeConstraint_Sequence2 -> [StringFacet]
nodeConstraint_Sequence2ListOfStringFacet :: [StringFacet]}
  deriving (NodeConstraint_Sequence2 -> NodeConstraint_Sequence2 -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NodeConstraint_Sequence2 -> NodeConstraint_Sequence2 -> Bool
$c/= :: NodeConstraint_Sequence2 -> NodeConstraint_Sequence2 -> Bool
== :: NodeConstraint_Sequence2 -> NodeConstraint_Sequence2 -> Bool
$c== :: NodeConstraint_Sequence2 -> NodeConstraint_Sequence2 -> Bool
Eq, Eq NodeConstraint_Sequence2
NodeConstraint_Sequence2 -> NodeConstraint_Sequence2 -> Bool
NodeConstraint_Sequence2 -> NodeConstraint_Sequence2 -> Ordering
NodeConstraint_Sequence2
-> NodeConstraint_Sequence2 -> NodeConstraint_Sequence2
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
min :: NodeConstraint_Sequence2
-> NodeConstraint_Sequence2 -> NodeConstraint_Sequence2
$cmin :: NodeConstraint_Sequence2
-> NodeConstraint_Sequence2 -> NodeConstraint_Sequence2
max :: NodeConstraint_Sequence2
-> NodeConstraint_Sequence2 -> NodeConstraint_Sequence2
$cmax :: NodeConstraint_Sequence2
-> NodeConstraint_Sequence2 -> NodeConstraint_Sequence2
>= :: NodeConstraint_Sequence2 -> NodeConstraint_Sequence2 -> Bool
$c>= :: NodeConstraint_Sequence2 -> NodeConstraint_Sequence2 -> Bool
> :: NodeConstraint_Sequence2 -> NodeConstraint_Sequence2 -> Bool
$c> :: NodeConstraint_Sequence2 -> NodeConstraint_Sequence2 -> Bool
<= :: NodeConstraint_Sequence2 -> NodeConstraint_Sequence2 -> Bool
$c<= :: NodeConstraint_Sequence2 -> NodeConstraint_Sequence2 -> Bool
< :: NodeConstraint_Sequence2 -> NodeConstraint_Sequence2 -> Bool
$c< :: NodeConstraint_Sequence2 -> NodeConstraint_Sequence2 -> Bool
compare :: NodeConstraint_Sequence2 -> NodeConstraint_Sequence2 -> Ordering
$ccompare :: NodeConstraint_Sequence2 -> NodeConstraint_Sequence2 -> Ordering
Ord, ReadPrec [NodeConstraint_Sequence2]
ReadPrec NodeConstraint_Sequence2
Int -> ReadS NodeConstraint_Sequence2
ReadS [NodeConstraint_Sequence2]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [NodeConstraint_Sequence2]
$creadListPrec :: ReadPrec [NodeConstraint_Sequence2]
readPrec :: ReadPrec NodeConstraint_Sequence2
$creadPrec :: ReadPrec NodeConstraint_Sequence2
readList :: ReadS [NodeConstraint_Sequence2]
$creadList :: ReadS [NodeConstraint_Sequence2]
readsPrec :: Int -> ReadS NodeConstraint_Sequence2
$creadsPrec :: Int -> ReadS NodeConstraint_Sequence2
Read, Int -> NodeConstraint_Sequence2 -> ShowS
[NodeConstraint_Sequence2] -> ShowS
NodeConstraint_Sequence2 -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [NodeConstraint_Sequence2] -> ShowS
$cshowList :: [NodeConstraint_Sequence2] -> ShowS
show :: NodeConstraint_Sequence2 -> String
$cshow :: NodeConstraint_Sequence2 -> String
showsPrec :: Int -> NodeConstraint_Sequence2 -> ShowS
$cshowsPrec :: Int -> NodeConstraint_Sequence2 -> ShowS
Show)

_NodeConstraint_Sequence2 :: Name
_NodeConstraint_Sequence2 = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.NodeConstraint.Sequence2")

_NodeConstraint_Sequence2_nonLiteralKind :: FieldName
_NodeConstraint_Sequence2_nonLiteralKind = (String -> FieldName
Core.FieldName String
"nonLiteralKind")

_NodeConstraint_Sequence2_listOfStringFacet :: FieldName
_NodeConstraint_Sequence2_listOfStringFacet = (String -> FieldName
Core.FieldName String
"listOfStringFacet")

data NodeConstraint_Sequence3 = 
  NodeConstraint_Sequence3 {
    NodeConstraint_Sequence3 -> Datatype
nodeConstraint_Sequence3Datatype :: Datatype,
    NodeConstraint_Sequence3 -> [XsFacet]
nodeConstraint_Sequence3ListOfXsFacet :: [XsFacet]}
  deriving (NodeConstraint_Sequence3 -> NodeConstraint_Sequence3 -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NodeConstraint_Sequence3 -> NodeConstraint_Sequence3 -> Bool
$c/= :: NodeConstraint_Sequence3 -> NodeConstraint_Sequence3 -> Bool
== :: NodeConstraint_Sequence3 -> NodeConstraint_Sequence3 -> Bool
$c== :: NodeConstraint_Sequence3 -> NodeConstraint_Sequence3 -> Bool
Eq, Eq NodeConstraint_Sequence3
NodeConstraint_Sequence3 -> NodeConstraint_Sequence3 -> Bool
NodeConstraint_Sequence3 -> NodeConstraint_Sequence3 -> Ordering
NodeConstraint_Sequence3
-> NodeConstraint_Sequence3 -> NodeConstraint_Sequence3
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
min :: NodeConstraint_Sequence3
-> NodeConstraint_Sequence3 -> NodeConstraint_Sequence3
$cmin :: NodeConstraint_Sequence3
-> NodeConstraint_Sequence3 -> NodeConstraint_Sequence3
max :: NodeConstraint_Sequence3
-> NodeConstraint_Sequence3 -> NodeConstraint_Sequence3
$cmax :: NodeConstraint_Sequence3
-> NodeConstraint_Sequence3 -> NodeConstraint_Sequence3
>= :: NodeConstraint_Sequence3 -> NodeConstraint_Sequence3 -> Bool
$c>= :: NodeConstraint_Sequence3 -> NodeConstraint_Sequence3 -> Bool
> :: NodeConstraint_Sequence3 -> NodeConstraint_Sequence3 -> Bool
$c> :: NodeConstraint_Sequence3 -> NodeConstraint_Sequence3 -> Bool
<= :: NodeConstraint_Sequence3 -> NodeConstraint_Sequence3 -> Bool
$c<= :: NodeConstraint_Sequence3 -> NodeConstraint_Sequence3 -> Bool
< :: NodeConstraint_Sequence3 -> NodeConstraint_Sequence3 -> Bool
$c< :: NodeConstraint_Sequence3 -> NodeConstraint_Sequence3 -> Bool
compare :: NodeConstraint_Sequence3 -> NodeConstraint_Sequence3 -> Ordering
$ccompare :: NodeConstraint_Sequence3 -> NodeConstraint_Sequence3 -> Ordering
Ord, ReadPrec [NodeConstraint_Sequence3]
ReadPrec NodeConstraint_Sequence3
Int -> ReadS NodeConstraint_Sequence3
ReadS [NodeConstraint_Sequence3]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [NodeConstraint_Sequence3]
$creadListPrec :: ReadPrec [NodeConstraint_Sequence3]
readPrec :: ReadPrec NodeConstraint_Sequence3
$creadPrec :: ReadPrec NodeConstraint_Sequence3
readList :: ReadS [NodeConstraint_Sequence3]
$creadList :: ReadS [NodeConstraint_Sequence3]
readsPrec :: Int -> ReadS NodeConstraint_Sequence3
$creadsPrec :: Int -> ReadS NodeConstraint_Sequence3
Read, Int -> NodeConstraint_Sequence3 -> ShowS
[NodeConstraint_Sequence3] -> ShowS
NodeConstraint_Sequence3 -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [NodeConstraint_Sequence3] -> ShowS
$cshowList :: [NodeConstraint_Sequence3] -> ShowS
show :: NodeConstraint_Sequence3 -> String
$cshow :: NodeConstraint_Sequence3 -> String
showsPrec :: Int -> NodeConstraint_Sequence3 -> ShowS
$cshowsPrec :: Int -> NodeConstraint_Sequence3 -> ShowS
Show)

_NodeConstraint_Sequence3 :: Name
_NodeConstraint_Sequence3 = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.NodeConstraint.Sequence3")

_NodeConstraint_Sequence3_datatype :: FieldName
_NodeConstraint_Sequence3_datatype = (String -> FieldName
Core.FieldName String
"datatype")

_NodeConstraint_Sequence3_listOfXsFacet :: FieldName
_NodeConstraint_Sequence3_listOfXsFacet = (String -> FieldName
Core.FieldName String
"listOfXsFacet")

data NodeConstraint_Sequence4 = 
  NodeConstraint_Sequence4 {
    NodeConstraint_Sequence4 -> ValueSet
nodeConstraint_Sequence4ValueSet :: ValueSet,
    NodeConstraint_Sequence4 -> [XsFacet]
nodeConstraint_Sequence4ListOfXsFacet :: [XsFacet]}
  deriving (NodeConstraint_Sequence4 -> NodeConstraint_Sequence4 -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NodeConstraint_Sequence4 -> NodeConstraint_Sequence4 -> Bool
$c/= :: NodeConstraint_Sequence4 -> NodeConstraint_Sequence4 -> Bool
== :: NodeConstraint_Sequence4 -> NodeConstraint_Sequence4 -> Bool
$c== :: NodeConstraint_Sequence4 -> NodeConstraint_Sequence4 -> Bool
Eq, Eq NodeConstraint_Sequence4
NodeConstraint_Sequence4 -> NodeConstraint_Sequence4 -> Bool
NodeConstraint_Sequence4 -> NodeConstraint_Sequence4 -> Ordering
NodeConstraint_Sequence4
-> NodeConstraint_Sequence4 -> NodeConstraint_Sequence4
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
min :: NodeConstraint_Sequence4
-> NodeConstraint_Sequence4 -> NodeConstraint_Sequence4
$cmin :: NodeConstraint_Sequence4
-> NodeConstraint_Sequence4 -> NodeConstraint_Sequence4
max :: NodeConstraint_Sequence4
-> NodeConstraint_Sequence4 -> NodeConstraint_Sequence4
$cmax :: NodeConstraint_Sequence4
-> NodeConstraint_Sequence4 -> NodeConstraint_Sequence4
>= :: NodeConstraint_Sequence4 -> NodeConstraint_Sequence4 -> Bool
$c>= :: NodeConstraint_Sequence4 -> NodeConstraint_Sequence4 -> Bool
> :: NodeConstraint_Sequence4 -> NodeConstraint_Sequence4 -> Bool
$c> :: NodeConstraint_Sequence4 -> NodeConstraint_Sequence4 -> Bool
<= :: NodeConstraint_Sequence4 -> NodeConstraint_Sequence4 -> Bool
$c<= :: NodeConstraint_Sequence4 -> NodeConstraint_Sequence4 -> Bool
< :: NodeConstraint_Sequence4 -> NodeConstraint_Sequence4 -> Bool
$c< :: NodeConstraint_Sequence4 -> NodeConstraint_Sequence4 -> Bool
compare :: NodeConstraint_Sequence4 -> NodeConstraint_Sequence4 -> Ordering
$ccompare :: NodeConstraint_Sequence4 -> NodeConstraint_Sequence4 -> Ordering
Ord, ReadPrec [NodeConstraint_Sequence4]
ReadPrec NodeConstraint_Sequence4
Int -> ReadS NodeConstraint_Sequence4
ReadS [NodeConstraint_Sequence4]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [NodeConstraint_Sequence4]
$creadListPrec :: ReadPrec [NodeConstraint_Sequence4]
readPrec :: ReadPrec NodeConstraint_Sequence4
$creadPrec :: ReadPrec NodeConstraint_Sequence4
readList :: ReadS [NodeConstraint_Sequence4]
$creadList :: ReadS [NodeConstraint_Sequence4]
readsPrec :: Int -> ReadS NodeConstraint_Sequence4
$creadsPrec :: Int -> ReadS NodeConstraint_Sequence4
Read, Int -> NodeConstraint_Sequence4 -> ShowS
[NodeConstraint_Sequence4] -> ShowS
NodeConstraint_Sequence4 -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [NodeConstraint_Sequence4] -> ShowS
$cshowList :: [NodeConstraint_Sequence4] -> ShowS
show :: NodeConstraint_Sequence4 -> String
$cshow :: NodeConstraint_Sequence4 -> String
showsPrec :: Int -> NodeConstraint_Sequence4 -> ShowS
$cshowsPrec :: Int -> NodeConstraint_Sequence4 -> ShowS
Show)

_NodeConstraint_Sequence4 :: Name
_NodeConstraint_Sequence4 = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.NodeConstraint.Sequence4")

_NodeConstraint_Sequence4_valueSet :: FieldName
_NodeConstraint_Sequence4_valueSet = (String -> FieldName
Core.FieldName String
"valueSet")

_NodeConstraint_Sequence4_listOfXsFacet :: FieldName
_NodeConstraint_Sequence4_listOfXsFacet = (String -> FieldName
Core.FieldName String
"listOfXsFacet")

data NodeConstraint_Sequence5 = 
  NodeConstraint_Sequence5 {
    NodeConstraint_Sequence5 -> ValueSet
nodeConstraint_Sequence5ValueSet :: ValueSet,
    NodeConstraint_Sequence5 -> [XsFacet]
nodeConstraint_Sequence5ListOfXsFacet :: [XsFacet]}
  deriving (NodeConstraint_Sequence5 -> NodeConstraint_Sequence5 -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NodeConstraint_Sequence5 -> NodeConstraint_Sequence5 -> Bool
$c/= :: NodeConstraint_Sequence5 -> NodeConstraint_Sequence5 -> Bool
== :: NodeConstraint_Sequence5 -> NodeConstraint_Sequence5 -> Bool
$c== :: NodeConstraint_Sequence5 -> NodeConstraint_Sequence5 -> Bool
Eq, Eq NodeConstraint_Sequence5
NodeConstraint_Sequence5 -> NodeConstraint_Sequence5 -> Bool
NodeConstraint_Sequence5 -> NodeConstraint_Sequence5 -> Ordering
NodeConstraint_Sequence5
-> NodeConstraint_Sequence5 -> NodeConstraint_Sequence5
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
min :: NodeConstraint_Sequence5
-> NodeConstraint_Sequence5 -> NodeConstraint_Sequence5
$cmin :: NodeConstraint_Sequence5
-> NodeConstraint_Sequence5 -> NodeConstraint_Sequence5
max :: NodeConstraint_Sequence5
-> NodeConstraint_Sequence5 -> NodeConstraint_Sequence5
$cmax :: NodeConstraint_Sequence5
-> NodeConstraint_Sequence5 -> NodeConstraint_Sequence5
>= :: NodeConstraint_Sequence5 -> NodeConstraint_Sequence5 -> Bool
$c>= :: NodeConstraint_Sequence5 -> NodeConstraint_Sequence5 -> Bool
> :: NodeConstraint_Sequence5 -> NodeConstraint_Sequence5 -> Bool
$c> :: NodeConstraint_Sequence5 -> NodeConstraint_Sequence5 -> Bool
<= :: NodeConstraint_Sequence5 -> NodeConstraint_Sequence5 -> Bool
$c<= :: NodeConstraint_Sequence5 -> NodeConstraint_Sequence5 -> Bool
< :: NodeConstraint_Sequence5 -> NodeConstraint_Sequence5 -> Bool
$c< :: NodeConstraint_Sequence5 -> NodeConstraint_Sequence5 -> Bool
compare :: NodeConstraint_Sequence5 -> NodeConstraint_Sequence5 -> Ordering
$ccompare :: NodeConstraint_Sequence5 -> NodeConstraint_Sequence5 -> Ordering
Ord, ReadPrec [NodeConstraint_Sequence5]
ReadPrec NodeConstraint_Sequence5
Int -> ReadS NodeConstraint_Sequence5
ReadS [NodeConstraint_Sequence5]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [NodeConstraint_Sequence5]
$creadListPrec :: ReadPrec [NodeConstraint_Sequence5]
readPrec :: ReadPrec NodeConstraint_Sequence5
$creadPrec :: ReadPrec NodeConstraint_Sequence5
readList :: ReadS [NodeConstraint_Sequence5]
$creadList :: ReadS [NodeConstraint_Sequence5]
readsPrec :: Int -> ReadS NodeConstraint_Sequence5
$creadsPrec :: Int -> ReadS NodeConstraint_Sequence5
Read, Int -> NodeConstraint_Sequence5 -> ShowS
[NodeConstraint_Sequence5] -> ShowS
NodeConstraint_Sequence5 -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [NodeConstraint_Sequence5] -> ShowS
$cshowList :: [NodeConstraint_Sequence5] -> ShowS
show :: NodeConstraint_Sequence5 -> String
$cshow :: NodeConstraint_Sequence5 -> String
showsPrec :: Int -> NodeConstraint_Sequence5 -> ShowS
$cshowsPrec :: Int -> NodeConstraint_Sequence5 -> ShowS
Show)

_NodeConstraint_Sequence5 :: Name
_NodeConstraint_Sequence5 = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.NodeConstraint.Sequence5")

_NodeConstraint_Sequence5_valueSet :: FieldName
_NodeConstraint_Sequence5_valueSet = (String -> FieldName
Core.FieldName String
"valueSet")

_NodeConstraint_Sequence5_listOfXsFacet :: FieldName
_NodeConstraint_Sequence5_listOfXsFacet = (String -> FieldName
Core.FieldName String
"listOfXsFacet")

data NonLiteralKind = 
  NonLiteralKindIRI  |
  NonLiteralKindBNODE  |
  NonLiteralKindNONLITERAL 
  deriving (NonLiteralKind -> NonLiteralKind -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NonLiteralKind -> NonLiteralKind -> Bool
$c/= :: NonLiteralKind -> NonLiteralKind -> Bool
== :: NonLiteralKind -> NonLiteralKind -> Bool
$c== :: NonLiteralKind -> NonLiteralKind -> Bool
Eq, Eq NonLiteralKind
NonLiteralKind -> NonLiteralKind -> Bool
NonLiteralKind -> NonLiteralKind -> Ordering
NonLiteralKind -> NonLiteralKind -> NonLiteralKind
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
min :: NonLiteralKind -> NonLiteralKind -> NonLiteralKind
$cmin :: NonLiteralKind -> NonLiteralKind -> NonLiteralKind
max :: NonLiteralKind -> NonLiteralKind -> NonLiteralKind
$cmax :: NonLiteralKind -> NonLiteralKind -> NonLiteralKind
>= :: NonLiteralKind -> NonLiteralKind -> Bool
$c>= :: NonLiteralKind -> NonLiteralKind -> Bool
> :: NonLiteralKind -> NonLiteralKind -> Bool
$c> :: NonLiteralKind -> NonLiteralKind -> Bool
<= :: NonLiteralKind -> NonLiteralKind -> Bool
$c<= :: NonLiteralKind -> NonLiteralKind -> Bool
< :: NonLiteralKind -> NonLiteralKind -> Bool
$c< :: NonLiteralKind -> NonLiteralKind -> Bool
compare :: NonLiteralKind -> NonLiteralKind -> Ordering
$ccompare :: NonLiteralKind -> NonLiteralKind -> Ordering
Ord, ReadPrec [NonLiteralKind]
ReadPrec NonLiteralKind
Int -> ReadS NonLiteralKind
ReadS [NonLiteralKind]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [NonLiteralKind]
$creadListPrec :: ReadPrec [NonLiteralKind]
readPrec :: ReadPrec NonLiteralKind
$creadPrec :: ReadPrec NonLiteralKind
readList :: ReadS [NonLiteralKind]
$creadList :: ReadS [NonLiteralKind]
readsPrec :: Int -> ReadS NonLiteralKind
$creadsPrec :: Int -> ReadS NonLiteralKind
Read, Int -> NonLiteralKind -> ShowS
[NonLiteralKind] -> ShowS
NonLiteralKind -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [NonLiteralKind] -> ShowS
$cshowList :: [NonLiteralKind] -> ShowS
show :: NonLiteralKind -> String
$cshow :: NonLiteralKind -> String
showsPrec :: Int -> NonLiteralKind -> ShowS
$cshowsPrec :: Int -> NonLiteralKind -> ShowS
Show)

_NonLiteralKind :: Name
_NonLiteralKind = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.NonLiteralKind")

_NonLiteralKind_iRI :: FieldName
_NonLiteralKind_iRI = (String -> FieldName
Core.FieldName String
"iRI")

_NonLiteralKind_bNODE :: FieldName
_NonLiteralKind_bNODE = (String -> FieldName
Core.FieldName String
"bNODE")

_NonLiteralKind_nONLITERAL :: FieldName
_NonLiteralKind_nONLITERAL = (String -> FieldName
Core.FieldName String
"nONLITERAL")

data XsFacet = 
  XsFacetStringFacet StringFacet |
  XsFacetNumericFacet NumericFacet
  deriving (XsFacet -> XsFacet -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: XsFacet -> XsFacet -> Bool
$c/= :: XsFacet -> XsFacet -> Bool
== :: XsFacet -> XsFacet -> Bool
$c== :: XsFacet -> XsFacet -> Bool
Eq, Eq XsFacet
XsFacet -> XsFacet -> Bool
XsFacet -> XsFacet -> Ordering
XsFacet -> XsFacet -> XsFacet
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
min :: XsFacet -> XsFacet -> XsFacet
$cmin :: XsFacet -> XsFacet -> XsFacet
max :: XsFacet -> XsFacet -> XsFacet
$cmax :: XsFacet -> XsFacet -> XsFacet
>= :: XsFacet -> XsFacet -> Bool
$c>= :: XsFacet -> XsFacet -> Bool
> :: XsFacet -> XsFacet -> Bool
$c> :: XsFacet -> XsFacet -> Bool
<= :: XsFacet -> XsFacet -> Bool
$c<= :: XsFacet -> XsFacet -> Bool
< :: XsFacet -> XsFacet -> Bool
$c< :: XsFacet -> XsFacet -> Bool
compare :: XsFacet -> XsFacet -> Ordering
$ccompare :: XsFacet -> XsFacet -> Ordering
Ord, ReadPrec [XsFacet]
ReadPrec XsFacet
Int -> ReadS XsFacet
ReadS [XsFacet]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [XsFacet]
$creadListPrec :: ReadPrec [XsFacet]
readPrec :: ReadPrec XsFacet
$creadPrec :: ReadPrec XsFacet
readList :: ReadS [XsFacet]
$creadList :: ReadS [XsFacet]
readsPrec :: Int -> ReadS XsFacet
$creadsPrec :: Int -> ReadS XsFacet
Read, Int -> XsFacet -> ShowS
[XsFacet] -> ShowS
XsFacet -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [XsFacet] -> ShowS
$cshowList :: [XsFacet] -> ShowS
show :: XsFacet -> String
$cshow :: XsFacet -> String
showsPrec :: Int -> XsFacet -> ShowS
$cshowsPrec :: Int -> XsFacet -> ShowS
Show)

_XsFacet :: Name
_XsFacet = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.XsFacet")

_XsFacet_stringFacet :: FieldName
_XsFacet_stringFacet = (String -> FieldName
Core.FieldName String
"stringFacet")

_XsFacet_numericFacet :: FieldName
_XsFacet_numericFacet = (String -> FieldName
Core.FieldName String
"numericFacet")

data StringFacet = 
  StringFacetSequence StringFacet_Sequence |
  StringFacetRegexp Regexp
  deriving (StringFacet -> StringFacet -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StringFacet -> StringFacet -> Bool
$c/= :: StringFacet -> StringFacet -> Bool
== :: StringFacet -> StringFacet -> Bool
$c== :: StringFacet -> StringFacet -> Bool
Eq, Eq StringFacet
StringFacet -> StringFacet -> Bool
StringFacet -> StringFacet -> Ordering
StringFacet -> StringFacet -> StringFacet
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
min :: StringFacet -> StringFacet -> StringFacet
$cmin :: StringFacet -> StringFacet -> StringFacet
max :: StringFacet -> StringFacet -> StringFacet
$cmax :: StringFacet -> StringFacet -> StringFacet
>= :: StringFacet -> StringFacet -> Bool
$c>= :: StringFacet -> StringFacet -> Bool
> :: StringFacet -> StringFacet -> Bool
$c> :: StringFacet -> StringFacet -> Bool
<= :: StringFacet -> StringFacet -> Bool
$c<= :: StringFacet -> StringFacet -> Bool
< :: StringFacet -> StringFacet -> Bool
$c< :: StringFacet -> StringFacet -> Bool
compare :: StringFacet -> StringFacet -> Ordering
$ccompare :: StringFacet -> StringFacet -> Ordering
Ord, ReadPrec [StringFacet]
ReadPrec StringFacet
Int -> ReadS StringFacet
ReadS [StringFacet]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [StringFacet]
$creadListPrec :: ReadPrec [StringFacet]
readPrec :: ReadPrec StringFacet
$creadPrec :: ReadPrec StringFacet
readList :: ReadS [StringFacet]
$creadList :: ReadS [StringFacet]
readsPrec :: Int -> ReadS StringFacet
$creadsPrec :: Int -> ReadS StringFacet
Read, Int -> StringFacet -> ShowS
[StringFacet] -> ShowS
StringFacet -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StringFacet] -> ShowS
$cshowList :: [StringFacet] -> ShowS
show :: StringFacet -> String
$cshow :: StringFacet -> String
showsPrec :: Int -> StringFacet -> ShowS
$cshowsPrec :: Int -> StringFacet -> ShowS
Show)

_StringFacet :: Name
_StringFacet = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.StringFacet")

_StringFacet_sequence :: FieldName
_StringFacet_sequence = (String -> FieldName
Core.FieldName String
"sequence")

_StringFacet_regexp :: FieldName
_StringFacet_regexp = (String -> FieldName
Core.FieldName String
"regexp")

data StringFacet_Sequence = 
  StringFacet_Sequence {
    StringFacet_Sequence -> StringLength
stringFacet_SequenceStringLength :: StringLength,
    StringFacet_Sequence -> Integer_
stringFacet_SequenceInteger :: Integer_}
  deriving (StringFacet_Sequence -> StringFacet_Sequence -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StringFacet_Sequence -> StringFacet_Sequence -> Bool
$c/= :: StringFacet_Sequence -> StringFacet_Sequence -> Bool
== :: StringFacet_Sequence -> StringFacet_Sequence -> Bool
$c== :: StringFacet_Sequence -> StringFacet_Sequence -> Bool
Eq, Eq StringFacet_Sequence
StringFacet_Sequence -> StringFacet_Sequence -> Bool
StringFacet_Sequence -> StringFacet_Sequence -> Ordering
StringFacet_Sequence
-> StringFacet_Sequence -> StringFacet_Sequence
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
min :: StringFacet_Sequence
-> StringFacet_Sequence -> StringFacet_Sequence
$cmin :: StringFacet_Sequence
-> StringFacet_Sequence -> StringFacet_Sequence
max :: StringFacet_Sequence
-> StringFacet_Sequence -> StringFacet_Sequence
$cmax :: StringFacet_Sequence
-> StringFacet_Sequence -> StringFacet_Sequence
>= :: StringFacet_Sequence -> StringFacet_Sequence -> Bool
$c>= :: StringFacet_Sequence -> StringFacet_Sequence -> Bool
> :: StringFacet_Sequence -> StringFacet_Sequence -> Bool
$c> :: StringFacet_Sequence -> StringFacet_Sequence -> Bool
<= :: StringFacet_Sequence -> StringFacet_Sequence -> Bool
$c<= :: StringFacet_Sequence -> StringFacet_Sequence -> Bool
< :: StringFacet_Sequence -> StringFacet_Sequence -> Bool
$c< :: StringFacet_Sequence -> StringFacet_Sequence -> Bool
compare :: StringFacet_Sequence -> StringFacet_Sequence -> Ordering
$ccompare :: StringFacet_Sequence -> StringFacet_Sequence -> Ordering
Ord, ReadPrec [StringFacet_Sequence]
ReadPrec StringFacet_Sequence
Int -> ReadS StringFacet_Sequence
ReadS [StringFacet_Sequence]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [StringFacet_Sequence]
$creadListPrec :: ReadPrec [StringFacet_Sequence]
readPrec :: ReadPrec StringFacet_Sequence
$creadPrec :: ReadPrec StringFacet_Sequence
readList :: ReadS [StringFacet_Sequence]
$creadList :: ReadS [StringFacet_Sequence]
readsPrec :: Int -> ReadS StringFacet_Sequence
$creadsPrec :: Int -> ReadS StringFacet_Sequence
Read, Int -> StringFacet_Sequence -> ShowS
[StringFacet_Sequence] -> ShowS
StringFacet_Sequence -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StringFacet_Sequence] -> ShowS
$cshowList :: [StringFacet_Sequence] -> ShowS
show :: StringFacet_Sequence -> String
$cshow :: StringFacet_Sequence -> String
showsPrec :: Int -> StringFacet_Sequence -> ShowS
$cshowsPrec :: Int -> StringFacet_Sequence -> ShowS
Show)

_StringFacet_Sequence :: Name
_StringFacet_Sequence = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.StringFacet.Sequence")

_StringFacet_Sequence_stringLength :: FieldName
_StringFacet_Sequence_stringLength = (String -> FieldName
Core.FieldName String
"stringLength")

_StringFacet_Sequence_integer :: FieldName
_StringFacet_Sequence_integer = (String -> FieldName
Core.FieldName String
"integer")

data StringLength = 
  StringLengthLENGTH  |
  StringLengthMINLENGTH  |
  StringLengthMAXLENGTH 
  deriving (StringLength -> StringLength -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StringLength -> StringLength -> Bool
$c/= :: StringLength -> StringLength -> Bool
== :: StringLength -> StringLength -> Bool
$c== :: StringLength -> StringLength -> Bool
Eq, Eq StringLength
StringLength -> StringLength -> Bool
StringLength -> StringLength -> Ordering
StringLength -> StringLength -> StringLength
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
min :: StringLength -> StringLength -> StringLength
$cmin :: StringLength -> StringLength -> StringLength
max :: StringLength -> StringLength -> StringLength
$cmax :: StringLength -> StringLength -> StringLength
>= :: StringLength -> StringLength -> Bool
$c>= :: StringLength -> StringLength -> Bool
> :: StringLength -> StringLength -> Bool
$c> :: StringLength -> StringLength -> Bool
<= :: StringLength -> StringLength -> Bool
$c<= :: StringLength -> StringLength -> Bool
< :: StringLength -> StringLength -> Bool
$c< :: StringLength -> StringLength -> Bool
compare :: StringLength -> StringLength -> Ordering
$ccompare :: StringLength -> StringLength -> Ordering
Ord, ReadPrec [StringLength]
ReadPrec StringLength
Int -> ReadS StringLength
ReadS [StringLength]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [StringLength]
$creadListPrec :: ReadPrec [StringLength]
readPrec :: ReadPrec StringLength
$creadPrec :: ReadPrec StringLength
readList :: ReadS [StringLength]
$creadList :: ReadS [StringLength]
readsPrec :: Int -> ReadS StringLength
$creadsPrec :: Int -> ReadS StringLength
Read, Int -> StringLength -> ShowS
[StringLength] -> ShowS
StringLength -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StringLength] -> ShowS
$cshowList :: [StringLength] -> ShowS
show :: StringLength -> String
$cshow :: StringLength -> String
showsPrec :: Int -> StringLength -> ShowS
$cshowsPrec :: Int -> StringLength -> ShowS
Show)

_StringLength :: Name
_StringLength = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.StringLength")

_StringLength_lENGTH :: FieldName
_StringLength_lENGTH = (String -> FieldName
Core.FieldName String
"lENGTH")

_StringLength_mINLENGTH :: FieldName
_StringLength_mINLENGTH = (String -> FieldName
Core.FieldName String
"mINLENGTH")

_StringLength_mAXLENGTH :: FieldName
_StringLength_mAXLENGTH = (String -> FieldName
Core.FieldName String
"mAXLENGTH")

data NumericFacet = 
  NumericFacetSequence NumericFacet_Sequence |
  NumericFacetSequence2 NumericFacet_Sequence2
  deriving (NumericFacet -> NumericFacet -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NumericFacet -> NumericFacet -> Bool
$c/= :: NumericFacet -> NumericFacet -> Bool
== :: NumericFacet -> NumericFacet -> Bool
$c== :: NumericFacet -> NumericFacet -> Bool
Eq, Eq NumericFacet
NumericFacet -> NumericFacet -> Bool
NumericFacet -> NumericFacet -> Ordering
NumericFacet -> NumericFacet -> NumericFacet
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
min :: NumericFacet -> NumericFacet -> NumericFacet
$cmin :: NumericFacet -> NumericFacet -> NumericFacet
max :: NumericFacet -> NumericFacet -> NumericFacet
$cmax :: NumericFacet -> NumericFacet -> NumericFacet
>= :: NumericFacet -> NumericFacet -> Bool
$c>= :: NumericFacet -> NumericFacet -> Bool
> :: NumericFacet -> NumericFacet -> Bool
$c> :: NumericFacet -> NumericFacet -> Bool
<= :: NumericFacet -> NumericFacet -> Bool
$c<= :: NumericFacet -> NumericFacet -> Bool
< :: NumericFacet -> NumericFacet -> Bool
$c< :: NumericFacet -> NumericFacet -> Bool
compare :: NumericFacet -> NumericFacet -> Ordering
$ccompare :: NumericFacet -> NumericFacet -> Ordering
Ord, ReadPrec [NumericFacet]
ReadPrec NumericFacet
Int -> ReadS NumericFacet
ReadS [NumericFacet]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [NumericFacet]
$creadListPrec :: ReadPrec [NumericFacet]
readPrec :: ReadPrec NumericFacet
$creadPrec :: ReadPrec NumericFacet
readList :: ReadS [NumericFacet]
$creadList :: ReadS [NumericFacet]
readsPrec :: Int -> ReadS NumericFacet
$creadsPrec :: Int -> ReadS NumericFacet
Read, Int -> NumericFacet -> ShowS
[NumericFacet] -> ShowS
NumericFacet -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [NumericFacet] -> ShowS
$cshowList :: [NumericFacet] -> ShowS
show :: NumericFacet -> String
$cshow :: NumericFacet -> String
showsPrec :: Int -> NumericFacet -> ShowS
$cshowsPrec :: Int -> NumericFacet -> ShowS
Show)

_NumericFacet :: Name
_NumericFacet = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.NumericFacet")

_NumericFacet_sequence :: FieldName
_NumericFacet_sequence = (String -> FieldName
Core.FieldName String
"sequence")

_NumericFacet_sequence2 :: FieldName
_NumericFacet_sequence2 = (String -> FieldName
Core.FieldName String
"sequence2")

data NumericFacet_Sequence = 
  NumericFacet_Sequence {
    NumericFacet_Sequence -> NumericRange
numericFacet_SequenceNumericRange :: NumericRange,
    NumericFacet_Sequence -> NumericLiteral
numericFacet_SequenceNumericLiteral :: NumericLiteral}
  deriving (NumericFacet_Sequence -> NumericFacet_Sequence -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NumericFacet_Sequence -> NumericFacet_Sequence -> Bool
$c/= :: NumericFacet_Sequence -> NumericFacet_Sequence -> Bool
== :: NumericFacet_Sequence -> NumericFacet_Sequence -> Bool
$c== :: NumericFacet_Sequence -> NumericFacet_Sequence -> Bool
Eq, Eq NumericFacet_Sequence
NumericFacet_Sequence -> NumericFacet_Sequence -> Bool
NumericFacet_Sequence -> NumericFacet_Sequence -> Ordering
NumericFacet_Sequence
-> NumericFacet_Sequence -> NumericFacet_Sequence
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
min :: NumericFacet_Sequence
-> NumericFacet_Sequence -> NumericFacet_Sequence
$cmin :: NumericFacet_Sequence
-> NumericFacet_Sequence -> NumericFacet_Sequence
max :: NumericFacet_Sequence
-> NumericFacet_Sequence -> NumericFacet_Sequence
$cmax :: NumericFacet_Sequence
-> NumericFacet_Sequence -> NumericFacet_Sequence
>= :: NumericFacet_Sequence -> NumericFacet_Sequence -> Bool
$c>= :: NumericFacet_Sequence -> NumericFacet_Sequence -> Bool
> :: NumericFacet_Sequence -> NumericFacet_Sequence -> Bool
$c> :: NumericFacet_Sequence -> NumericFacet_Sequence -> Bool
<= :: NumericFacet_Sequence -> NumericFacet_Sequence -> Bool
$c<= :: NumericFacet_Sequence -> NumericFacet_Sequence -> Bool
< :: NumericFacet_Sequence -> NumericFacet_Sequence -> Bool
$c< :: NumericFacet_Sequence -> NumericFacet_Sequence -> Bool
compare :: NumericFacet_Sequence -> NumericFacet_Sequence -> Ordering
$ccompare :: NumericFacet_Sequence -> NumericFacet_Sequence -> Ordering
Ord, ReadPrec [NumericFacet_Sequence]
ReadPrec NumericFacet_Sequence
Int -> ReadS NumericFacet_Sequence
ReadS [NumericFacet_Sequence]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [NumericFacet_Sequence]
$creadListPrec :: ReadPrec [NumericFacet_Sequence]
readPrec :: ReadPrec NumericFacet_Sequence
$creadPrec :: ReadPrec NumericFacet_Sequence
readList :: ReadS [NumericFacet_Sequence]
$creadList :: ReadS [NumericFacet_Sequence]
readsPrec :: Int -> ReadS NumericFacet_Sequence
$creadsPrec :: Int -> ReadS NumericFacet_Sequence
Read, Int -> NumericFacet_Sequence -> ShowS
[NumericFacet_Sequence] -> ShowS
NumericFacet_Sequence -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [NumericFacet_Sequence] -> ShowS
$cshowList :: [NumericFacet_Sequence] -> ShowS
show :: NumericFacet_Sequence -> String
$cshow :: NumericFacet_Sequence -> String
showsPrec :: Int -> NumericFacet_Sequence -> ShowS
$cshowsPrec :: Int -> NumericFacet_Sequence -> ShowS
Show)

_NumericFacet_Sequence :: Name
_NumericFacet_Sequence = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.NumericFacet.Sequence")

_NumericFacet_Sequence_numericRange :: FieldName
_NumericFacet_Sequence_numericRange = (String -> FieldName
Core.FieldName String
"numericRange")

_NumericFacet_Sequence_numericLiteral :: FieldName
_NumericFacet_Sequence_numericLiteral = (String -> FieldName
Core.FieldName String
"numericLiteral")

data NumericFacet_Sequence2 = 
  NumericFacet_Sequence2 {
    NumericFacet_Sequence2 -> NumericLength
numericFacet_Sequence2NumericLength :: NumericLength,
    NumericFacet_Sequence2 -> Integer_
numericFacet_Sequence2Integer :: Integer_}
  deriving (NumericFacet_Sequence2 -> NumericFacet_Sequence2 -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NumericFacet_Sequence2 -> NumericFacet_Sequence2 -> Bool
$c/= :: NumericFacet_Sequence2 -> NumericFacet_Sequence2 -> Bool
== :: NumericFacet_Sequence2 -> NumericFacet_Sequence2 -> Bool
$c== :: NumericFacet_Sequence2 -> NumericFacet_Sequence2 -> Bool
Eq, Eq NumericFacet_Sequence2
NumericFacet_Sequence2 -> NumericFacet_Sequence2 -> Bool
NumericFacet_Sequence2 -> NumericFacet_Sequence2 -> Ordering
NumericFacet_Sequence2
-> NumericFacet_Sequence2 -> NumericFacet_Sequence2
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
min :: NumericFacet_Sequence2
-> NumericFacet_Sequence2 -> NumericFacet_Sequence2
$cmin :: NumericFacet_Sequence2
-> NumericFacet_Sequence2 -> NumericFacet_Sequence2
max :: NumericFacet_Sequence2
-> NumericFacet_Sequence2 -> NumericFacet_Sequence2
$cmax :: NumericFacet_Sequence2
-> NumericFacet_Sequence2 -> NumericFacet_Sequence2
>= :: NumericFacet_Sequence2 -> NumericFacet_Sequence2 -> Bool
$c>= :: NumericFacet_Sequence2 -> NumericFacet_Sequence2 -> Bool
> :: NumericFacet_Sequence2 -> NumericFacet_Sequence2 -> Bool
$c> :: NumericFacet_Sequence2 -> NumericFacet_Sequence2 -> Bool
<= :: NumericFacet_Sequence2 -> NumericFacet_Sequence2 -> Bool
$c<= :: NumericFacet_Sequence2 -> NumericFacet_Sequence2 -> Bool
< :: NumericFacet_Sequence2 -> NumericFacet_Sequence2 -> Bool
$c< :: NumericFacet_Sequence2 -> NumericFacet_Sequence2 -> Bool
compare :: NumericFacet_Sequence2 -> NumericFacet_Sequence2 -> Ordering
$ccompare :: NumericFacet_Sequence2 -> NumericFacet_Sequence2 -> Ordering
Ord, ReadPrec [NumericFacet_Sequence2]
ReadPrec NumericFacet_Sequence2
Int -> ReadS NumericFacet_Sequence2
ReadS [NumericFacet_Sequence2]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [NumericFacet_Sequence2]
$creadListPrec :: ReadPrec [NumericFacet_Sequence2]
readPrec :: ReadPrec NumericFacet_Sequence2
$creadPrec :: ReadPrec NumericFacet_Sequence2
readList :: ReadS [NumericFacet_Sequence2]
$creadList :: ReadS [NumericFacet_Sequence2]
readsPrec :: Int -> ReadS NumericFacet_Sequence2
$creadsPrec :: Int -> ReadS NumericFacet_Sequence2
Read, Int -> NumericFacet_Sequence2 -> ShowS
[NumericFacet_Sequence2] -> ShowS
NumericFacet_Sequence2 -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [NumericFacet_Sequence2] -> ShowS
$cshowList :: [NumericFacet_Sequence2] -> ShowS
show :: NumericFacet_Sequence2 -> String
$cshow :: NumericFacet_Sequence2 -> String
showsPrec :: Int -> NumericFacet_Sequence2 -> ShowS
$cshowsPrec :: Int -> NumericFacet_Sequence2 -> ShowS
Show)

_NumericFacet_Sequence2 :: Name
_NumericFacet_Sequence2 = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.NumericFacet.Sequence2")

_NumericFacet_Sequence2_numericLength :: FieldName
_NumericFacet_Sequence2_numericLength = (String -> FieldName
Core.FieldName String
"numericLength")

_NumericFacet_Sequence2_integer :: FieldName
_NumericFacet_Sequence2_integer = (String -> FieldName
Core.FieldName String
"integer")

data NumericRange = 
  NumericRangeMININCLUSIVE  |
  NumericRangeMINEXCLUSIVE  |
  NumericRangeMAXINCLUSIVE  |
  NumericRangeMAXEXCLUSIVE 
  deriving (NumericRange -> NumericRange -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NumericRange -> NumericRange -> Bool
$c/= :: NumericRange -> NumericRange -> Bool
== :: NumericRange -> NumericRange -> Bool
$c== :: NumericRange -> NumericRange -> Bool
Eq, Eq NumericRange
NumericRange -> NumericRange -> Bool
NumericRange -> NumericRange -> Ordering
NumericRange -> NumericRange -> NumericRange
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
min :: NumericRange -> NumericRange -> NumericRange
$cmin :: NumericRange -> NumericRange -> NumericRange
max :: NumericRange -> NumericRange -> NumericRange
$cmax :: NumericRange -> NumericRange -> NumericRange
>= :: NumericRange -> NumericRange -> Bool
$c>= :: NumericRange -> NumericRange -> Bool
> :: NumericRange -> NumericRange -> Bool
$c> :: NumericRange -> NumericRange -> Bool
<= :: NumericRange -> NumericRange -> Bool
$c<= :: NumericRange -> NumericRange -> Bool
< :: NumericRange -> NumericRange -> Bool
$c< :: NumericRange -> NumericRange -> Bool
compare :: NumericRange -> NumericRange -> Ordering
$ccompare :: NumericRange -> NumericRange -> Ordering
Ord, ReadPrec [NumericRange]
ReadPrec NumericRange
Int -> ReadS NumericRange
ReadS [NumericRange]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [NumericRange]
$creadListPrec :: ReadPrec [NumericRange]
readPrec :: ReadPrec NumericRange
$creadPrec :: ReadPrec NumericRange
readList :: ReadS [NumericRange]
$creadList :: ReadS [NumericRange]
readsPrec :: Int -> ReadS NumericRange
$creadsPrec :: Int -> ReadS NumericRange
Read, Int -> NumericRange -> ShowS
[NumericRange] -> ShowS
NumericRange -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [NumericRange] -> ShowS
$cshowList :: [NumericRange] -> ShowS
show :: NumericRange -> String
$cshow :: NumericRange -> String
showsPrec :: Int -> NumericRange -> ShowS
$cshowsPrec :: Int -> NumericRange -> ShowS
Show)

_NumericRange :: Name
_NumericRange = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.NumericRange")

_NumericRange_mININCLUSIVE :: FieldName
_NumericRange_mININCLUSIVE = (String -> FieldName
Core.FieldName String
"mININCLUSIVE")

_NumericRange_mINEXCLUSIVE :: FieldName
_NumericRange_mINEXCLUSIVE = (String -> FieldName
Core.FieldName String
"mINEXCLUSIVE")

_NumericRange_mAXINCLUSIVE :: FieldName
_NumericRange_mAXINCLUSIVE = (String -> FieldName
Core.FieldName String
"mAXINCLUSIVE")

_NumericRange_mAXEXCLUSIVE :: FieldName
_NumericRange_mAXEXCLUSIVE = (String -> FieldName
Core.FieldName String
"mAXEXCLUSIVE")

data NumericLength = 
  NumericLengthTOTALDIGITS  |
  NumericLengthFRACTIONDIGITS 
  deriving (NumericLength -> NumericLength -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NumericLength -> NumericLength -> Bool
$c/= :: NumericLength -> NumericLength -> Bool
== :: NumericLength -> NumericLength -> Bool
$c== :: NumericLength -> NumericLength -> Bool
Eq, Eq NumericLength
NumericLength -> NumericLength -> Bool
NumericLength -> NumericLength -> Ordering
NumericLength -> NumericLength -> NumericLength
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
min :: NumericLength -> NumericLength -> NumericLength
$cmin :: NumericLength -> NumericLength -> NumericLength
max :: NumericLength -> NumericLength -> NumericLength
$cmax :: NumericLength -> NumericLength -> NumericLength
>= :: NumericLength -> NumericLength -> Bool
$c>= :: NumericLength -> NumericLength -> Bool
> :: NumericLength -> NumericLength -> Bool
$c> :: NumericLength -> NumericLength -> Bool
<= :: NumericLength -> NumericLength -> Bool
$c<= :: NumericLength -> NumericLength -> Bool
< :: NumericLength -> NumericLength -> Bool
$c< :: NumericLength -> NumericLength -> Bool
compare :: NumericLength -> NumericLength -> Ordering
$ccompare :: NumericLength -> NumericLength -> Ordering
Ord, ReadPrec [NumericLength]
ReadPrec NumericLength
Int -> ReadS NumericLength
ReadS [NumericLength]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [NumericLength]
$creadListPrec :: ReadPrec [NumericLength]
readPrec :: ReadPrec NumericLength
$creadPrec :: ReadPrec NumericLength
readList :: ReadS [NumericLength]
$creadList :: ReadS [NumericLength]
readsPrec :: Int -> ReadS NumericLength
$creadsPrec :: Int -> ReadS NumericLength
Read, Int -> NumericLength -> ShowS
[NumericLength] -> ShowS
NumericLength -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [NumericLength] -> ShowS
$cshowList :: [NumericLength] -> ShowS
show :: NumericLength -> String
$cshow :: NumericLength -> String
showsPrec :: Int -> NumericLength -> ShowS
$cshowsPrec :: Int -> NumericLength -> ShowS
Show)

_NumericLength :: Name
_NumericLength = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.NumericLength")

_NumericLength_tOTALDIGITS :: FieldName
_NumericLength_tOTALDIGITS = (String -> FieldName
Core.FieldName String
"tOTALDIGITS")

_NumericLength_fRACTIONDIGITS :: FieldName
_NumericLength_fRACTIONDIGITS = (String -> FieldName
Core.FieldName String
"fRACTIONDIGITS")

data ShapeDefinition = 
  ShapeDefinition {
    ShapeDefinition -> [ShapeDefinition_ListOfAlts_Elmt]
shapeDefinitionListOfAlts :: [ShapeDefinition_ListOfAlts_Elmt],
    ShapeDefinition -> Maybe TripleExpression
shapeDefinitionTripleExpression :: (Maybe TripleExpression),
    ShapeDefinition -> [Annotation]
shapeDefinitionListOfAnnotation :: [Annotation],
    ShapeDefinition -> SemanticActions
shapeDefinitionSemanticActions :: SemanticActions}
  deriving (ShapeDefinition -> ShapeDefinition -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ShapeDefinition -> ShapeDefinition -> Bool
$c/= :: ShapeDefinition -> ShapeDefinition -> Bool
== :: ShapeDefinition -> ShapeDefinition -> Bool
$c== :: ShapeDefinition -> ShapeDefinition -> Bool
Eq, Eq ShapeDefinition
ShapeDefinition -> ShapeDefinition -> Bool
ShapeDefinition -> ShapeDefinition -> Ordering
ShapeDefinition -> ShapeDefinition -> ShapeDefinition
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
min :: ShapeDefinition -> ShapeDefinition -> ShapeDefinition
$cmin :: ShapeDefinition -> ShapeDefinition -> ShapeDefinition
max :: ShapeDefinition -> ShapeDefinition -> ShapeDefinition
$cmax :: ShapeDefinition -> ShapeDefinition -> ShapeDefinition
>= :: ShapeDefinition -> ShapeDefinition -> Bool
$c>= :: ShapeDefinition -> ShapeDefinition -> Bool
> :: ShapeDefinition -> ShapeDefinition -> Bool
$c> :: ShapeDefinition -> ShapeDefinition -> Bool
<= :: ShapeDefinition -> ShapeDefinition -> Bool
$c<= :: ShapeDefinition -> ShapeDefinition -> Bool
< :: ShapeDefinition -> ShapeDefinition -> Bool
$c< :: ShapeDefinition -> ShapeDefinition -> Bool
compare :: ShapeDefinition -> ShapeDefinition -> Ordering
$ccompare :: ShapeDefinition -> ShapeDefinition -> Ordering
Ord, ReadPrec [ShapeDefinition]
ReadPrec ShapeDefinition
Int -> ReadS ShapeDefinition
ReadS [ShapeDefinition]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ShapeDefinition]
$creadListPrec :: ReadPrec [ShapeDefinition]
readPrec :: ReadPrec ShapeDefinition
$creadPrec :: ReadPrec ShapeDefinition
readList :: ReadS [ShapeDefinition]
$creadList :: ReadS [ShapeDefinition]
readsPrec :: Int -> ReadS ShapeDefinition
$creadsPrec :: Int -> ReadS ShapeDefinition
Read, Int -> ShapeDefinition -> ShowS
[ShapeDefinition] -> ShowS
ShapeDefinition -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ShapeDefinition] -> ShowS
$cshowList :: [ShapeDefinition] -> ShowS
show :: ShapeDefinition -> String
$cshow :: ShapeDefinition -> String
showsPrec :: Int -> ShapeDefinition -> ShowS
$cshowsPrec :: Int -> ShapeDefinition -> ShowS
Show)

_ShapeDefinition :: Name
_ShapeDefinition = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.ShapeDefinition")

_ShapeDefinition_listOfAlts :: FieldName
_ShapeDefinition_listOfAlts = (String -> FieldName
Core.FieldName String
"listOfAlts")

_ShapeDefinition_tripleExpression :: FieldName
_ShapeDefinition_tripleExpression = (String -> FieldName
Core.FieldName String
"tripleExpression")

_ShapeDefinition_listOfAnnotation :: FieldName
_ShapeDefinition_listOfAnnotation = (String -> FieldName
Core.FieldName String
"listOfAnnotation")

_ShapeDefinition_semanticActions :: FieldName
_ShapeDefinition_semanticActions = (String -> FieldName
Core.FieldName String
"semanticActions")

data ShapeDefinition_ListOfAlts_Elmt = 
  ShapeDefinition_ListOfAlts_ElmtIncludeSet IncludeSet |
  ShapeDefinition_ListOfAlts_ElmtExtraPropertySet ExtraPropertySet |
  ShapeDefinition_ListOfAlts_ElmtCLOSED 
  deriving (ShapeDefinition_ListOfAlts_Elmt
-> ShapeDefinition_ListOfAlts_Elmt -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ShapeDefinition_ListOfAlts_Elmt
-> ShapeDefinition_ListOfAlts_Elmt -> Bool
$c/= :: ShapeDefinition_ListOfAlts_Elmt
-> ShapeDefinition_ListOfAlts_Elmt -> Bool
== :: ShapeDefinition_ListOfAlts_Elmt
-> ShapeDefinition_ListOfAlts_Elmt -> Bool
$c== :: ShapeDefinition_ListOfAlts_Elmt
-> ShapeDefinition_ListOfAlts_Elmt -> Bool
Eq, Eq ShapeDefinition_ListOfAlts_Elmt
ShapeDefinition_ListOfAlts_Elmt
-> ShapeDefinition_ListOfAlts_Elmt -> Bool
ShapeDefinition_ListOfAlts_Elmt
-> ShapeDefinition_ListOfAlts_Elmt -> Ordering
ShapeDefinition_ListOfAlts_Elmt
-> ShapeDefinition_ListOfAlts_Elmt
-> ShapeDefinition_ListOfAlts_Elmt
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
min :: ShapeDefinition_ListOfAlts_Elmt
-> ShapeDefinition_ListOfAlts_Elmt
-> ShapeDefinition_ListOfAlts_Elmt
$cmin :: ShapeDefinition_ListOfAlts_Elmt
-> ShapeDefinition_ListOfAlts_Elmt
-> ShapeDefinition_ListOfAlts_Elmt
max :: ShapeDefinition_ListOfAlts_Elmt
-> ShapeDefinition_ListOfAlts_Elmt
-> ShapeDefinition_ListOfAlts_Elmt
$cmax :: ShapeDefinition_ListOfAlts_Elmt
-> ShapeDefinition_ListOfAlts_Elmt
-> ShapeDefinition_ListOfAlts_Elmt
>= :: ShapeDefinition_ListOfAlts_Elmt
-> ShapeDefinition_ListOfAlts_Elmt -> Bool
$c>= :: ShapeDefinition_ListOfAlts_Elmt
-> ShapeDefinition_ListOfAlts_Elmt -> Bool
> :: ShapeDefinition_ListOfAlts_Elmt
-> ShapeDefinition_ListOfAlts_Elmt -> Bool
$c> :: ShapeDefinition_ListOfAlts_Elmt
-> ShapeDefinition_ListOfAlts_Elmt -> Bool
<= :: ShapeDefinition_ListOfAlts_Elmt
-> ShapeDefinition_ListOfAlts_Elmt -> Bool
$c<= :: ShapeDefinition_ListOfAlts_Elmt
-> ShapeDefinition_ListOfAlts_Elmt -> Bool
< :: ShapeDefinition_ListOfAlts_Elmt
-> ShapeDefinition_ListOfAlts_Elmt -> Bool
$c< :: ShapeDefinition_ListOfAlts_Elmt
-> ShapeDefinition_ListOfAlts_Elmt -> Bool
compare :: ShapeDefinition_ListOfAlts_Elmt
-> ShapeDefinition_ListOfAlts_Elmt -> Ordering
$ccompare :: ShapeDefinition_ListOfAlts_Elmt
-> ShapeDefinition_ListOfAlts_Elmt -> Ordering
Ord, ReadPrec [ShapeDefinition_ListOfAlts_Elmt]
ReadPrec ShapeDefinition_ListOfAlts_Elmt
Int -> ReadS ShapeDefinition_ListOfAlts_Elmt
ReadS [ShapeDefinition_ListOfAlts_Elmt]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ShapeDefinition_ListOfAlts_Elmt]
$creadListPrec :: ReadPrec [ShapeDefinition_ListOfAlts_Elmt]
readPrec :: ReadPrec ShapeDefinition_ListOfAlts_Elmt
$creadPrec :: ReadPrec ShapeDefinition_ListOfAlts_Elmt
readList :: ReadS [ShapeDefinition_ListOfAlts_Elmt]
$creadList :: ReadS [ShapeDefinition_ListOfAlts_Elmt]
readsPrec :: Int -> ReadS ShapeDefinition_ListOfAlts_Elmt
$creadsPrec :: Int -> ReadS ShapeDefinition_ListOfAlts_Elmt
Read, Int -> ShapeDefinition_ListOfAlts_Elmt -> ShowS
[ShapeDefinition_ListOfAlts_Elmt] -> ShowS
ShapeDefinition_ListOfAlts_Elmt -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ShapeDefinition_ListOfAlts_Elmt] -> ShowS
$cshowList :: [ShapeDefinition_ListOfAlts_Elmt] -> ShowS
show :: ShapeDefinition_ListOfAlts_Elmt -> String
$cshow :: ShapeDefinition_ListOfAlts_Elmt -> String
showsPrec :: Int -> ShapeDefinition_ListOfAlts_Elmt -> ShowS
$cshowsPrec :: Int -> ShapeDefinition_ListOfAlts_Elmt -> ShowS
Show)

_ShapeDefinition_ListOfAlts_Elmt :: Name
_ShapeDefinition_ListOfAlts_Elmt = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.ShapeDefinition.ListOfAlts.Elmt")

_ShapeDefinition_ListOfAlts_Elmt_includeSet :: FieldName
_ShapeDefinition_ListOfAlts_Elmt_includeSet = (String -> FieldName
Core.FieldName String
"includeSet")

_ShapeDefinition_ListOfAlts_Elmt_extraPropertySet :: FieldName
_ShapeDefinition_ListOfAlts_Elmt_extraPropertySet = (String -> FieldName
Core.FieldName String
"extraPropertySet")

_ShapeDefinition_ListOfAlts_Elmt_cLOSED :: FieldName
_ShapeDefinition_ListOfAlts_Elmt_cLOSED = (String -> FieldName
Core.FieldName String
"cLOSED")

data InlineShapeDefinition = 
  InlineShapeDefinition {
    InlineShapeDefinition -> [InlineShapeDefinition_ListOfAlts_Elmt]
inlineShapeDefinitionListOfAlts :: [InlineShapeDefinition_ListOfAlts_Elmt],
    InlineShapeDefinition -> Maybe TripleExpression
inlineShapeDefinitionTripleExpression :: (Maybe TripleExpression)}
  deriving (InlineShapeDefinition -> InlineShapeDefinition -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: InlineShapeDefinition -> InlineShapeDefinition -> Bool
$c/= :: InlineShapeDefinition -> InlineShapeDefinition -> Bool
== :: InlineShapeDefinition -> InlineShapeDefinition -> Bool
$c== :: InlineShapeDefinition -> InlineShapeDefinition -> Bool
Eq, Eq InlineShapeDefinition
InlineShapeDefinition -> InlineShapeDefinition -> Bool
InlineShapeDefinition -> InlineShapeDefinition -> Ordering
InlineShapeDefinition
-> InlineShapeDefinition -> InlineShapeDefinition
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
min :: InlineShapeDefinition
-> InlineShapeDefinition -> InlineShapeDefinition
$cmin :: InlineShapeDefinition
-> InlineShapeDefinition -> InlineShapeDefinition
max :: InlineShapeDefinition
-> InlineShapeDefinition -> InlineShapeDefinition
$cmax :: InlineShapeDefinition
-> InlineShapeDefinition -> InlineShapeDefinition
>= :: InlineShapeDefinition -> InlineShapeDefinition -> Bool
$c>= :: InlineShapeDefinition -> InlineShapeDefinition -> Bool
> :: InlineShapeDefinition -> InlineShapeDefinition -> Bool
$c> :: InlineShapeDefinition -> InlineShapeDefinition -> Bool
<= :: InlineShapeDefinition -> InlineShapeDefinition -> Bool
$c<= :: InlineShapeDefinition -> InlineShapeDefinition -> Bool
< :: InlineShapeDefinition -> InlineShapeDefinition -> Bool
$c< :: InlineShapeDefinition -> InlineShapeDefinition -> Bool
compare :: InlineShapeDefinition -> InlineShapeDefinition -> Ordering
$ccompare :: InlineShapeDefinition -> InlineShapeDefinition -> Ordering
Ord, ReadPrec [InlineShapeDefinition]
ReadPrec InlineShapeDefinition
Int -> ReadS InlineShapeDefinition
ReadS [InlineShapeDefinition]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [InlineShapeDefinition]
$creadListPrec :: ReadPrec [InlineShapeDefinition]
readPrec :: ReadPrec InlineShapeDefinition
$creadPrec :: ReadPrec InlineShapeDefinition
readList :: ReadS [InlineShapeDefinition]
$creadList :: ReadS [InlineShapeDefinition]
readsPrec :: Int -> ReadS InlineShapeDefinition
$creadsPrec :: Int -> ReadS InlineShapeDefinition
Read, Int -> InlineShapeDefinition -> ShowS
[InlineShapeDefinition] -> ShowS
InlineShapeDefinition -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [InlineShapeDefinition] -> ShowS
$cshowList :: [InlineShapeDefinition] -> ShowS
show :: InlineShapeDefinition -> String
$cshow :: InlineShapeDefinition -> String
showsPrec :: Int -> InlineShapeDefinition -> ShowS
$cshowsPrec :: Int -> InlineShapeDefinition -> ShowS
Show)

_InlineShapeDefinition :: Name
_InlineShapeDefinition = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.InlineShapeDefinition")

_InlineShapeDefinition_listOfAlts :: FieldName
_InlineShapeDefinition_listOfAlts = (String -> FieldName
Core.FieldName String
"listOfAlts")

_InlineShapeDefinition_tripleExpression :: FieldName
_InlineShapeDefinition_tripleExpression = (String -> FieldName
Core.FieldName String
"tripleExpression")

data InlineShapeDefinition_ListOfAlts_Elmt = 
  InlineShapeDefinition_ListOfAlts_ElmtIncludeSet IncludeSet |
  InlineShapeDefinition_ListOfAlts_ElmtExtraPropertySet ExtraPropertySet |
  InlineShapeDefinition_ListOfAlts_ElmtCLOSED 
  deriving (InlineShapeDefinition_ListOfAlts_Elmt
-> InlineShapeDefinition_ListOfAlts_Elmt -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: InlineShapeDefinition_ListOfAlts_Elmt
-> InlineShapeDefinition_ListOfAlts_Elmt -> Bool
$c/= :: InlineShapeDefinition_ListOfAlts_Elmt
-> InlineShapeDefinition_ListOfAlts_Elmt -> Bool
== :: InlineShapeDefinition_ListOfAlts_Elmt
-> InlineShapeDefinition_ListOfAlts_Elmt -> Bool
$c== :: InlineShapeDefinition_ListOfAlts_Elmt
-> InlineShapeDefinition_ListOfAlts_Elmt -> Bool
Eq, Eq InlineShapeDefinition_ListOfAlts_Elmt
InlineShapeDefinition_ListOfAlts_Elmt
-> InlineShapeDefinition_ListOfAlts_Elmt -> Bool
InlineShapeDefinition_ListOfAlts_Elmt
-> InlineShapeDefinition_ListOfAlts_Elmt -> Ordering
InlineShapeDefinition_ListOfAlts_Elmt
-> InlineShapeDefinition_ListOfAlts_Elmt
-> InlineShapeDefinition_ListOfAlts_Elmt
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
min :: InlineShapeDefinition_ListOfAlts_Elmt
-> InlineShapeDefinition_ListOfAlts_Elmt
-> InlineShapeDefinition_ListOfAlts_Elmt
$cmin :: InlineShapeDefinition_ListOfAlts_Elmt
-> InlineShapeDefinition_ListOfAlts_Elmt
-> InlineShapeDefinition_ListOfAlts_Elmt
max :: InlineShapeDefinition_ListOfAlts_Elmt
-> InlineShapeDefinition_ListOfAlts_Elmt
-> InlineShapeDefinition_ListOfAlts_Elmt
$cmax :: InlineShapeDefinition_ListOfAlts_Elmt
-> InlineShapeDefinition_ListOfAlts_Elmt
-> InlineShapeDefinition_ListOfAlts_Elmt
>= :: InlineShapeDefinition_ListOfAlts_Elmt
-> InlineShapeDefinition_ListOfAlts_Elmt -> Bool
$c>= :: InlineShapeDefinition_ListOfAlts_Elmt
-> InlineShapeDefinition_ListOfAlts_Elmt -> Bool
> :: InlineShapeDefinition_ListOfAlts_Elmt
-> InlineShapeDefinition_ListOfAlts_Elmt -> Bool
$c> :: InlineShapeDefinition_ListOfAlts_Elmt
-> InlineShapeDefinition_ListOfAlts_Elmt -> Bool
<= :: InlineShapeDefinition_ListOfAlts_Elmt
-> InlineShapeDefinition_ListOfAlts_Elmt -> Bool
$c<= :: InlineShapeDefinition_ListOfAlts_Elmt
-> InlineShapeDefinition_ListOfAlts_Elmt -> Bool
< :: InlineShapeDefinition_ListOfAlts_Elmt
-> InlineShapeDefinition_ListOfAlts_Elmt -> Bool
$c< :: InlineShapeDefinition_ListOfAlts_Elmt
-> InlineShapeDefinition_ListOfAlts_Elmt -> Bool
compare :: InlineShapeDefinition_ListOfAlts_Elmt
-> InlineShapeDefinition_ListOfAlts_Elmt -> Ordering
$ccompare :: InlineShapeDefinition_ListOfAlts_Elmt
-> InlineShapeDefinition_ListOfAlts_Elmt -> Ordering
Ord, ReadPrec [InlineShapeDefinition_ListOfAlts_Elmt]
ReadPrec InlineShapeDefinition_ListOfAlts_Elmt
Int -> ReadS InlineShapeDefinition_ListOfAlts_Elmt
ReadS [InlineShapeDefinition_ListOfAlts_Elmt]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [InlineShapeDefinition_ListOfAlts_Elmt]
$creadListPrec :: ReadPrec [InlineShapeDefinition_ListOfAlts_Elmt]
readPrec :: ReadPrec InlineShapeDefinition_ListOfAlts_Elmt
$creadPrec :: ReadPrec InlineShapeDefinition_ListOfAlts_Elmt
readList :: ReadS [InlineShapeDefinition_ListOfAlts_Elmt]
$creadList :: ReadS [InlineShapeDefinition_ListOfAlts_Elmt]
readsPrec :: Int -> ReadS InlineShapeDefinition_ListOfAlts_Elmt
$creadsPrec :: Int -> ReadS InlineShapeDefinition_ListOfAlts_Elmt
Read, Int -> InlineShapeDefinition_ListOfAlts_Elmt -> ShowS
[InlineShapeDefinition_ListOfAlts_Elmt] -> ShowS
InlineShapeDefinition_ListOfAlts_Elmt -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [InlineShapeDefinition_ListOfAlts_Elmt] -> ShowS
$cshowList :: [InlineShapeDefinition_ListOfAlts_Elmt] -> ShowS
show :: InlineShapeDefinition_ListOfAlts_Elmt -> String
$cshow :: InlineShapeDefinition_ListOfAlts_Elmt -> String
showsPrec :: Int -> InlineShapeDefinition_ListOfAlts_Elmt -> ShowS
$cshowsPrec :: Int -> InlineShapeDefinition_ListOfAlts_Elmt -> ShowS
Show)

_InlineShapeDefinition_ListOfAlts_Elmt :: Name
_InlineShapeDefinition_ListOfAlts_Elmt = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.InlineShapeDefinition.ListOfAlts.Elmt")

_InlineShapeDefinition_ListOfAlts_Elmt_includeSet :: FieldName
_InlineShapeDefinition_ListOfAlts_Elmt_includeSet = (String -> FieldName
Core.FieldName String
"includeSet")

_InlineShapeDefinition_ListOfAlts_Elmt_extraPropertySet :: FieldName
_InlineShapeDefinition_ListOfAlts_Elmt_extraPropertySet = (String -> FieldName
Core.FieldName String
"extraPropertySet")

_InlineShapeDefinition_ListOfAlts_Elmt_cLOSED :: FieldName
_InlineShapeDefinition_ListOfAlts_Elmt_cLOSED = (String -> FieldName
Core.FieldName String
"cLOSED")

data ExtraPropertySet = 
  ExtraPropertySet {
    ExtraPropertySet -> [Predicate]
extraPropertySetListOfPredicate :: [Predicate]}
  deriving (ExtraPropertySet -> ExtraPropertySet -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ExtraPropertySet -> ExtraPropertySet -> Bool
$c/= :: ExtraPropertySet -> ExtraPropertySet -> Bool
== :: ExtraPropertySet -> ExtraPropertySet -> Bool
$c== :: ExtraPropertySet -> ExtraPropertySet -> Bool
Eq, Eq ExtraPropertySet
ExtraPropertySet -> ExtraPropertySet -> Bool
ExtraPropertySet -> ExtraPropertySet -> Ordering
ExtraPropertySet -> ExtraPropertySet -> ExtraPropertySet
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
min :: ExtraPropertySet -> ExtraPropertySet -> ExtraPropertySet
$cmin :: ExtraPropertySet -> ExtraPropertySet -> ExtraPropertySet
max :: ExtraPropertySet -> ExtraPropertySet -> ExtraPropertySet
$cmax :: ExtraPropertySet -> ExtraPropertySet -> ExtraPropertySet
>= :: ExtraPropertySet -> ExtraPropertySet -> Bool
$c>= :: ExtraPropertySet -> ExtraPropertySet -> Bool
> :: ExtraPropertySet -> ExtraPropertySet -> Bool
$c> :: ExtraPropertySet -> ExtraPropertySet -> Bool
<= :: ExtraPropertySet -> ExtraPropertySet -> Bool
$c<= :: ExtraPropertySet -> ExtraPropertySet -> Bool
< :: ExtraPropertySet -> ExtraPropertySet -> Bool
$c< :: ExtraPropertySet -> ExtraPropertySet -> Bool
compare :: ExtraPropertySet -> ExtraPropertySet -> Ordering
$ccompare :: ExtraPropertySet -> ExtraPropertySet -> Ordering
Ord, ReadPrec [ExtraPropertySet]
ReadPrec ExtraPropertySet
Int -> ReadS ExtraPropertySet
ReadS [ExtraPropertySet]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ExtraPropertySet]
$creadListPrec :: ReadPrec [ExtraPropertySet]
readPrec :: ReadPrec ExtraPropertySet
$creadPrec :: ReadPrec ExtraPropertySet
readList :: ReadS [ExtraPropertySet]
$creadList :: ReadS [ExtraPropertySet]
readsPrec :: Int -> ReadS ExtraPropertySet
$creadsPrec :: Int -> ReadS ExtraPropertySet
Read, Int -> ExtraPropertySet -> ShowS
[ExtraPropertySet] -> ShowS
ExtraPropertySet -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ExtraPropertySet] -> ShowS
$cshowList :: [ExtraPropertySet] -> ShowS
show :: ExtraPropertySet -> String
$cshow :: ExtraPropertySet -> String
showsPrec :: Int -> ExtraPropertySet -> ShowS
$cshowsPrec :: Int -> ExtraPropertySet -> ShowS
Show)

_ExtraPropertySet :: Name
_ExtraPropertySet = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.ExtraPropertySet")

_ExtraPropertySet_listOfPredicate :: FieldName
_ExtraPropertySet_listOfPredicate = (String -> FieldName
Core.FieldName String
"listOfPredicate")

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

_TripleExpression :: Name
_TripleExpression = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.TripleExpression")

data OneOfTripleExpr = 
  OneOfTripleExprGroupTripleExpr GroupTripleExpr |
  OneOfTripleExprMultiElementOneOf MultiElementOneOf
  deriving (OneOfTripleExpr -> OneOfTripleExpr -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: OneOfTripleExpr -> OneOfTripleExpr -> Bool
$c/= :: OneOfTripleExpr -> OneOfTripleExpr -> Bool
== :: OneOfTripleExpr -> OneOfTripleExpr -> Bool
$c== :: OneOfTripleExpr -> OneOfTripleExpr -> Bool
Eq, Eq OneOfTripleExpr
OneOfTripleExpr -> OneOfTripleExpr -> Bool
OneOfTripleExpr -> OneOfTripleExpr -> Ordering
OneOfTripleExpr -> OneOfTripleExpr -> OneOfTripleExpr
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
min :: OneOfTripleExpr -> OneOfTripleExpr -> OneOfTripleExpr
$cmin :: OneOfTripleExpr -> OneOfTripleExpr -> OneOfTripleExpr
max :: OneOfTripleExpr -> OneOfTripleExpr -> OneOfTripleExpr
$cmax :: OneOfTripleExpr -> OneOfTripleExpr -> OneOfTripleExpr
>= :: OneOfTripleExpr -> OneOfTripleExpr -> Bool
$c>= :: OneOfTripleExpr -> OneOfTripleExpr -> Bool
> :: OneOfTripleExpr -> OneOfTripleExpr -> Bool
$c> :: OneOfTripleExpr -> OneOfTripleExpr -> Bool
<= :: OneOfTripleExpr -> OneOfTripleExpr -> Bool
$c<= :: OneOfTripleExpr -> OneOfTripleExpr -> Bool
< :: OneOfTripleExpr -> OneOfTripleExpr -> Bool
$c< :: OneOfTripleExpr -> OneOfTripleExpr -> Bool
compare :: OneOfTripleExpr -> OneOfTripleExpr -> Ordering
$ccompare :: OneOfTripleExpr -> OneOfTripleExpr -> Ordering
Ord, ReadPrec [OneOfTripleExpr]
ReadPrec OneOfTripleExpr
Int -> ReadS OneOfTripleExpr
ReadS [OneOfTripleExpr]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [OneOfTripleExpr]
$creadListPrec :: ReadPrec [OneOfTripleExpr]
readPrec :: ReadPrec OneOfTripleExpr
$creadPrec :: ReadPrec OneOfTripleExpr
readList :: ReadS [OneOfTripleExpr]
$creadList :: ReadS [OneOfTripleExpr]
readsPrec :: Int -> ReadS OneOfTripleExpr
$creadsPrec :: Int -> ReadS OneOfTripleExpr
Read, Int -> OneOfTripleExpr -> ShowS
[OneOfTripleExpr] -> ShowS
OneOfTripleExpr -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [OneOfTripleExpr] -> ShowS
$cshowList :: [OneOfTripleExpr] -> ShowS
show :: OneOfTripleExpr -> String
$cshow :: OneOfTripleExpr -> String
showsPrec :: Int -> OneOfTripleExpr -> ShowS
$cshowsPrec :: Int -> OneOfTripleExpr -> ShowS
Show)

_OneOfTripleExpr :: Name
_OneOfTripleExpr = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.OneOfTripleExpr")

_OneOfTripleExpr_groupTripleExpr :: FieldName
_OneOfTripleExpr_groupTripleExpr = (String -> FieldName
Core.FieldName String
"groupTripleExpr")

_OneOfTripleExpr_multiElementOneOf :: FieldName
_OneOfTripleExpr_multiElementOneOf = (String -> FieldName
Core.FieldName String
"multiElementOneOf")

data MultiElementOneOf = 
  MultiElementOneOf {
    MultiElementOneOf -> GroupTripleExpr
multiElementOneOfGroupTripleExpr :: GroupTripleExpr,
    MultiElementOneOf -> [MultiElementOneOf_ListOfSequence_Elmt]
multiElementOneOfListOfSequence :: [MultiElementOneOf_ListOfSequence_Elmt]}
  deriving (MultiElementOneOf -> MultiElementOneOf -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MultiElementOneOf -> MultiElementOneOf -> Bool
$c/= :: MultiElementOneOf -> MultiElementOneOf -> Bool
== :: MultiElementOneOf -> MultiElementOneOf -> Bool
$c== :: MultiElementOneOf -> MultiElementOneOf -> Bool
Eq, Eq MultiElementOneOf
MultiElementOneOf -> MultiElementOneOf -> Bool
MultiElementOneOf -> MultiElementOneOf -> Ordering
MultiElementOneOf -> MultiElementOneOf -> MultiElementOneOf
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
min :: MultiElementOneOf -> MultiElementOneOf -> MultiElementOneOf
$cmin :: MultiElementOneOf -> MultiElementOneOf -> MultiElementOneOf
max :: MultiElementOneOf -> MultiElementOneOf -> MultiElementOneOf
$cmax :: MultiElementOneOf -> MultiElementOneOf -> MultiElementOneOf
>= :: MultiElementOneOf -> MultiElementOneOf -> Bool
$c>= :: MultiElementOneOf -> MultiElementOneOf -> Bool
> :: MultiElementOneOf -> MultiElementOneOf -> Bool
$c> :: MultiElementOneOf -> MultiElementOneOf -> Bool
<= :: MultiElementOneOf -> MultiElementOneOf -> Bool
$c<= :: MultiElementOneOf -> MultiElementOneOf -> Bool
< :: MultiElementOneOf -> MultiElementOneOf -> Bool
$c< :: MultiElementOneOf -> MultiElementOneOf -> Bool
compare :: MultiElementOneOf -> MultiElementOneOf -> Ordering
$ccompare :: MultiElementOneOf -> MultiElementOneOf -> Ordering
Ord, ReadPrec [MultiElementOneOf]
ReadPrec MultiElementOneOf
Int -> ReadS MultiElementOneOf
ReadS [MultiElementOneOf]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [MultiElementOneOf]
$creadListPrec :: ReadPrec [MultiElementOneOf]
readPrec :: ReadPrec MultiElementOneOf
$creadPrec :: ReadPrec MultiElementOneOf
readList :: ReadS [MultiElementOneOf]
$creadList :: ReadS [MultiElementOneOf]
readsPrec :: Int -> ReadS MultiElementOneOf
$creadsPrec :: Int -> ReadS MultiElementOneOf
Read, Int -> MultiElementOneOf -> ShowS
[MultiElementOneOf] -> ShowS
MultiElementOneOf -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MultiElementOneOf] -> ShowS
$cshowList :: [MultiElementOneOf] -> ShowS
show :: MultiElementOneOf -> String
$cshow :: MultiElementOneOf -> String
showsPrec :: Int -> MultiElementOneOf -> ShowS
$cshowsPrec :: Int -> MultiElementOneOf -> ShowS
Show)

_MultiElementOneOf :: Name
_MultiElementOneOf = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.MultiElementOneOf")

_MultiElementOneOf_groupTripleExpr :: FieldName
_MultiElementOneOf_groupTripleExpr = (String -> FieldName
Core.FieldName String
"groupTripleExpr")

_MultiElementOneOf_listOfSequence :: FieldName
_MultiElementOneOf_listOfSequence = (String -> FieldName
Core.FieldName String
"listOfSequence")

data MultiElementOneOf_ListOfSequence_Elmt = 
  MultiElementOneOf_ListOfSequence_Elmt {
    MultiElementOneOf_ListOfSequence_Elmt -> GroupTripleExpr
multiElementOneOf_ListOfSequence_ElmtGroupTripleExpr :: GroupTripleExpr}
  deriving (MultiElementOneOf_ListOfSequence_Elmt
-> MultiElementOneOf_ListOfSequence_Elmt -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MultiElementOneOf_ListOfSequence_Elmt
-> MultiElementOneOf_ListOfSequence_Elmt -> Bool
$c/= :: MultiElementOneOf_ListOfSequence_Elmt
-> MultiElementOneOf_ListOfSequence_Elmt -> Bool
== :: MultiElementOneOf_ListOfSequence_Elmt
-> MultiElementOneOf_ListOfSequence_Elmt -> Bool
$c== :: MultiElementOneOf_ListOfSequence_Elmt
-> MultiElementOneOf_ListOfSequence_Elmt -> Bool
Eq, Eq MultiElementOneOf_ListOfSequence_Elmt
MultiElementOneOf_ListOfSequence_Elmt
-> MultiElementOneOf_ListOfSequence_Elmt -> Bool
MultiElementOneOf_ListOfSequence_Elmt
-> MultiElementOneOf_ListOfSequence_Elmt -> Ordering
MultiElementOneOf_ListOfSequence_Elmt
-> MultiElementOneOf_ListOfSequence_Elmt
-> MultiElementOneOf_ListOfSequence_Elmt
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
min :: MultiElementOneOf_ListOfSequence_Elmt
-> MultiElementOneOf_ListOfSequence_Elmt
-> MultiElementOneOf_ListOfSequence_Elmt
$cmin :: MultiElementOneOf_ListOfSequence_Elmt
-> MultiElementOneOf_ListOfSequence_Elmt
-> MultiElementOneOf_ListOfSequence_Elmt
max :: MultiElementOneOf_ListOfSequence_Elmt
-> MultiElementOneOf_ListOfSequence_Elmt
-> MultiElementOneOf_ListOfSequence_Elmt
$cmax :: MultiElementOneOf_ListOfSequence_Elmt
-> MultiElementOneOf_ListOfSequence_Elmt
-> MultiElementOneOf_ListOfSequence_Elmt
>= :: MultiElementOneOf_ListOfSequence_Elmt
-> MultiElementOneOf_ListOfSequence_Elmt -> Bool
$c>= :: MultiElementOneOf_ListOfSequence_Elmt
-> MultiElementOneOf_ListOfSequence_Elmt -> Bool
> :: MultiElementOneOf_ListOfSequence_Elmt
-> MultiElementOneOf_ListOfSequence_Elmt -> Bool
$c> :: MultiElementOneOf_ListOfSequence_Elmt
-> MultiElementOneOf_ListOfSequence_Elmt -> Bool
<= :: MultiElementOneOf_ListOfSequence_Elmt
-> MultiElementOneOf_ListOfSequence_Elmt -> Bool
$c<= :: MultiElementOneOf_ListOfSequence_Elmt
-> MultiElementOneOf_ListOfSequence_Elmt -> Bool
< :: MultiElementOneOf_ListOfSequence_Elmt
-> MultiElementOneOf_ListOfSequence_Elmt -> Bool
$c< :: MultiElementOneOf_ListOfSequence_Elmt
-> MultiElementOneOf_ListOfSequence_Elmt -> Bool
compare :: MultiElementOneOf_ListOfSequence_Elmt
-> MultiElementOneOf_ListOfSequence_Elmt -> Ordering
$ccompare :: MultiElementOneOf_ListOfSequence_Elmt
-> MultiElementOneOf_ListOfSequence_Elmt -> Ordering
Ord, ReadPrec [MultiElementOneOf_ListOfSequence_Elmt]
ReadPrec MultiElementOneOf_ListOfSequence_Elmt
Int -> ReadS MultiElementOneOf_ListOfSequence_Elmt
ReadS [MultiElementOneOf_ListOfSequence_Elmt]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [MultiElementOneOf_ListOfSequence_Elmt]
$creadListPrec :: ReadPrec [MultiElementOneOf_ListOfSequence_Elmt]
readPrec :: ReadPrec MultiElementOneOf_ListOfSequence_Elmt
$creadPrec :: ReadPrec MultiElementOneOf_ListOfSequence_Elmt
readList :: ReadS [MultiElementOneOf_ListOfSequence_Elmt]
$creadList :: ReadS [MultiElementOneOf_ListOfSequence_Elmt]
readsPrec :: Int -> ReadS MultiElementOneOf_ListOfSequence_Elmt
$creadsPrec :: Int -> ReadS MultiElementOneOf_ListOfSequence_Elmt
Read, Int -> MultiElementOneOf_ListOfSequence_Elmt -> ShowS
[MultiElementOneOf_ListOfSequence_Elmt] -> ShowS
MultiElementOneOf_ListOfSequence_Elmt -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MultiElementOneOf_ListOfSequence_Elmt] -> ShowS
$cshowList :: [MultiElementOneOf_ListOfSequence_Elmt] -> ShowS
show :: MultiElementOneOf_ListOfSequence_Elmt -> String
$cshow :: MultiElementOneOf_ListOfSequence_Elmt -> String
showsPrec :: Int -> MultiElementOneOf_ListOfSequence_Elmt -> ShowS
$cshowsPrec :: Int -> MultiElementOneOf_ListOfSequence_Elmt -> ShowS
Show)

_MultiElementOneOf_ListOfSequence_Elmt :: Name
_MultiElementOneOf_ListOfSequence_Elmt = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.MultiElementOneOf.ListOfSequence.Elmt")

_MultiElementOneOf_ListOfSequence_Elmt_groupTripleExpr :: FieldName
_MultiElementOneOf_ListOfSequence_Elmt_groupTripleExpr = (String -> FieldName
Core.FieldName String
"groupTripleExpr")

data InnerTripleExpr = 
  InnerTripleExprMultiElementGroup MultiElementGroup |
  InnerTripleExprMultiElementOneOf MultiElementOneOf
  deriving (InnerTripleExpr -> InnerTripleExpr -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: InnerTripleExpr -> InnerTripleExpr -> Bool
$c/= :: InnerTripleExpr -> InnerTripleExpr -> Bool
== :: InnerTripleExpr -> InnerTripleExpr -> Bool
$c== :: InnerTripleExpr -> InnerTripleExpr -> Bool
Eq, Eq InnerTripleExpr
InnerTripleExpr -> InnerTripleExpr -> Bool
InnerTripleExpr -> InnerTripleExpr -> Ordering
InnerTripleExpr -> InnerTripleExpr -> InnerTripleExpr
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
min :: InnerTripleExpr -> InnerTripleExpr -> InnerTripleExpr
$cmin :: InnerTripleExpr -> InnerTripleExpr -> InnerTripleExpr
max :: InnerTripleExpr -> InnerTripleExpr -> InnerTripleExpr
$cmax :: InnerTripleExpr -> InnerTripleExpr -> InnerTripleExpr
>= :: InnerTripleExpr -> InnerTripleExpr -> Bool
$c>= :: InnerTripleExpr -> InnerTripleExpr -> Bool
> :: InnerTripleExpr -> InnerTripleExpr -> Bool
$c> :: InnerTripleExpr -> InnerTripleExpr -> Bool
<= :: InnerTripleExpr -> InnerTripleExpr -> Bool
$c<= :: InnerTripleExpr -> InnerTripleExpr -> Bool
< :: InnerTripleExpr -> InnerTripleExpr -> Bool
$c< :: InnerTripleExpr -> InnerTripleExpr -> Bool
compare :: InnerTripleExpr -> InnerTripleExpr -> Ordering
$ccompare :: InnerTripleExpr -> InnerTripleExpr -> Ordering
Ord, ReadPrec [InnerTripleExpr]
ReadPrec InnerTripleExpr
Int -> ReadS InnerTripleExpr
ReadS [InnerTripleExpr]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [InnerTripleExpr]
$creadListPrec :: ReadPrec [InnerTripleExpr]
readPrec :: ReadPrec InnerTripleExpr
$creadPrec :: ReadPrec InnerTripleExpr
readList :: ReadS [InnerTripleExpr]
$creadList :: ReadS [InnerTripleExpr]
readsPrec :: Int -> ReadS InnerTripleExpr
$creadsPrec :: Int -> ReadS InnerTripleExpr
Read, Int -> InnerTripleExpr -> ShowS
[InnerTripleExpr] -> ShowS
InnerTripleExpr -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [InnerTripleExpr] -> ShowS
$cshowList :: [InnerTripleExpr] -> ShowS
show :: InnerTripleExpr -> String
$cshow :: InnerTripleExpr -> String
showsPrec :: Int -> InnerTripleExpr -> ShowS
$cshowsPrec :: Int -> InnerTripleExpr -> ShowS
Show)

_InnerTripleExpr :: Name
_InnerTripleExpr = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.InnerTripleExpr")

_InnerTripleExpr_multiElementGroup :: FieldName
_InnerTripleExpr_multiElementGroup = (String -> FieldName
Core.FieldName String
"multiElementGroup")

_InnerTripleExpr_multiElementOneOf :: FieldName
_InnerTripleExpr_multiElementOneOf = (String -> FieldName
Core.FieldName String
"multiElementOneOf")

data GroupTripleExpr = 
  GroupTripleExprSingleElementGroup SingleElementGroup |
  GroupTripleExprMultiElementGroup MultiElementGroup
  deriving (GroupTripleExpr -> GroupTripleExpr -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GroupTripleExpr -> GroupTripleExpr -> Bool
$c/= :: GroupTripleExpr -> GroupTripleExpr -> Bool
== :: GroupTripleExpr -> GroupTripleExpr -> Bool
$c== :: GroupTripleExpr -> GroupTripleExpr -> Bool
Eq, Eq GroupTripleExpr
GroupTripleExpr -> GroupTripleExpr -> Bool
GroupTripleExpr -> GroupTripleExpr -> Ordering
GroupTripleExpr -> GroupTripleExpr -> GroupTripleExpr
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
min :: GroupTripleExpr -> GroupTripleExpr -> GroupTripleExpr
$cmin :: GroupTripleExpr -> GroupTripleExpr -> GroupTripleExpr
max :: GroupTripleExpr -> GroupTripleExpr -> GroupTripleExpr
$cmax :: GroupTripleExpr -> GroupTripleExpr -> GroupTripleExpr
>= :: GroupTripleExpr -> GroupTripleExpr -> Bool
$c>= :: GroupTripleExpr -> GroupTripleExpr -> Bool
> :: GroupTripleExpr -> GroupTripleExpr -> Bool
$c> :: GroupTripleExpr -> GroupTripleExpr -> Bool
<= :: GroupTripleExpr -> GroupTripleExpr -> Bool
$c<= :: GroupTripleExpr -> GroupTripleExpr -> Bool
< :: GroupTripleExpr -> GroupTripleExpr -> Bool
$c< :: GroupTripleExpr -> GroupTripleExpr -> Bool
compare :: GroupTripleExpr -> GroupTripleExpr -> Ordering
$ccompare :: GroupTripleExpr -> GroupTripleExpr -> Ordering
Ord, ReadPrec [GroupTripleExpr]
ReadPrec GroupTripleExpr
Int -> ReadS GroupTripleExpr
ReadS [GroupTripleExpr]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GroupTripleExpr]
$creadListPrec :: ReadPrec [GroupTripleExpr]
readPrec :: ReadPrec GroupTripleExpr
$creadPrec :: ReadPrec GroupTripleExpr
readList :: ReadS [GroupTripleExpr]
$creadList :: ReadS [GroupTripleExpr]
readsPrec :: Int -> ReadS GroupTripleExpr
$creadsPrec :: Int -> ReadS GroupTripleExpr
Read, Int -> GroupTripleExpr -> ShowS
[GroupTripleExpr] -> ShowS
GroupTripleExpr -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GroupTripleExpr] -> ShowS
$cshowList :: [GroupTripleExpr] -> ShowS
show :: GroupTripleExpr -> String
$cshow :: GroupTripleExpr -> String
showsPrec :: Int -> GroupTripleExpr -> ShowS
$cshowsPrec :: Int -> GroupTripleExpr -> ShowS
Show)

_GroupTripleExpr :: Name
_GroupTripleExpr = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.GroupTripleExpr")

_GroupTripleExpr_singleElementGroup :: FieldName
_GroupTripleExpr_singleElementGroup = (String -> FieldName
Core.FieldName String
"singleElementGroup")

_GroupTripleExpr_multiElementGroup :: FieldName
_GroupTripleExpr_multiElementGroup = (String -> FieldName
Core.FieldName String
"multiElementGroup")

data SingleElementGroup = 
  SingleElementGroup {
    SingleElementGroup -> UnaryTripleExpr
singleElementGroupUnaryTripleExpr :: UnaryTripleExpr,
    SingleElementGroup -> Maybe ()
singleElementGroupSemi :: (Maybe ())}
  deriving (SingleElementGroup -> SingleElementGroup -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SingleElementGroup -> SingleElementGroup -> Bool
$c/= :: SingleElementGroup -> SingleElementGroup -> Bool
== :: SingleElementGroup -> SingleElementGroup -> Bool
$c== :: SingleElementGroup -> SingleElementGroup -> Bool
Eq, Eq SingleElementGroup
SingleElementGroup -> SingleElementGroup -> Bool
SingleElementGroup -> SingleElementGroup -> Ordering
SingleElementGroup -> SingleElementGroup -> SingleElementGroup
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
min :: SingleElementGroup -> SingleElementGroup -> SingleElementGroup
$cmin :: SingleElementGroup -> SingleElementGroup -> SingleElementGroup
max :: SingleElementGroup -> SingleElementGroup -> SingleElementGroup
$cmax :: SingleElementGroup -> SingleElementGroup -> SingleElementGroup
>= :: SingleElementGroup -> SingleElementGroup -> Bool
$c>= :: SingleElementGroup -> SingleElementGroup -> Bool
> :: SingleElementGroup -> SingleElementGroup -> Bool
$c> :: SingleElementGroup -> SingleElementGroup -> Bool
<= :: SingleElementGroup -> SingleElementGroup -> Bool
$c<= :: SingleElementGroup -> SingleElementGroup -> Bool
< :: SingleElementGroup -> SingleElementGroup -> Bool
$c< :: SingleElementGroup -> SingleElementGroup -> Bool
compare :: SingleElementGroup -> SingleElementGroup -> Ordering
$ccompare :: SingleElementGroup -> SingleElementGroup -> Ordering
Ord, ReadPrec [SingleElementGroup]
ReadPrec SingleElementGroup
Int -> ReadS SingleElementGroup
ReadS [SingleElementGroup]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [SingleElementGroup]
$creadListPrec :: ReadPrec [SingleElementGroup]
readPrec :: ReadPrec SingleElementGroup
$creadPrec :: ReadPrec SingleElementGroup
readList :: ReadS [SingleElementGroup]
$creadList :: ReadS [SingleElementGroup]
readsPrec :: Int -> ReadS SingleElementGroup
$creadsPrec :: Int -> ReadS SingleElementGroup
Read, Int -> SingleElementGroup -> ShowS
[SingleElementGroup] -> ShowS
SingleElementGroup -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SingleElementGroup] -> ShowS
$cshowList :: [SingleElementGroup] -> ShowS
show :: SingleElementGroup -> String
$cshow :: SingleElementGroup -> String
showsPrec :: Int -> SingleElementGroup -> ShowS
$cshowsPrec :: Int -> SingleElementGroup -> ShowS
Show)

_SingleElementGroup :: Name
_SingleElementGroup = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.SingleElementGroup")

_SingleElementGroup_unaryTripleExpr :: FieldName
_SingleElementGroup_unaryTripleExpr = (String -> FieldName
Core.FieldName String
"unaryTripleExpr")

_SingleElementGroup_semi :: FieldName
_SingleElementGroup_semi = (String -> FieldName
Core.FieldName String
"semi")

data MultiElementGroup = 
  MultiElementGroup {
    MultiElementGroup -> UnaryTripleExpr
multiElementGroupUnaryTripleExpr :: UnaryTripleExpr,
    MultiElementGroup -> [MultiElementGroup_ListOfSequence_Elmt]
multiElementGroupListOfSequence :: [MultiElementGroup_ListOfSequence_Elmt],
    MultiElementGroup -> Maybe ()
multiElementGroupSemi :: (Maybe ())}
  deriving (MultiElementGroup -> MultiElementGroup -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MultiElementGroup -> MultiElementGroup -> Bool
$c/= :: MultiElementGroup -> MultiElementGroup -> Bool
== :: MultiElementGroup -> MultiElementGroup -> Bool
$c== :: MultiElementGroup -> MultiElementGroup -> Bool
Eq, Eq MultiElementGroup
MultiElementGroup -> MultiElementGroup -> Bool
MultiElementGroup -> MultiElementGroup -> Ordering
MultiElementGroup -> MultiElementGroup -> MultiElementGroup
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
min :: MultiElementGroup -> MultiElementGroup -> MultiElementGroup
$cmin :: MultiElementGroup -> MultiElementGroup -> MultiElementGroup
max :: MultiElementGroup -> MultiElementGroup -> MultiElementGroup
$cmax :: MultiElementGroup -> MultiElementGroup -> MultiElementGroup
>= :: MultiElementGroup -> MultiElementGroup -> Bool
$c>= :: MultiElementGroup -> MultiElementGroup -> Bool
> :: MultiElementGroup -> MultiElementGroup -> Bool
$c> :: MultiElementGroup -> MultiElementGroup -> Bool
<= :: MultiElementGroup -> MultiElementGroup -> Bool
$c<= :: MultiElementGroup -> MultiElementGroup -> Bool
< :: MultiElementGroup -> MultiElementGroup -> Bool
$c< :: MultiElementGroup -> MultiElementGroup -> Bool
compare :: MultiElementGroup -> MultiElementGroup -> Ordering
$ccompare :: MultiElementGroup -> MultiElementGroup -> Ordering
Ord, ReadPrec [MultiElementGroup]
ReadPrec MultiElementGroup
Int -> ReadS MultiElementGroup
ReadS [MultiElementGroup]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [MultiElementGroup]
$creadListPrec :: ReadPrec [MultiElementGroup]
readPrec :: ReadPrec MultiElementGroup
$creadPrec :: ReadPrec MultiElementGroup
readList :: ReadS [MultiElementGroup]
$creadList :: ReadS [MultiElementGroup]
readsPrec :: Int -> ReadS MultiElementGroup
$creadsPrec :: Int -> ReadS MultiElementGroup
Read, Int -> MultiElementGroup -> ShowS
[MultiElementGroup] -> ShowS
MultiElementGroup -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MultiElementGroup] -> ShowS
$cshowList :: [MultiElementGroup] -> ShowS
show :: MultiElementGroup -> String
$cshow :: MultiElementGroup -> String
showsPrec :: Int -> MultiElementGroup -> ShowS
$cshowsPrec :: Int -> MultiElementGroup -> ShowS
Show)

_MultiElementGroup :: Name
_MultiElementGroup = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.MultiElementGroup")

_MultiElementGroup_unaryTripleExpr :: FieldName
_MultiElementGroup_unaryTripleExpr = (String -> FieldName
Core.FieldName String
"unaryTripleExpr")

_MultiElementGroup_listOfSequence :: FieldName
_MultiElementGroup_listOfSequence = (String -> FieldName
Core.FieldName String
"listOfSequence")

_MultiElementGroup_semi :: FieldName
_MultiElementGroup_semi = (String -> FieldName
Core.FieldName String
"semi")

data MultiElementGroup_ListOfSequence_Elmt = 
  MultiElementGroup_ListOfSequence_Elmt {
    MultiElementGroup_ListOfSequence_Elmt -> UnaryTripleExpr
multiElementGroup_ListOfSequence_ElmtUnaryTripleExpr :: UnaryTripleExpr}
  deriving (MultiElementGroup_ListOfSequence_Elmt
-> MultiElementGroup_ListOfSequence_Elmt -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MultiElementGroup_ListOfSequence_Elmt
-> MultiElementGroup_ListOfSequence_Elmt -> Bool
$c/= :: MultiElementGroup_ListOfSequence_Elmt
-> MultiElementGroup_ListOfSequence_Elmt -> Bool
== :: MultiElementGroup_ListOfSequence_Elmt
-> MultiElementGroup_ListOfSequence_Elmt -> Bool
$c== :: MultiElementGroup_ListOfSequence_Elmt
-> MultiElementGroup_ListOfSequence_Elmt -> Bool
Eq, Eq MultiElementGroup_ListOfSequence_Elmt
MultiElementGroup_ListOfSequence_Elmt
-> MultiElementGroup_ListOfSequence_Elmt -> Bool
MultiElementGroup_ListOfSequence_Elmt
-> MultiElementGroup_ListOfSequence_Elmt -> Ordering
MultiElementGroup_ListOfSequence_Elmt
-> MultiElementGroup_ListOfSequence_Elmt
-> MultiElementGroup_ListOfSequence_Elmt
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
min :: MultiElementGroup_ListOfSequence_Elmt
-> MultiElementGroup_ListOfSequence_Elmt
-> MultiElementGroup_ListOfSequence_Elmt
$cmin :: MultiElementGroup_ListOfSequence_Elmt
-> MultiElementGroup_ListOfSequence_Elmt
-> MultiElementGroup_ListOfSequence_Elmt
max :: MultiElementGroup_ListOfSequence_Elmt
-> MultiElementGroup_ListOfSequence_Elmt
-> MultiElementGroup_ListOfSequence_Elmt
$cmax :: MultiElementGroup_ListOfSequence_Elmt
-> MultiElementGroup_ListOfSequence_Elmt
-> MultiElementGroup_ListOfSequence_Elmt
>= :: MultiElementGroup_ListOfSequence_Elmt
-> MultiElementGroup_ListOfSequence_Elmt -> Bool
$c>= :: MultiElementGroup_ListOfSequence_Elmt
-> MultiElementGroup_ListOfSequence_Elmt -> Bool
> :: MultiElementGroup_ListOfSequence_Elmt
-> MultiElementGroup_ListOfSequence_Elmt -> Bool
$c> :: MultiElementGroup_ListOfSequence_Elmt
-> MultiElementGroup_ListOfSequence_Elmt -> Bool
<= :: MultiElementGroup_ListOfSequence_Elmt
-> MultiElementGroup_ListOfSequence_Elmt -> Bool
$c<= :: MultiElementGroup_ListOfSequence_Elmt
-> MultiElementGroup_ListOfSequence_Elmt -> Bool
< :: MultiElementGroup_ListOfSequence_Elmt
-> MultiElementGroup_ListOfSequence_Elmt -> Bool
$c< :: MultiElementGroup_ListOfSequence_Elmt
-> MultiElementGroup_ListOfSequence_Elmt -> Bool
compare :: MultiElementGroup_ListOfSequence_Elmt
-> MultiElementGroup_ListOfSequence_Elmt -> Ordering
$ccompare :: MultiElementGroup_ListOfSequence_Elmt
-> MultiElementGroup_ListOfSequence_Elmt -> Ordering
Ord, ReadPrec [MultiElementGroup_ListOfSequence_Elmt]
ReadPrec MultiElementGroup_ListOfSequence_Elmt
Int -> ReadS MultiElementGroup_ListOfSequence_Elmt
ReadS [MultiElementGroup_ListOfSequence_Elmt]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [MultiElementGroup_ListOfSequence_Elmt]
$creadListPrec :: ReadPrec [MultiElementGroup_ListOfSequence_Elmt]
readPrec :: ReadPrec MultiElementGroup_ListOfSequence_Elmt
$creadPrec :: ReadPrec MultiElementGroup_ListOfSequence_Elmt
readList :: ReadS [MultiElementGroup_ListOfSequence_Elmt]
$creadList :: ReadS [MultiElementGroup_ListOfSequence_Elmt]
readsPrec :: Int -> ReadS MultiElementGroup_ListOfSequence_Elmt
$creadsPrec :: Int -> ReadS MultiElementGroup_ListOfSequence_Elmt
Read, Int -> MultiElementGroup_ListOfSequence_Elmt -> ShowS
[MultiElementGroup_ListOfSequence_Elmt] -> ShowS
MultiElementGroup_ListOfSequence_Elmt -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MultiElementGroup_ListOfSequence_Elmt] -> ShowS
$cshowList :: [MultiElementGroup_ListOfSequence_Elmt] -> ShowS
show :: MultiElementGroup_ListOfSequence_Elmt -> String
$cshow :: MultiElementGroup_ListOfSequence_Elmt -> String
showsPrec :: Int -> MultiElementGroup_ListOfSequence_Elmt -> ShowS
$cshowsPrec :: Int -> MultiElementGroup_ListOfSequence_Elmt -> ShowS
Show)

_MultiElementGroup_ListOfSequence_Elmt :: Name
_MultiElementGroup_ListOfSequence_Elmt = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.MultiElementGroup.ListOfSequence.Elmt")

_MultiElementGroup_ListOfSequence_Elmt_unaryTripleExpr :: FieldName
_MultiElementGroup_ListOfSequence_Elmt_unaryTripleExpr = (String -> FieldName
Core.FieldName String
"unaryTripleExpr")

data UnaryTripleExpr = 
  UnaryTripleExprSequence UnaryTripleExpr_Sequence |
  UnaryTripleExprInclude Include
  deriving (UnaryTripleExpr -> UnaryTripleExpr -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UnaryTripleExpr -> UnaryTripleExpr -> Bool
$c/= :: UnaryTripleExpr -> UnaryTripleExpr -> Bool
== :: UnaryTripleExpr -> UnaryTripleExpr -> Bool
$c== :: UnaryTripleExpr -> UnaryTripleExpr -> Bool
Eq, Eq UnaryTripleExpr
UnaryTripleExpr -> UnaryTripleExpr -> Bool
UnaryTripleExpr -> UnaryTripleExpr -> Ordering
UnaryTripleExpr -> UnaryTripleExpr -> UnaryTripleExpr
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
min :: UnaryTripleExpr -> UnaryTripleExpr -> UnaryTripleExpr
$cmin :: UnaryTripleExpr -> UnaryTripleExpr -> UnaryTripleExpr
max :: UnaryTripleExpr -> UnaryTripleExpr -> UnaryTripleExpr
$cmax :: UnaryTripleExpr -> UnaryTripleExpr -> UnaryTripleExpr
>= :: UnaryTripleExpr -> UnaryTripleExpr -> Bool
$c>= :: UnaryTripleExpr -> UnaryTripleExpr -> Bool
> :: UnaryTripleExpr -> UnaryTripleExpr -> Bool
$c> :: UnaryTripleExpr -> UnaryTripleExpr -> Bool
<= :: UnaryTripleExpr -> UnaryTripleExpr -> Bool
$c<= :: UnaryTripleExpr -> UnaryTripleExpr -> Bool
< :: UnaryTripleExpr -> UnaryTripleExpr -> Bool
$c< :: UnaryTripleExpr -> UnaryTripleExpr -> Bool
compare :: UnaryTripleExpr -> UnaryTripleExpr -> Ordering
$ccompare :: UnaryTripleExpr -> UnaryTripleExpr -> Ordering
Ord, ReadPrec [UnaryTripleExpr]
ReadPrec UnaryTripleExpr
Int -> ReadS UnaryTripleExpr
ReadS [UnaryTripleExpr]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [UnaryTripleExpr]
$creadListPrec :: ReadPrec [UnaryTripleExpr]
readPrec :: ReadPrec UnaryTripleExpr
$creadPrec :: ReadPrec UnaryTripleExpr
readList :: ReadS [UnaryTripleExpr]
$creadList :: ReadS [UnaryTripleExpr]
readsPrec :: Int -> ReadS UnaryTripleExpr
$creadsPrec :: Int -> ReadS UnaryTripleExpr
Read, Int -> UnaryTripleExpr -> ShowS
[UnaryTripleExpr] -> ShowS
UnaryTripleExpr -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [UnaryTripleExpr] -> ShowS
$cshowList :: [UnaryTripleExpr] -> ShowS
show :: UnaryTripleExpr -> String
$cshow :: UnaryTripleExpr -> String
showsPrec :: Int -> UnaryTripleExpr -> ShowS
$cshowsPrec :: Int -> UnaryTripleExpr -> ShowS
Show)

_UnaryTripleExpr :: Name
_UnaryTripleExpr = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.UnaryTripleExpr")

_UnaryTripleExpr_sequence :: FieldName
_UnaryTripleExpr_sequence = (String -> FieldName
Core.FieldName String
"sequence")

_UnaryTripleExpr_include :: FieldName
_UnaryTripleExpr_include = (String -> FieldName
Core.FieldName String
"include")

data UnaryTripleExpr_Sequence = 
  UnaryTripleExpr_Sequence {
    UnaryTripleExpr_Sequence
-> Maybe UnaryTripleExpr_Sequence_Sequence_Option
unaryTripleExpr_SequenceSequence :: (Maybe UnaryTripleExpr_Sequence_Sequence_Option),
    UnaryTripleExpr_Sequence -> UnaryTripleExpr_Sequence_Alts
unaryTripleExpr_SequenceAlts :: UnaryTripleExpr_Sequence_Alts}
  deriving (UnaryTripleExpr_Sequence -> UnaryTripleExpr_Sequence -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UnaryTripleExpr_Sequence -> UnaryTripleExpr_Sequence -> Bool
$c/= :: UnaryTripleExpr_Sequence -> UnaryTripleExpr_Sequence -> Bool
== :: UnaryTripleExpr_Sequence -> UnaryTripleExpr_Sequence -> Bool
$c== :: UnaryTripleExpr_Sequence -> UnaryTripleExpr_Sequence -> Bool
Eq, Eq UnaryTripleExpr_Sequence
UnaryTripleExpr_Sequence -> UnaryTripleExpr_Sequence -> Bool
UnaryTripleExpr_Sequence -> UnaryTripleExpr_Sequence -> Ordering
UnaryTripleExpr_Sequence
-> UnaryTripleExpr_Sequence -> UnaryTripleExpr_Sequence
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
min :: UnaryTripleExpr_Sequence
-> UnaryTripleExpr_Sequence -> UnaryTripleExpr_Sequence
$cmin :: UnaryTripleExpr_Sequence
-> UnaryTripleExpr_Sequence -> UnaryTripleExpr_Sequence
max :: UnaryTripleExpr_Sequence
-> UnaryTripleExpr_Sequence -> UnaryTripleExpr_Sequence
$cmax :: UnaryTripleExpr_Sequence
-> UnaryTripleExpr_Sequence -> UnaryTripleExpr_Sequence
>= :: UnaryTripleExpr_Sequence -> UnaryTripleExpr_Sequence -> Bool
$c>= :: UnaryTripleExpr_Sequence -> UnaryTripleExpr_Sequence -> Bool
> :: UnaryTripleExpr_Sequence -> UnaryTripleExpr_Sequence -> Bool
$c> :: UnaryTripleExpr_Sequence -> UnaryTripleExpr_Sequence -> Bool
<= :: UnaryTripleExpr_Sequence -> UnaryTripleExpr_Sequence -> Bool
$c<= :: UnaryTripleExpr_Sequence -> UnaryTripleExpr_Sequence -> Bool
< :: UnaryTripleExpr_Sequence -> UnaryTripleExpr_Sequence -> Bool
$c< :: UnaryTripleExpr_Sequence -> UnaryTripleExpr_Sequence -> Bool
compare :: UnaryTripleExpr_Sequence -> UnaryTripleExpr_Sequence -> Ordering
$ccompare :: UnaryTripleExpr_Sequence -> UnaryTripleExpr_Sequence -> Ordering
Ord, ReadPrec [UnaryTripleExpr_Sequence]
ReadPrec UnaryTripleExpr_Sequence
Int -> ReadS UnaryTripleExpr_Sequence
ReadS [UnaryTripleExpr_Sequence]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [UnaryTripleExpr_Sequence]
$creadListPrec :: ReadPrec [UnaryTripleExpr_Sequence]
readPrec :: ReadPrec UnaryTripleExpr_Sequence
$creadPrec :: ReadPrec UnaryTripleExpr_Sequence
readList :: ReadS [UnaryTripleExpr_Sequence]
$creadList :: ReadS [UnaryTripleExpr_Sequence]
readsPrec :: Int -> ReadS UnaryTripleExpr_Sequence
$creadsPrec :: Int -> ReadS UnaryTripleExpr_Sequence
Read, Int -> UnaryTripleExpr_Sequence -> ShowS
[UnaryTripleExpr_Sequence] -> ShowS
UnaryTripleExpr_Sequence -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [UnaryTripleExpr_Sequence] -> ShowS
$cshowList :: [UnaryTripleExpr_Sequence] -> ShowS
show :: UnaryTripleExpr_Sequence -> String
$cshow :: UnaryTripleExpr_Sequence -> String
showsPrec :: Int -> UnaryTripleExpr_Sequence -> ShowS
$cshowsPrec :: Int -> UnaryTripleExpr_Sequence -> ShowS
Show)

_UnaryTripleExpr_Sequence :: Name
_UnaryTripleExpr_Sequence = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.UnaryTripleExpr.Sequence")

_UnaryTripleExpr_Sequence_sequence :: FieldName
_UnaryTripleExpr_Sequence_sequence = (String -> FieldName
Core.FieldName String
"sequence")

_UnaryTripleExpr_Sequence_alts :: FieldName
_UnaryTripleExpr_Sequence_alts = (String -> FieldName
Core.FieldName String
"alts")

data UnaryTripleExpr_Sequence_Sequence_Option = 
  UnaryTripleExpr_Sequence_Sequence_Option {
    UnaryTripleExpr_Sequence_Sequence_Option -> TripleExprLabel
unaryTripleExpr_Sequence_Sequence_OptionTripleExprLabel :: TripleExprLabel}
  deriving (UnaryTripleExpr_Sequence_Sequence_Option
-> UnaryTripleExpr_Sequence_Sequence_Option -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UnaryTripleExpr_Sequence_Sequence_Option
-> UnaryTripleExpr_Sequence_Sequence_Option -> Bool
$c/= :: UnaryTripleExpr_Sequence_Sequence_Option
-> UnaryTripleExpr_Sequence_Sequence_Option -> Bool
== :: UnaryTripleExpr_Sequence_Sequence_Option
-> UnaryTripleExpr_Sequence_Sequence_Option -> Bool
$c== :: UnaryTripleExpr_Sequence_Sequence_Option
-> UnaryTripleExpr_Sequence_Sequence_Option -> Bool
Eq, Eq UnaryTripleExpr_Sequence_Sequence_Option
UnaryTripleExpr_Sequence_Sequence_Option
-> UnaryTripleExpr_Sequence_Sequence_Option -> Bool
UnaryTripleExpr_Sequence_Sequence_Option
-> UnaryTripleExpr_Sequence_Sequence_Option -> Ordering
UnaryTripleExpr_Sequence_Sequence_Option
-> UnaryTripleExpr_Sequence_Sequence_Option
-> UnaryTripleExpr_Sequence_Sequence_Option
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
min :: UnaryTripleExpr_Sequence_Sequence_Option
-> UnaryTripleExpr_Sequence_Sequence_Option
-> UnaryTripleExpr_Sequence_Sequence_Option
$cmin :: UnaryTripleExpr_Sequence_Sequence_Option
-> UnaryTripleExpr_Sequence_Sequence_Option
-> UnaryTripleExpr_Sequence_Sequence_Option
max :: UnaryTripleExpr_Sequence_Sequence_Option
-> UnaryTripleExpr_Sequence_Sequence_Option
-> UnaryTripleExpr_Sequence_Sequence_Option
$cmax :: UnaryTripleExpr_Sequence_Sequence_Option
-> UnaryTripleExpr_Sequence_Sequence_Option
-> UnaryTripleExpr_Sequence_Sequence_Option
>= :: UnaryTripleExpr_Sequence_Sequence_Option
-> UnaryTripleExpr_Sequence_Sequence_Option -> Bool
$c>= :: UnaryTripleExpr_Sequence_Sequence_Option
-> UnaryTripleExpr_Sequence_Sequence_Option -> Bool
> :: UnaryTripleExpr_Sequence_Sequence_Option
-> UnaryTripleExpr_Sequence_Sequence_Option -> Bool
$c> :: UnaryTripleExpr_Sequence_Sequence_Option
-> UnaryTripleExpr_Sequence_Sequence_Option -> Bool
<= :: UnaryTripleExpr_Sequence_Sequence_Option
-> UnaryTripleExpr_Sequence_Sequence_Option -> Bool
$c<= :: UnaryTripleExpr_Sequence_Sequence_Option
-> UnaryTripleExpr_Sequence_Sequence_Option -> Bool
< :: UnaryTripleExpr_Sequence_Sequence_Option
-> UnaryTripleExpr_Sequence_Sequence_Option -> Bool
$c< :: UnaryTripleExpr_Sequence_Sequence_Option
-> UnaryTripleExpr_Sequence_Sequence_Option -> Bool
compare :: UnaryTripleExpr_Sequence_Sequence_Option
-> UnaryTripleExpr_Sequence_Sequence_Option -> Ordering
$ccompare :: UnaryTripleExpr_Sequence_Sequence_Option
-> UnaryTripleExpr_Sequence_Sequence_Option -> Ordering
Ord, ReadPrec [UnaryTripleExpr_Sequence_Sequence_Option]
ReadPrec UnaryTripleExpr_Sequence_Sequence_Option
Int -> ReadS UnaryTripleExpr_Sequence_Sequence_Option
ReadS [UnaryTripleExpr_Sequence_Sequence_Option]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [UnaryTripleExpr_Sequence_Sequence_Option]
$creadListPrec :: ReadPrec [UnaryTripleExpr_Sequence_Sequence_Option]
readPrec :: ReadPrec UnaryTripleExpr_Sequence_Sequence_Option
$creadPrec :: ReadPrec UnaryTripleExpr_Sequence_Sequence_Option
readList :: ReadS [UnaryTripleExpr_Sequence_Sequence_Option]
$creadList :: ReadS [UnaryTripleExpr_Sequence_Sequence_Option]
readsPrec :: Int -> ReadS UnaryTripleExpr_Sequence_Sequence_Option
$creadsPrec :: Int -> ReadS UnaryTripleExpr_Sequence_Sequence_Option
Read, Int -> UnaryTripleExpr_Sequence_Sequence_Option -> ShowS
[UnaryTripleExpr_Sequence_Sequence_Option] -> ShowS
UnaryTripleExpr_Sequence_Sequence_Option -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [UnaryTripleExpr_Sequence_Sequence_Option] -> ShowS
$cshowList :: [UnaryTripleExpr_Sequence_Sequence_Option] -> ShowS
show :: UnaryTripleExpr_Sequence_Sequence_Option -> String
$cshow :: UnaryTripleExpr_Sequence_Sequence_Option -> String
showsPrec :: Int -> UnaryTripleExpr_Sequence_Sequence_Option -> ShowS
$cshowsPrec :: Int -> UnaryTripleExpr_Sequence_Sequence_Option -> ShowS
Show)

_UnaryTripleExpr_Sequence_Sequence_Option :: Name
_UnaryTripleExpr_Sequence_Sequence_Option = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.UnaryTripleExpr.Sequence.Sequence.Option")

_UnaryTripleExpr_Sequence_Sequence_Option_tripleExprLabel :: FieldName
_UnaryTripleExpr_Sequence_Sequence_Option_tripleExprLabel = (String -> FieldName
Core.FieldName String
"tripleExprLabel")

data UnaryTripleExpr_Sequence_Alts = 
  UnaryTripleExpr_Sequence_AltsTripleConstraint TripleConstraint |
  UnaryTripleExpr_Sequence_AltsBracketedTripleExpr BracketedTripleExpr
  deriving (UnaryTripleExpr_Sequence_Alts
-> UnaryTripleExpr_Sequence_Alts -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UnaryTripleExpr_Sequence_Alts
-> UnaryTripleExpr_Sequence_Alts -> Bool
$c/= :: UnaryTripleExpr_Sequence_Alts
-> UnaryTripleExpr_Sequence_Alts -> Bool
== :: UnaryTripleExpr_Sequence_Alts
-> UnaryTripleExpr_Sequence_Alts -> Bool
$c== :: UnaryTripleExpr_Sequence_Alts
-> UnaryTripleExpr_Sequence_Alts -> Bool
Eq, Eq UnaryTripleExpr_Sequence_Alts
UnaryTripleExpr_Sequence_Alts
-> UnaryTripleExpr_Sequence_Alts -> Bool
UnaryTripleExpr_Sequence_Alts
-> UnaryTripleExpr_Sequence_Alts -> Ordering
UnaryTripleExpr_Sequence_Alts
-> UnaryTripleExpr_Sequence_Alts -> UnaryTripleExpr_Sequence_Alts
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
min :: UnaryTripleExpr_Sequence_Alts
-> UnaryTripleExpr_Sequence_Alts -> UnaryTripleExpr_Sequence_Alts
$cmin :: UnaryTripleExpr_Sequence_Alts
-> UnaryTripleExpr_Sequence_Alts -> UnaryTripleExpr_Sequence_Alts
max :: UnaryTripleExpr_Sequence_Alts
-> UnaryTripleExpr_Sequence_Alts -> UnaryTripleExpr_Sequence_Alts
$cmax :: UnaryTripleExpr_Sequence_Alts
-> UnaryTripleExpr_Sequence_Alts -> UnaryTripleExpr_Sequence_Alts
>= :: UnaryTripleExpr_Sequence_Alts
-> UnaryTripleExpr_Sequence_Alts -> Bool
$c>= :: UnaryTripleExpr_Sequence_Alts
-> UnaryTripleExpr_Sequence_Alts -> Bool
> :: UnaryTripleExpr_Sequence_Alts
-> UnaryTripleExpr_Sequence_Alts -> Bool
$c> :: UnaryTripleExpr_Sequence_Alts
-> UnaryTripleExpr_Sequence_Alts -> Bool
<= :: UnaryTripleExpr_Sequence_Alts
-> UnaryTripleExpr_Sequence_Alts -> Bool
$c<= :: UnaryTripleExpr_Sequence_Alts
-> UnaryTripleExpr_Sequence_Alts -> Bool
< :: UnaryTripleExpr_Sequence_Alts
-> UnaryTripleExpr_Sequence_Alts -> Bool
$c< :: UnaryTripleExpr_Sequence_Alts
-> UnaryTripleExpr_Sequence_Alts -> Bool
compare :: UnaryTripleExpr_Sequence_Alts
-> UnaryTripleExpr_Sequence_Alts -> Ordering
$ccompare :: UnaryTripleExpr_Sequence_Alts
-> UnaryTripleExpr_Sequence_Alts -> Ordering
Ord, ReadPrec [UnaryTripleExpr_Sequence_Alts]
ReadPrec UnaryTripleExpr_Sequence_Alts
Int -> ReadS UnaryTripleExpr_Sequence_Alts
ReadS [UnaryTripleExpr_Sequence_Alts]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [UnaryTripleExpr_Sequence_Alts]
$creadListPrec :: ReadPrec [UnaryTripleExpr_Sequence_Alts]
readPrec :: ReadPrec UnaryTripleExpr_Sequence_Alts
$creadPrec :: ReadPrec UnaryTripleExpr_Sequence_Alts
readList :: ReadS [UnaryTripleExpr_Sequence_Alts]
$creadList :: ReadS [UnaryTripleExpr_Sequence_Alts]
readsPrec :: Int -> ReadS UnaryTripleExpr_Sequence_Alts
$creadsPrec :: Int -> ReadS UnaryTripleExpr_Sequence_Alts
Read, Int -> UnaryTripleExpr_Sequence_Alts -> ShowS
[UnaryTripleExpr_Sequence_Alts] -> ShowS
UnaryTripleExpr_Sequence_Alts -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [UnaryTripleExpr_Sequence_Alts] -> ShowS
$cshowList :: [UnaryTripleExpr_Sequence_Alts] -> ShowS
show :: UnaryTripleExpr_Sequence_Alts -> String
$cshow :: UnaryTripleExpr_Sequence_Alts -> String
showsPrec :: Int -> UnaryTripleExpr_Sequence_Alts -> ShowS
$cshowsPrec :: Int -> UnaryTripleExpr_Sequence_Alts -> ShowS
Show)

_UnaryTripleExpr_Sequence_Alts :: Name
_UnaryTripleExpr_Sequence_Alts = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.UnaryTripleExpr.Sequence.Alts")

_UnaryTripleExpr_Sequence_Alts_tripleConstraint :: FieldName
_UnaryTripleExpr_Sequence_Alts_tripleConstraint = (String -> FieldName
Core.FieldName String
"tripleConstraint")

_UnaryTripleExpr_Sequence_Alts_bracketedTripleExpr :: FieldName
_UnaryTripleExpr_Sequence_Alts_bracketedTripleExpr = (String -> FieldName
Core.FieldName String
"bracketedTripleExpr")

data BracketedTripleExpr = 
  BracketedTripleExpr {
    BracketedTripleExpr -> InnerTripleExpr
bracketedTripleExprInnerTripleExpr :: InnerTripleExpr,
    BracketedTripleExpr -> Maybe Cardinality
bracketedTripleExprCardinality :: (Maybe Cardinality),
    BracketedTripleExpr -> [Annotation]
bracketedTripleExprListOfAnnotation :: [Annotation],
    BracketedTripleExpr -> SemanticActions
bracketedTripleExprSemanticActions :: SemanticActions}
  deriving (BracketedTripleExpr -> BracketedTripleExpr -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BracketedTripleExpr -> BracketedTripleExpr -> Bool
$c/= :: BracketedTripleExpr -> BracketedTripleExpr -> Bool
== :: BracketedTripleExpr -> BracketedTripleExpr -> Bool
$c== :: BracketedTripleExpr -> BracketedTripleExpr -> Bool
Eq, Eq BracketedTripleExpr
BracketedTripleExpr -> BracketedTripleExpr -> Bool
BracketedTripleExpr -> BracketedTripleExpr -> Ordering
BracketedTripleExpr -> BracketedTripleExpr -> BracketedTripleExpr
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
min :: BracketedTripleExpr -> BracketedTripleExpr -> BracketedTripleExpr
$cmin :: BracketedTripleExpr -> BracketedTripleExpr -> BracketedTripleExpr
max :: BracketedTripleExpr -> BracketedTripleExpr -> BracketedTripleExpr
$cmax :: BracketedTripleExpr -> BracketedTripleExpr -> BracketedTripleExpr
>= :: BracketedTripleExpr -> BracketedTripleExpr -> Bool
$c>= :: BracketedTripleExpr -> BracketedTripleExpr -> Bool
> :: BracketedTripleExpr -> BracketedTripleExpr -> Bool
$c> :: BracketedTripleExpr -> BracketedTripleExpr -> Bool
<= :: BracketedTripleExpr -> BracketedTripleExpr -> Bool
$c<= :: BracketedTripleExpr -> BracketedTripleExpr -> Bool
< :: BracketedTripleExpr -> BracketedTripleExpr -> Bool
$c< :: BracketedTripleExpr -> BracketedTripleExpr -> Bool
compare :: BracketedTripleExpr -> BracketedTripleExpr -> Ordering
$ccompare :: BracketedTripleExpr -> BracketedTripleExpr -> Ordering
Ord, ReadPrec [BracketedTripleExpr]
ReadPrec BracketedTripleExpr
Int -> ReadS BracketedTripleExpr
ReadS [BracketedTripleExpr]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [BracketedTripleExpr]
$creadListPrec :: ReadPrec [BracketedTripleExpr]
readPrec :: ReadPrec BracketedTripleExpr
$creadPrec :: ReadPrec BracketedTripleExpr
readList :: ReadS [BracketedTripleExpr]
$creadList :: ReadS [BracketedTripleExpr]
readsPrec :: Int -> ReadS BracketedTripleExpr
$creadsPrec :: Int -> ReadS BracketedTripleExpr
Read, Int -> BracketedTripleExpr -> ShowS
[BracketedTripleExpr] -> ShowS
BracketedTripleExpr -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BracketedTripleExpr] -> ShowS
$cshowList :: [BracketedTripleExpr] -> ShowS
show :: BracketedTripleExpr -> String
$cshow :: BracketedTripleExpr -> String
showsPrec :: Int -> BracketedTripleExpr -> ShowS
$cshowsPrec :: Int -> BracketedTripleExpr -> ShowS
Show)

_BracketedTripleExpr :: Name
_BracketedTripleExpr = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.BracketedTripleExpr")

_BracketedTripleExpr_innerTripleExpr :: FieldName
_BracketedTripleExpr_innerTripleExpr = (String -> FieldName
Core.FieldName String
"innerTripleExpr")

_BracketedTripleExpr_cardinality :: FieldName
_BracketedTripleExpr_cardinality = (String -> FieldName
Core.FieldName String
"cardinality")

_BracketedTripleExpr_listOfAnnotation :: FieldName
_BracketedTripleExpr_listOfAnnotation = (String -> FieldName
Core.FieldName String
"listOfAnnotation")

_BracketedTripleExpr_semanticActions :: FieldName
_BracketedTripleExpr_semanticActions = (String -> FieldName
Core.FieldName String
"semanticActions")

data TripleConstraint = 
  TripleConstraint {
    TripleConstraint -> Maybe SenseFlags
tripleConstraintSenseFlags :: (Maybe SenseFlags),
    TripleConstraint -> Predicate
tripleConstraintPredicate :: Predicate,
    TripleConstraint -> InlineShapeExpression
tripleConstraintInlineShapeExpression :: InlineShapeExpression,
    TripleConstraint -> Maybe Cardinality
tripleConstraintCardinality :: (Maybe Cardinality),
    TripleConstraint -> [Annotation]
tripleConstraintListOfAnnotation :: [Annotation],
    TripleConstraint -> SemanticActions
tripleConstraintSemanticActions :: SemanticActions}
  deriving (TripleConstraint -> TripleConstraint -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TripleConstraint -> TripleConstraint -> Bool
$c/= :: TripleConstraint -> TripleConstraint -> Bool
== :: TripleConstraint -> TripleConstraint -> Bool
$c== :: TripleConstraint -> TripleConstraint -> Bool
Eq, Eq TripleConstraint
TripleConstraint -> TripleConstraint -> Bool
TripleConstraint -> TripleConstraint -> Ordering
TripleConstraint -> TripleConstraint -> TripleConstraint
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
min :: TripleConstraint -> TripleConstraint -> TripleConstraint
$cmin :: TripleConstraint -> TripleConstraint -> TripleConstraint
max :: TripleConstraint -> TripleConstraint -> TripleConstraint
$cmax :: TripleConstraint -> TripleConstraint -> TripleConstraint
>= :: TripleConstraint -> TripleConstraint -> Bool
$c>= :: TripleConstraint -> TripleConstraint -> Bool
> :: TripleConstraint -> TripleConstraint -> Bool
$c> :: TripleConstraint -> TripleConstraint -> Bool
<= :: TripleConstraint -> TripleConstraint -> Bool
$c<= :: TripleConstraint -> TripleConstraint -> Bool
< :: TripleConstraint -> TripleConstraint -> Bool
$c< :: TripleConstraint -> TripleConstraint -> Bool
compare :: TripleConstraint -> TripleConstraint -> Ordering
$ccompare :: TripleConstraint -> TripleConstraint -> Ordering
Ord, ReadPrec [TripleConstraint]
ReadPrec TripleConstraint
Int -> ReadS TripleConstraint
ReadS [TripleConstraint]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [TripleConstraint]
$creadListPrec :: ReadPrec [TripleConstraint]
readPrec :: ReadPrec TripleConstraint
$creadPrec :: ReadPrec TripleConstraint
readList :: ReadS [TripleConstraint]
$creadList :: ReadS [TripleConstraint]
readsPrec :: Int -> ReadS TripleConstraint
$creadsPrec :: Int -> ReadS TripleConstraint
Read, Int -> TripleConstraint -> ShowS
[TripleConstraint] -> ShowS
TripleConstraint -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TripleConstraint] -> ShowS
$cshowList :: [TripleConstraint] -> ShowS
show :: TripleConstraint -> String
$cshow :: TripleConstraint -> String
showsPrec :: Int -> TripleConstraint -> ShowS
$cshowsPrec :: Int -> TripleConstraint -> ShowS
Show)

_TripleConstraint :: Name
_TripleConstraint = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.TripleConstraint")

_TripleConstraint_senseFlags :: FieldName
_TripleConstraint_senseFlags = (String -> FieldName
Core.FieldName String
"senseFlags")

_TripleConstraint_predicate :: FieldName
_TripleConstraint_predicate = (String -> FieldName
Core.FieldName String
"predicate")

_TripleConstraint_inlineShapeExpression :: FieldName
_TripleConstraint_inlineShapeExpression = (String -> FieldName
Core.FieldName String
"inlineShapeExpression")

_TripleConstraint_cardinality :: FieldName
_TripleConstraint_cardinality = (String -> FieldName
Core.FieldName String
"cardinality")

_TripleConstraint_listOfAnnotation :: FieldName
_TripleConstraint_listOfAnnotation = (String -> FieldName
Core.FieldName String
"listOfAnnotation")

_TripleConstraint_semanticActions :: FieldName
_TripleConstraint_semanticActions = (String -> FieldName
Core.FieldName String
"semanticActions")

data Cardinality = 
  CardinalityAst  |
  CardinalityPlus  |
  CardinalityQuest  |
  CardinalityRepeatRange RepeatRange
  deriving (Cardinality -> Cardinality -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Cardinality -> Cardinality -> Bool
$c/= :: Cardinality -> Cardinality -> Bool
== :: Cardinality -> Cardinality -> Bool
$c== :: Cardinality -> Cardinality -> Bool
Eq, Eq Cardinality
Cardinality -> Cardinality -> Bool
Cardinality -> Cardinality -> Ordering
Cardinality -> Cardinality -> Cardinality
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
min :: Cardinality -> Cardinality -> Cardinality
$cmin :: Cardinality -> Cardinality -> Cardinality
max :: Cardinality -> Cardinality -> Cardinality
$cmax :: Cardinality -> Cardinality -> Cardinality
>= :: Cardinality -> Cardinality -> Bool
$c>= :: Cardinality -> Cardinality -> Bool
> :: Cardinality -> Cardinality -> Bool
$c> :: Cardinality -> Cardinality -> Bool
<= :: Cardinality -> Cardinality -> Bool
$c<= :: Cardinality -> Cardinality -> Bool
< :: Cardinality -> Cardinality -> Bool
$c< :: Cardinality -> Cardinality -> Bool
compare :: Cardinality -> Cardinality -> Ordering
$ccompare :: Cardinality -> Cardinality -> Ordering
Ord, ReadPrec [Cardinality]
ReadPrec Cardinality
Int -> ReadS Cardinality
ReadS [Cardinality]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Cardinality]
$creadListPrec :: ReadPrec [Cardinality]
readPrec :: ReadPrec Cardinality
$creadPrec :: ReadPrec Cardinality
readList :: ReadS [Cardinality]
$creadList :: ReadS [Cardinality]
readsPrec :: Int -> ReadS Cardinality
$creadsPrec :: Int -> ReadS Cardinality
Read, Int -> Cardinality -> ShowS
[Cardinality] -> ShowS
Cardinality -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Cardinality] -> ShowS
$cshowList :: [Cardinality] -> ShowS
show :: Cardinality -> String
$cshow :: Cardinality -> String
showsPrec :: Int -> Cardinality -> ShowS
$cshowsPrec :: Int -> Cardinality -> ShowS
Show)

_Cardinality :: Name
_Cardinality = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.Cardinality")

_Cardinality_ast :: FieldName
_Cardinality_ast = (String -> FieldName
Core.FieldName String
"ast")

_Cardinality_plus :: FieldName
_Cardinality_plus = (String -> FieldName
Core.FieldName String
"plus")

_Cardinality_quest :: FieldName
_Cardinality_quest = (String -> FieldName
Core.FieldName String
"quest")

_Cardinality_repeatRange :: FieldName
_Cardinality_repeatRange = (String -> FieldName
Core.FieldName String
"repeatRange")

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

_SenseFlags :: Name
_SenseFlags = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.SenseFlags")

data ValueSet = 
  ValueSet {
    ValueSet -> [ValueSetValue]
valueSetListOfValueSetValue :: [ValueSetValue]}
  deriving (ValueSet -> ValueSet -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ValueSet -> ValueSet -> Bool
$c/= :: ValueSet -> ValueSet -> Bool
== :: ValueSet -> ValueSet -> Bool
$c== :: ValueSet -> ValueSet -> Bool
Eq, Eq ValueSet
ValueSet -> ValueSet -> Bool
ValueSet -> ValueSet -> Ordering
ValueSet -> ValueSet -> ValueSet
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
min :: ValueSet -> ValueSet -> ValueSet
$cmin :: ValueSet -> ValueSet -> ValueSet
max :: ValueSet -> ValueSet -> ValueSet
$cmax :: ValueSet -> ValueSet -> ValueSet
>= :: ValueSet -> ValueSet -> Bool
$c>= :: ValueSet -> ValueSet -> Bool
> :: ValueSet -> ValueSet -> Bool
$c> :: ValueSet -> ValueSet -> Bool
<= :: ValueSet -> ValueSet -> Bool
$c<= :: ValueSet -> ValueSet -> Bool
< :: ValueSet -> ValueSet -> Bool
$c< :: ValueSet -> ValueSet -> Bool
compare :: ValueSet -> ValueSet -> Ordering
$ccompare :: ValueSet -> ValueSet -> Ordering
Ord, ReadPrec [ValueSet]
ReadPrec ValueSet
Int -> ReadS ValueSet
ReadS [ValueSet]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ValueSet]
$creadListPrec :: ReadPrec [ValueSet]
readPrec :: ReadPrec ValueSet
$creadPrec :: ReadPrec ValueSet
readList :: ReadS [ValueSet]
$creadList :: ReadS [ValueSet]
readsPrec :: Int -> ReadS ValueSet
$creadsPrec :: Int -> ReadS ValueSet
Read, Int -> ValueSet -> ShowS
[ValueSet] -> ShowS
ValueSet -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ValueSet] -> ShowS
$cshowList :: [ValueSet] -> ShowS
show :: ValueSet -> String
$cshow :: ValueSet -> String
showsPrec :: Int -> ValueSet -> ShowS
$cshowsPrec :: Int -> ValueSet -> ShowS
Show)

_ValueSet :: Name
_ValueSet = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.ValueSet")

_ValueSet_listOfValueSetValue :: FieldName
_ValueSet_listOfValueSetValue = (String -> FieldName
Core.FieldName String
"listOfValueSetValue")

data ValueSetValue = 
  ValueSetValueIriRange IriRange |
  ValueSetValueLiteral Literal
  deriving (ValueSetValue -> ValueSetValue -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ValueSetValue -> ValueSetValue -> Bool
$c/= :: ValueSetValue -> ValueSetValue -> Bool
== :: ValueSetValue -> ValueSetValue -> Bool
$c== :: ValueSetValue -> ValueSetValue -> Bool
Eq, Eq ValueSetValue
ValueSetValue -> ValueSetValue -> Bool
ValueSetValue -> ValueSetValue -> Ordering
ValueSetValue -> ValueSetValue -> ValueSetValue
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
min :: ValueSetValue -> ValueSetValue -> ValueSetValue
$cmin :: ValueSetValue -> ValueSetValue -> ValueSetValue
max :: ValueSetValue -> ValueSetValue -> ValueSetValue
$cmax :: ValueSetValue -> ValueSetValue -> ValueSetValue
>= :: ValueSetValue -> ValueSetValue -> Bool
$c>= :: ValueSetValue -> ValueSetValue -> Bool
> :: ValueSetValue -> ValueSetValue -> Bool
$c> :: ValueSetValue -> ValueSetValue -> Bool
<= :: ValueSetValue -> ValueSetValue -> Bool
$c<= :: ValueSetValue -> ValueSetValue -> Bool
< :: ValueSetValue -> ValueSetValue -> Bool
$c< :: ValueSetValue -> ValueSetValue -> Bool
compare :: ValueSetValue -> ValueSetValue -> Ordering
$ccompare :: ValueSetValue -> ValueSetValue -> Ordering
Ord, ReadPrec [ValueSetValue]
ReadPrec ValueSetValue
Int -> ReadS ValueSetValue
ReadS [ValueSetValue]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ValueSetValue]
$creadListPrec :: ReadPrec [ValueSetValue]
readPrec :: ReadPrec ValueSetValue
$creadPrec :: ReadPrec ValueSetValue
readList :: ReadS [ValueSetValue]
$creadList :: ReadS [ValueSetValue]
readsPrec :: Int -> ReadS ValueSetValue
$creadsPrec :: Int -> ReadS ValueSetValue
Read, Int -> ValueSetValue -> ShowS
[ValueSetValue] -> ShowS
ValueSetValue -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ValueSetValue] -> ShowS
$cshowList :: [ValueSetValue] -> ShowS
show :: ValueSetValue -> String
$cshow :: ValueSetValue -> String
showsPrec :: Int -> ValueSetValue -> ShowS
$cshowsPrec :: Int -> ValueSetValue -> ShowS
Show)

_ValueSetValue :: Name
_ValueSetValue = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.ValueSetValue")

_ValueSetValue_iriRange :: FieldName
_ValueSetValue_iriRange = (String -> FieldName
Core.FieldName String
"iriRange")

_ValueSetValue_literal :: FieldName
_ValueSetValue_literal = (String -> FieldName
Core.FieldName String
"literal")

data IriRange = 
  IriRangeSequence IriRange_Sequence |
  IriRangeSequence2 IriRange_Sequence2
  deriving (IriRange -> IriRange -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: IriRange -> IriRange -> Bool
$c/= :: IriRange -> IriRange -> Bool
== :: IriRange -> IriRange -> Bool
$c== :: IriRange -> IriRange -> Bool
Eq, Eq IriRange
IriRange -> IriRange -> Bool
IriRange -> IriRange -> Ordering
IriRange -> IriRange -> IriRange
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
min :: IriRange -> IriRange -> IriRange
$cmin :: IriRange -> IriRange -> IriRange
max :: IriRange -> IriRange -> IriRange
$cmax :: IriRange -> IriRange -> IriRange
>= :: IriRange -> IriRange -> Bool
$c>= :: IriRange -> IriRange -> Bool
> :: IriRange -> IriRange -> Bool
$c> :: IriRange -> IriRange -> Bool
<= :: IriRange -> IriRange -> Bool
$c<= :: IriRange -> IriRange -> Bool
< :: IriRange -> IriRange -> Bool
$c< :: IriRange -> IriRange -> Bool
compare :: IriRange -> IriRange -> Ordering
$ccompare :: IriRange -> IriRange -> Ordering
Ord, ReadPrec [IriRange]
ReadPrec IriRange
Int -> ReadS IriRange
ReadS [IriRange]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [IriRange]
$creadListPrec :: ReadPrec [IriRange]
readPrec :: ReadPrec IriRange
$creadPrec :: ReadPrec IriRange
readList :: ReadS [IriRange]
$creadList :: ReadS [IriRange]
readsPrec :: Int -> ReadS IriRange
$creadsPrec :: Int -> ReadS IriRange
Read, Int -> IriRange -> ShowS
[IriRange] -> ShowS
IriRange -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [IriRange] -> ShowS
$cshowList :: [IriRange] -> ShowS
show :: IriRange -> String
$cshow :: IriRange -> String
showsPrec :: Int -> IriRange -> ShowS
$cshowsPrec :: Int -> IriRange -> ShowS
Show)

_IriRange :: Name
_IriRange = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.IriRange")

_IriRange_sequence :: FieldName
_IriRange_sequence = (String -> FieldName
Core.FieldName String
"sequence")

_IriRange_sequence2 :: FieldName
_IriRange_sequence2 = (String -> FieldName
Core.FieldName String
"sequence2")

data IriRange_Sequence = 
  IriRange_Sequence {
    IriRange_Sequence -> Iri
iriRange_SequenceIri :: Iri,
    IriRange_Sequence -> Maybe IriRange_Sequence_Sequence_Option
iriRange_SequenceSequence :: (Maybe IriRange_Sequence_Sequence_Option)}
  deriving (IriRange_Sequence -> IriRange_Sequence -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: IriRange_Sequence -> IriRange_Sequence -> Bool
$c/= :: IriRange_Sequence -> IriRange_Sequence -> Bool
== :: IriRange_Sequence -> IriRange_Sequence -> Bool
$c== :: IriRange_Sequence -> IriRange_Sequence -> Bool
Eq, Eq IriRange_Sequence
IriRange_Sequence -> IriRange_Sequence -> Bool
IriRange_Sequence -> IriRange_Sequence -> Ordering
IriRange_Sequence -> IriRange_Sequence -> IriRange_Sequence
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
min :: IriRange_Sequence -> IriRange_Sequence -> IriRange_Sequence
$cmin :: IriRange_Sequence -> IriRange_Sequence -> IriRange_Sequence
max :: IriRange_Sequence -> IriRange_Sequence -> IriRange_Sequence
$cmax :: IriRange_Sequence -> IriRange_Sequence -> IriRange_Sequence
>= :: IriRange_Sequence -> IriRange_Sequence -> Bool
$c>= :: IriRange_Sequence -> IriRange_Sequence -> Bool
> :: IriRange_Sequence -> IriRange_Sequence -> Bool
$c> :: IriRange_Sequence -> IriRange_Sequence -> Bool
<= :: IriRange_Sequence -> IriRange_Sequence -> Bool
$c<= :: IriRange_Sequence -> IriRange_Sequence -> Bool
< :: IriRange_Sequence -> IriRange_Sequence -> Bool
$c< :: IriRange_Sequence -> IriRange_Sequence -> Bool
compare :: IriRange_Sequence -> IriRange_Sequence -> Ordering
$ccompare :: IriRange_Sequence -> IriRange_Sequence -> Ordering
Ord, ReadPrec [IriRange_Sequence]
ReadPrec IriRange_Sequence
Int -> ReadS IriRange_Sequence
ReadS [IriRange_Sequence]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [IriRange_Sequence]
$creadListPrec :: ReadPrec [IriRange_Sequence]
readPrec :: ReadPrec IriRange_Sequence
$creadPrec :: ReadPrec IriRange_Sequence
readList :: ReadS [IriRange_Sequence]
$creadList :: ReadS [IriRange_Sequence]
readsPrec :: Int -> ReadS IriRange_Sequence
$creadsPrec :: Int -> ReadS IriRange_Sequence
Read, Int -> IriRange_Sequence -> ShowS
[IriRange_Sequence] -> ShowS
IriRange_Sequence -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [IriRange_Sequence] -> ShowS
$cshowList :: [IriRange_Sequence] -> ShowS
show :: IriRange_Sequence -> String
$cshow :: IriRange_Sequence -> String
showsPrec :: Int -> IriRange_Sequence -> ShowS
$cshowsPrec :: Int -> IriRange_Sequence -> ShowS
Show)

_IriRange_Sequence :: Name
_IriRange_Sequence = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.IriRange.Sequence")

_IriRange_Sequence_iri :: FieldName
_IriRange_Sequence_iri = (String -> FieldName
Core.FieldName String
"iri")

_IriRange_Sequence_sequence :: FieldName
_IriRange_Sequence_sequence = (String -> FieldName
Core.FieldName String
"sequence")

data IriRange_Sequence_Sequence_Option = 
  IriRange_Sequence_Sequence_Option {
    IriRange_Sequence_Sequence_Option -> [Exclusion]
iriRange_Sequence_Sequence_OptionListOfExclusion :: [Exclusion]}
  deriving (IriRange_Sequence_Sequence_Option
-> IriRange_Sequence_Sequence_Option -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: IriRange_Sequence_Sequence_Option
-> IriRange_Sequence_Sequence_Option -> Bool
$c/= :: IriRange_Sequence_Sequence_Option
-> IriRange_Sequence_Sequence_Option -> Bool
== :: IriRange_Sequence_Sequence_Option
-> IriRange_Sequence_Sequence_Option -> Bool
$c== :: IriRange_Sequence_Sequence_Option
-> IriRange_Sequence_Sequence_Option -> Bool
Eq, Eq IriRange_Sequence_Sequence_Option
IriRange_Sequence_Sequence_Option
-> IriRange_Sequence_Sequence_Option -> Bool
IriRange_Sequence_Sequence_Option
-> IriRange_Sequence_Sequence_Option -> Ordering
IriRange_Sequence_Sequence_Option
-> IriRange_Sequence_Sequence_Option
-> IriRange_Sequence_Sequence_Option
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
min :: IriRange_Sequence_Sequence_Option
-> IriRange_Sequence_Sequence_Option
-> IriRange_Sequence_Sequence_Option
$cmin :: IriRange_Sequence_Sequence_Option
-> IriRange_Sequence_Sequence_Option
-> IriRange_Sequence_Sequence_Option
max :: IriRange_Sequence_Sequence_Option
-> IriRange_Sequence_Sequence_Option
-> IriRange_Sequence_Sequence_Option
$cmax :: IriRange_Sequence_Sequence_Option
-> IriRange_Sequence_Sequence_Option
-> IriRange_Sequence_Sequence_Option
>= :: IriRange_Sequence_Sequence_Option
-> IriRange_Sequence_Sequence_Option -> Bool
$c>= :: IriRange_Sequence_Sequence_Option
-> IriRange_Sequence_Sequence_Option -> Bool
> :: IriRange_Sequence_Sequence_Option
-> IriRange_Sequence_Sequence_Option -> Bool
$c> :: IriRange_Sequence_Sequence_Option
-> IriRange_Sequence_Sequence_Option -> Bool
<= :: IriRange_Sequence_Sequence_Option
-> IriRange_Sequence_Sequence_Option -> Bool
$c<= :: IriRange_Sequence_Sequence_Option
-> IriRange_Sequence_Sequence_Option -> Bool
< :: IriRange_Sequence_Sequence_Option
-> IriRange_Sequence_Sequence_Option -> Bool
$c< :: IriRange_Sequence_Sequence_Option
-> IriRange_Sequence_Sequence_Option -> Bool
compare :: IriRange_Sequence_Sequence_Option
-> IriRange_Sequence_Sequence_Option -> Ordering
$ccompare :: IriRange_Sequence_Sequence_Option
-> IriRange_Sequence_Sequence_Option -> Ordering
Ord, ReadPrec [IriRange_Sequence_Sequence_Option]
ReadPrec IriRange_Sequence_Sequence_Option
Int -> ReadS IriRange_Sequence_Sequence_Option
ReadS [IriRange_Sequence_Sequence_Option]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [IriRange_Sequence_Sequence_Option]
$creadListPrec :: ReadPrec [IriRange_Sequence_Sequence_Option]
readPrec :: ReadPrec IriRange_Sequence_Sequence_Option
$creadPrec :: ReadPrec IriRange_Sequence_Sequence_Option
readList :: ReadS [IriRange_Sequence_Sequence_Option]
$creadList :: ReadS [IriRange_Sequence_Sequence_Option]
readsPrec :: Int -> ReadS IriRange_Sequence_Sequence_Option
$creadsPrec :: Int -> ReadS IriRange_Sequence_Sequence_Option
Read, Int -> IriRange_Sequence_Sequence_Option -> ShowS
[IriRange_Sequence_Sequence_Option] -> ShowS
IriRange_Sequence_Sequence_Option -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [IriRange_Sequence_Sequence_Option] -> ShowS
$cshowList :: [IriRange_Sequence_Sequence_Option] -> ShowS
show :: IriRange_Sequence_Sequence_Option -> String
$cshow :: IriRange_Sequence_Sequence_Option -> String
showsPrec :: Int -> IriRange_Sequence_Sequence_Option -> ShowS
$cshowsPrec :: Int -> IriRange_Sequence_Sequence_Option -> ShowS
Show)

_IriRange_Sequence_Sequence_Option :: Name
_IriRange_Sequence_Sequence_Option = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.IriRange.Sequence.Sequence.Option")

_IriRange_Sequence_Sequence_Option_listOfExclusion :: FieldName
_IriRange_Sequence_Sequence_Option_listOfExclusion = (String -> FieldName
Core.FieldName String
"listOfExclusion")

data IriRange_Sequence2 = 
  IriRange_Sequence2 {
    IriRange_Sequence2 -> [Exclusion]
iriRange_Sequence2ListOfExclusion :: [Exclusion]}
  deriving (IriRange_Sequence2 -> IriRange_Sequence2 -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: IriRange_Sequence2 -> IriRange_Sequence2 -> Bool
$c/= :: IriRange_Sequence2 -> IriRange_Sequence2 -> Bool
== :: IriRange_Sequence2 -> IriRange_Sequence2 -> Bool
$c== :: IriRange_Sequence2 -> IriRange_Sequence2 -> Bool
Eq, Eq IriRange_Sequence2
IriRange_Sequence2 -> IriRange_Sequence2 -> Bool
IriRange_Sequence2 -> IriRange_Sequence2 -> Ordering
IriRange_Sequence2 -> IriRange_Sequence2 -> IriRange_Sequence2
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
min :: IriRange_Sequence2 -> IriRange_Sequence2 -> IriRange_Sequence2
$cmin :: IriRange_Sequence2 -> IriRange_Sequence2 -> IriRange_Sequence2
max :: IriRange_Sequence2 -> IriRange_Sequence2 -> IriRange_Sequence2
$cmax :: IriRange_Sequence2 -> IriRange_Sequence2 -> IriRange_Sequence2
>= :: IriRange_Sequence2 -> IriRange_Sequence2 -> Bool
$c>= :: IriRange_Sequence2 -> IriRange_Sequence2 -> Bool
> :: IriRange_Sequence2 -> IriRange_Sequence2 -> Bool
$c> :: IriRange_Sequence2 -> IriRange_Sequence2 -> Bool
<= :: IriRange_Sequence2 -> IriRange_Sequence2 -> Bool
$c<= :: IriRange_Sequence2 -> IriRange_Sequence2 -> Bool
< :: IriRange_Sequence2 -> IriRange_Sequence2 -> Bool
$c< :: IriRange_Sequence2 -> IriRange_Sequence2 -> Bool
compare :: IriRange_Sequence2 -> IriRange_Sequence2 -> Ordering
$ccompare :: IriRange_Sequence2 -> IriRange_Sequence2 -> Ordering
Ord, ReadPrec [IriRange_Sequence2]
ReadPrec IriRange_Sequence2
Int -> ReadS IriRange_Sequence2
ReadS [IriRange_Sequence2]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [IriRange_Sequence2]
$creadListPrec :: ReadPrec [IriRange_Sequence2]
readPrec :: ReadPrec IriRange_Sequence2
$creadPrec :: ReadPrec IriRange_Sequence2
readList :: ReadS [IriRange_Sequence2]
$creadList :: ReadS [IriRange_Sequence2]
readsPrec :: Int -> ReadS IriRange_Sequence2
$creadsPrec :: Int -> ReadS IriRange_Sequence2
Read, Int -> IriRange_Sequence2 -> ShowS
[IriRange_Sequence2] -> ShowS
IriRange_Sequence2 -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [IriRange_Sequence2] -> ShowS
$cshowList :: [IriRange_Sequence2] -> ShowS
show :: IriRange_Sequence2 -> String
$cshow :: IriRange_Sequence2 -> String
showsPrec :: Int -> IriRange_Sequence2 -> ShowS
$cshowsPrec :: Int -> IriRange_Sequence2 -> ShowS
Show)

_IriRange_Sequence2 :: Name
_IriRange_Sequence2 = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.IriRange.Sequence2")

_IriRange_Sequence2_listOfExclusion :: FieldName
_IriRange_Sequence2_listOfExclusion = (String -> FieldName
Core.FieldName String
"listOfExclusion")

data Exclusion = 
  Exclusion {
    Exclusion -> Iri
exclusionIri :: Iri}
  deriving (Exclusion -> Exclusion -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Exclusion -> Exclusion -> Bool
$c/= :: Exclusion -> Exclusion -> Bool
== :: Exclusion -> Exclusion -> Bool
$c== :: Exclusion -> Exclusion -> Bool
Eq, Eq Exclusion
Exclusion -> Exclusion -> Bool
Exclusion -> Exclusion -> Ordering
Exclusion -> Exclusion -> Exclusion
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
min :: Exclusion -> Exclusion -> Exclusion
$cmin :: Exclusion -> Exclusion -> Exclusion
max :: Exclusion -> Exclusion -> Exclusion
$cmax :: Exclusion -> Exclusion -> Exclusion
>= :: Exclusion -> Exclusion -> Bool
$c>= :: Exclusion -> Exclusion -> Bool
> :: Exclusion -> Exclusion -> Bool
$c> :: Exclusion -> Exclusion -> Bool
<= :: Exclusion -> Exclusion -> Bool
$c<= :: Exclusion -> Exclusion -> Bool
< :: Exclusion -> Exclusion -> Bool
$c< :: Exclusion -> Exclusion -> Bool
compare :: Exclusion -> Exclusion -> Ordering
$ccompare :: Exclusion -> Exclusion -> Ordering
Ord, ReadPrec [Exclusion]
ReadPrec Exclusion
Int -> ReadS Exclusion
ReadS [Exclusion]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Exclusion]
$creadListPrec :: ReadPrec [Exclusion]
readPrec :: ReadPrec Exclusion
$creadPrec :: ReadPrec Exclusion
readList :: ReadS [Exclusion]
$creadList :: ReadS [Exclusion]
readsPrec :: Int -> ReadS Exclusion
$creadsPrec :: Int -> ReadS Exclusion
Read, Int -> Exclusion -> ShowS
[Exclusion] -> ShowS
Exclusion -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Exclusion] -> ShowS
$cshowList :: [Exclusion] -> ShowS
show :: Exclusion -> String
$cshow :: Exclusion -> String
showsPrec :: Int -> Exclusion -> ShowS
$cshowsPrec :: Int -> Exclusion -> ShowS
Show)

_Exclusion :: Name
_Exclusion = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.Exclusion")

_Exclusion_iri :: FieldName
_Exclusion_iri = (String -> FieldName
Core.FieldName String
"iri")

data Include = 
  Include {
    Include -> TripleExprLabel
includeTripleExprLabel :: TripleExprLabel}
  deriving (Include -> Include -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Include -> Include -> Bool
$c/= :: Include -> Include -> Bool
== :: Include -> Include -> Bool
$c== :: Include -> Include -> Bool
Eq, Eq Include
Include -> Include -> Bool
Include -> Include -> Ordering
Include -> Include -> Include
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
min :: Include -> Include -> Include
$cmin :: Include -> Include -> Include
max :: Include -> Include -> Include
$cmax :: Include -> Include -> Include
>= :: Include -> Include -> Bool
$c>= :: Include -> Include -> Bool
> :: Include -> Include -> Bool
$c> :: Include -> Include -> Bool
<= :: Include -> Include -> Bool
$c<= :: Include -> Include -> Bool
< :: Include -> Include -> Bool
$c< :: Include -> Include -> Bool
compare :: Include -> Include -> Ordering
$ccompare :: Include -> Include -> Ordering
Ord, ReadPrec [Include]
ReadPrec Include
Int -> ReadS Include
ReadS [Include]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Include]
$creadListPrec :: ReadPrec [Include]
readPrec :: ReadPrec Include
$creadPrec :: ReadPrec Include
readList :: ReadS [Include]
$creadList :: ReadS [Include]
readsPrec :: Int -> ReadS Include
$creadsPrec :: Int -> ReadS Include
Read, Int -> Include -> ShowS
[Include] -> ShowS
Include -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Include] -> ShowS
$cshowList :: [Include] -> ShowS
show :: Include -> String
$cshow :: Include -> String
showsPrec :: Int -> Include -> ShowS
$cshowsPrec :: Int -> Include -> ShowS
Show)

_Include :: Name
_Include = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.Include")

_Include_tripleExprLabel :: FieldName
_Include_tripleExprLabel = (String -> FieldName
Core.FieldName String
"tripleExprLabel")

data Annotation = 
  Annotation {
    Annotation -> Predicate
annotationPredicate :: Predicate,
    Annotation -> Annotation_Alts
annotationAlts :: Annotation_Alts}
  deriving (Annotation -> Annotation -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Annotation -> Annotation -> Bool
$c/= :: Annotation -> Annotation -> Bool
== :: Annotation -> Annotation -> Bool
$c== :: Annotation -> Annotation -> Bool
Eq, Eq Annotation
Annotation -> Annotation -> Bool
Annotation -> Annotation -> Ordering
Annotation -> Annotation -> Annotation
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
min :: Annotation -> Annotation -> Annotation
$cmin :: Annotation -> Annotation -> Annotation
max :: Annotation -> Annotation -> Annotation
$cmax :: Annotation -> Annotation -> Annotation
>= :: Annotation -> Annotation -> Bool
$c>= :: Annotation -> Annotation -> Bool
> :: Annotation -> Annotation -> Bool
$c> :: Annotation -> Annotation -> Bool
<= :: Annotation -> Annotation -> Bool
$c<= :: Annotation -> Annotation -> Bool
< :: Annotation -> Annotation -> Bool
$c< :: Annotation -> Annotation -> Bool
compare :: Annotation -> Annotation -> Ordering
$ccompare :: Annotation -> Annotation -> Ordering
Ord, ReadPrec [Annotation]
ReadPrec Annotation
Int -> ReadS Annotation
ReadS [Annotation]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Annotation]
$creadListPrec :: ReadPrec [Annotation]
readPrec :: ReadPrec Annotation
$creadPrec :: ReadPrec Annotation
readList :: ReadS [Annotation]
$creadList :: ReadS [Annotation]
readsPrec :: Int -> ReadS Annotation
$creadsPrec :: Int -> ReadS Annotation
Read, Int -> Annotation -> ShowS
[Annotation] -> ShowS
Annotation -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Annotation] -> ShowS
$cshowList :: [Annotation] -> ShowS
show :: Annotation -> String
$cshow :: Annotation -> String
showsPrec :: Int -> Annotation -> ShowS
$cshowsPrec :: Int -> Annotation -> ShowS
Show)

_Annotation :: Name
_Annotation = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.Annotation")

_Annotation_predicate :: FieldName
_Annotation_predicate = (String -> FieldName
Core.FieldName String
"predicate")

_Annotation_alts :: FieldName
_Annotation_alts = (String -> FieldName
Core.FieldName String
"alts")

data Annotation_Alts = 
  Annotation_AltsIri Iri |
  Annotation_AltsLiteral Literal
  deriving (Annotation_Alts -> Annotation_Alts -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Annotation_Alts -> Annotation_Alts -> Bool
$c/= :: Annotation_Alts -> Annotation_Alts -> Bool
== :: Annotation_Alts -> Annotation_Alts -> Bool
$c== :: Annotation_Alts -> Annotation_Alts -> Bool
Eq, Eq Annotation_Alts
Annotation_Alts -> Annotation_Alts -> Bool
Annotation_Alts -> Annotation_Alts -> Ordering
Annotation_Alts -> Annotation_Alts -> Annotation_Alts
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
min :: Annotation_Alts -> Annotation_Alts -> Annotation_Alts
$cmin :: Annotation_Alts -> Annotation_Alts -> Annotation_Alts
max :: Annotation_Alts -> Annotation_Alts -> Annotation_Alts
$cmax :: Annotation_Alts -> Annotation_Alts -> Annotation_Alts
>= :: Annotation_Alts -> Annotation_Alts -> Bool
$c>= :: Annotation_Alts -> Annotation_Alts -> Bool
> :: Annotation_Alts -> Annotation_Alts -> Bool
$c> :: Annotation_Alts -> Annotation_Alts -> Bool
<= :: Annotation_Alts -> Annotation_Alts -> Bool
$c<= :: Annotation_Alts -> Annotation_Alts -> Bool
< :: Annotation_Alts -> Annotation_Alts -> Bool
$c< :: Annotation_Alts -> Annotation_Alts -> Bool
compare :: Annotation_Alts -> Annotation_Alts -> Ordering
$ccompare :: Annotation_Alts -> Annotation_Alts -> Ordering
Ord, ReadPrec [Annotation_Alts]
ReadPrec Annotation_Alts
Int -> ReadS Annotation_Alts
ReadS [Annotation_Alts]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Annotation_Alts]
$creadListPrec :: ReadPrec [Annotation_Alts]
readPrec :: ReadPrec Annotation_Alts
$creadPrec :: ReadPrec Annotation_Alts
readList :: ReadS [Annotation_Alts]
$creadList :: ReadS [Annotation_Alts]
readsPrec :: Int -> ReadS Annotation_Alts
$creadsPrec :: Int -> ReadS Annotation_Alts
Read, Int -> Annotation_Alts -> ShowS
[Annotation_Alts] -> ShowS
Annotation_Alts -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Annotation_Alts] -> ShowS
$cshowList :: [Annotation_Alts] -> ShowS
show :: Annotation_Alts -> String
$cshow :: Annotation_Alts -> String
showsPrec :: Int -> Annotation_Alts -> ShowS
$cshowsPrec :: Int -> Annotation_Alts -> ShowS
Show)

_Annotation_Alts :: Name
_Annotation_Alts = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.Annotation.Alts")

_Annotation_Alts_iri :: FieldName
_Annotation_Alts_iri = (String -> FieldName
Core.FieldName String
"iri")

_Annotation_Alts_literal :: FieldName
_Annotation_Alts_literal = (String -> FieldName
Core.FieldName String
"literal")

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

_SemanticActions :: Name
_SemanticActions = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.SemanticActions")

data CodeDecl = 
  CodeDecl {
    CodeDecl -> Iri
codeDeclIri :: Iri,
    CodeDecl -> CodeDecl_Alts
codeDeclAlts :: CodeDecl_Alts}
  deriving (CodeDecl -> CodeDecl -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CodeDecl -> CodeDecl -> Bool
$c/= :: CodeDecl -> CodeDecl -> Bool
== :: CodeDecl -> CodeDecl -> Bool
$c== :: CodeDecl -> CodeDecl -> Bool
Eq, Eq CodeDecl
CodeDecl -> CodeDecl -> Bool
CodeDecl -> CodeDecl -> Ordering
CodeDecl -> CodeDecl -> CodeDecl
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
min :: CodeDecl -> CodeDecl -> CodeDecl
$cmin :: CodeDecl -> CodeDecl -> CodeDecl
max :: CodeDecl -> CodeDecl -> CodeDecl
$cmax :: CodeDecl -> CodeDecl -> CodeDecl
>= :: CodeDecl -> CodeDecl -> Bool
$c>= :: CodeDecl -> CodeDecl -> Bool
> :: CodeDecl -> CodeDecl -> Bool
$c> :: CodeDecl -> CodeDecl -> Bool
<= :: CodeDecl -> CodeDecl -> Bool
$c<= :: CodeDecl -> CodeDecl -> Bool
< :: CodeDecl -> CodeDecl -> Bool
$c< :: CodeDecl -> CodeDecl -> Bool
compare :: CodeDecl -> CodeDecl -> Ordering
$ccompare :: CodeDecl -> CodeDecl -> Ordering
Ord, ReadPrec [CodeDecl]
ReadPrec CodeDecl
Int -> ReadS CodeDecl
ReadS [CodeDecl]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CodeDecl]
$creadListPrec :: ReadPrec [CodeDecl]
readPrec :: ReadPrec CodeDecl
$creadPrec :: ReadPrec CodeDecl
readList :: ReadS [CodeDecl]
$creadList :: ReadS [CodeDecl]
readsPrec :: Int -> ReadS CodeDecl
$creadsPrec :: Int -> ReadS CodeDecl
Read, Int -> CodeDecl -> ShowS
[CodeDecl] -> ShowS
CodeDecl -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CodeDecl] -> ShowS
$cshowList :: [CodeDecl] -> ShowS
show :: CodeDecl -> String
$cshow :: CodeDecl -> String
showsPrec :: Int -> CodeDecl -> ShowS
$cshowsPrec :: Int -> CodeDecl -> ShowS
Show)

_CodeDecl :: Name
_CodeDecl = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.CodeDecl")

_CodeDecl_iri :: FieldName
_CodeDecl_iri = (String -> FieldName
Core.FieldName String
"iri")

_CodeDecl_alts :: FieldName
_CodeDecl_alts = (String -> FieldName
Core.FieldName String
"alts")

data CodeDecl_Alts = 
  CodeDecl_AltsCode Code |
  CodeDecl_AltsPercnt 
  deriving (CodeDecl_Alts -> CodeDecl_Alts -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CodeDecl_Alts -> CodeDecl_Alts -> Bool
$c/= :: CodeDecl_Alts -> CodeDecl_Alts -> Bool
== :: CodeDecl_Alts -> CodeDecl_Alts -> Bool
$c== :: CodeDecl_Alts -> CodeDecl_Alts -> Bool
Eq, Eq CodeDecl_Alts
CodeDecl_Alts -> CodeDecl_Alts -> Bool
CodeDecl_Alts -> CodeDecl_Alts -> Ordering
CodeDecl_Alts -> CodeDecl_Alts -> CodeDecl_Alts
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
min :: CodeDecl_Alts -> CodeDecl_Alts -> CodeDecl_Alts
$cmin :: CodeDecl_Alts -> CodeDecl_Alts -> CodeDecl_Alts
max :: CodeDecl_Alts -> CodeDecl_Alts -> CodeDecl_Alts
$cmax :: CodeDecl_Alts -> CodeDecl_Alts -> CodeDecl_Alts
>= :: CodeDecl_Alts -> CodeDecl_Alts -> Bool
$c>= :: CodeDecl_Alts -> CodeDecl_Alts -> Bool
> :: CodeDecl_Alts -> CodeDecl_Alts -> Bool
$c> :: CodeDecl_Alts -> CodeDecl_Alts -> Bool
<= :: CodeDecl_Alts -> CodeDecl_Alts -> Bool
$c<= :: CodeDecl_Alts -> CodeDecl_Alts -> Bool
< :: CodeDecl_Alts -> CodeDecl_Alts -> Bool
$c< :: CodeDecl_Alts -> CodeDecl_Alts -> Bool
compare :: CodeDecl_Alts -> CodeDecl_Alts -> Ordering
$ccompare :: CodeDecl_Alts -> CodeDecl_Alts -> Ordering
Ord, ReadPrec [CodeDecl_Alts]
ReadPrec CodeDecl_Alts
Int -> ReadS CodeDecl_Alts
ReadS [CodeDecl_Alts]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CodeDecl_Alts]
$creadListPrec :: ReadPrec [CodeDecl_Alts]
readPrec :: ReadPrec CodeDecl_Alts
$creadPrec :: ReadPrec CodeDecl_Alts
readList :: ReadS [CodeDecl_Alts]
$creadList :: ReadS [CodeDecl_Alts]
readsPrec :: Int -> ReadS CodeDecl_Alts
$creadsPrec :: Int -> ReadS CodeDecl_Alts
Read, Int -> CodeDecl_Alts -> ShowS
[CodeDecl_Alts] -> ShowS
CodeDecl_Alts -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CodeDecl_Alts] -> ShowS
$cshowList :: [CodeDecl_Alts] -> ShowS
show :: CodeDecl_Alts -> String
$cshow :: CodeDecl_Alts -> String
showsPrec :: Int -> CodeDecl_Alts -> ShowS
$cshowsPrec :: Int -> CodeDecl_Alts -> ShowS
Show)

_CodeDecl_Alts :: Name
_CodeDecl_Alts = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.CodeDecl.Alts")

_CodeDecl_Alts_code :: FieldName
_CodeDecl_Alts_code = (String -> FieldName
Core.FieldName String
"code")

_CodeDecl_Alts_percnt :: FieldName
_CodeDecl_Alts_percnt = (String -> FieldName
Core.FieldName String
"percnt")

data Literal = 
  LiteralRdfLiteral RdfLiteral |
  LiteralNumericLiteral NumericLiteral |
  LiteralBooleanLiteral BooleanLiteral
  deriving (Literal -> Literal -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Literal -> Literal -> Bool
$c/= :: Literal -> Literal -> Bool
== :: Literal -> Literal -> Bool
$c== :: Literal -> Literal -> Bool
Eq, Eq Literal
Literal -> Literal -> Bool
Literal -> Literal -> Ordering
Literal -> Literal -> Literal
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
min :: Literal -> Literal -> Literal
$cmin :: Literal -> Literal -> Literal
max :: Literal -> Literal -> Literal
$cmax :: Literal -> Literal -> Literal
>= :: Literal -> Literal -> Bool
$c>= :: Literal -> Literal -> Bool
> :: Literal -> Literal -> Bool
$c> :: Literal -> Literal -> Bool
<= :: Literal -> Literal -> Bool
$c<= :: Literal -> Literal -> Bool
< :: Literal -> Literal -> Bool
$c< :: Literal -> Literal -> Bool
compare :: Literal -> Literal -> Ordering
$ccompare :: Literal -> Literal -> Ordering
Ord, ReadPrec [Literal]
ReadPrec Literal
Int -> ReadS Literal
ReadS [Literal]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Literal]
$creadListPrec :: ReadPrec [Literal]
readPrec :: ReadPrec Literal
$creadPrec :: ReadPrec Literal
readList :: ReadS [Literal]
$creadList :: ReadS [Literal]
readsPrec :: Int -> ReadS Literal
$creadsPrec :: Int -> ReadS Literal
Read, Int -> Literal -> ShowS
[Literal] -> ShowS
Literal -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Literal] -> ShowS
$cshowList :: [Literal] -> ShowS
show :: Literal -> String
$cshow :: Literal -> String
showsPrec :: Int -> Literal -> ShowS
$cshowsPrec :: Int -> Literal -> ShowS
Show)

_Literal :: Name
_Literal = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.Literal")

_Literal_rdfLiteral :: FieldName
_Literal_rdfLiteral = (String -> FieldName
Core.FieldName String
"rdfLiteral")

_Literal_numericLiteral :: FieldName
_Literal_numericLiteral = (String -> FieldName
Core.FieldName String
"numericLiteral")

_Literal_booleanLiteral :: FieldName
_Literal_booleanLiteral = (String -> FieldName
Core.FieldName String
"booleanLiteral")

data Predicate = 
  PredicateIri Iri |
  PredicateRdfType RdfType
  deriving (Predicate -> Predicate -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Predicate -> Predicate -> Bool
$c/= :: Predicate -> Predicate -> Bool
== :: Predicate -> Predicate -> Bool
$c== :: Predicate -> Predicate -> Bool
Eq, Eq Predicate
Predicate -> Predicate -> Bool
Predicate -> Predicate -> Ordering
Predicate -> Predicate -> Predicate
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
min :: Predicate -> Predicate -> Predicate
$cmin :: Predicate -> Predicate -> Predicate
max :: Predicate -> Predicate -> Predicate
$cmax :: Predicate -> Predicate -> Predicate
>= :: Predicate -> Predicate -> Bool
$c>= :: Predicate -> Predicate -> Bool
> :: Predicate -> Predicate -> Bool
$c> :: Predicate -> Predicate -> Bool
<= :: Predicate -> Predicate -> Bool
$c<= :: Predicate -> Predicate -> Bool
< :: Predicate -> Predicate -> Bool
$c< :: Predicate -> Predicate -> Bool
compare :: Predicate -> Predicate -> Ordering
$ccompare :: Predicate -> Predicate -> Ordering
Ord, ReadPrec [Predicate]
ReadPrec Predicate
Int -> ReadS Predicate
ReadS [Predicate]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Predicate]
$creadListPrec :: ReadPrec [Predicate]
readPrec :: ReadPrec Predicate
$creadPrec :: ReadPrec Predicate
readList :: ReadS [Predicate]
$creadList :: ReadS [Predicate]
readsPrec :: Int -> ReadS Predicate
$creadsPrec :: Int -> ReadS Predicate
Read, Int -> Predicate -> ShowS
[Predicate] -> ShowS
Predicate -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Predicate] -> ShowS
$cshowList :: [Predicate] -> ShowS
show :: Predicate -> String
$cshow :: Predicate -> String
showsPrec :: Int -> Predicate -> ShowS
$cshowsPrec :: Int -> Predicate -> ShowS
Show)

_Predicate :: Name
_Predicate = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.Predicate")

_Predicate_iri :: FieldName
_Predicate_iri = (String -> FieldName
Core.FieldName String
"iri")

_Predicate_rdfType :: FieldName
_Predicate_rdfType = (String -> FieldName
Core.FieldName String
"rdfType")

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

_Datatype :: Name
_Datatype = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.Datatype")

data ShapeExprLabel = 
  ShapeExprLabelIri Iri |
  ShapeExprLabelBlankNode BlankNode
  deriving (ShapeExprLabel -> ShapeExprLabel -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ShapeExprLabel -> ShapeExprLabel -> Bool
$c/= :: ShapeExprLabel -> ShapeExprLabel -> Bool
== :: ShapeExprLabel -> ShapeExprLabel -> Bool
$c== :: ShapeExprLabel -> ShapeExprLabel -> Bool
Eq, Eq ShapeExprLabel
ShapeExprLabel -> ShapeExprLabel -> Bool
ShapeExprLabel -> ShapeExprLabel -> Ordering
ShapeExprLabel -> ShapeExprLabel -> ShapeExprLabel
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
min :: ShapeExprLabel -> ShapeExprLabel -> ShapeExprLabel
$cmin :: ShapeExprLabel -> ShapeExprLabel -> ShapeExprLabel
max :: ShapeExprLabel -> ShapeExprLabel -> ShapeExprLabel
$cmax :: ShapeExprLabel -> ShapeExprLabel -> ShapeExprLabel
>= :: ShapeExprLabel -> ShapeExprLabel -> Bool
$c>= :: ShapeExprLabel -> ShapeExprLabel -> Bool
> :: ShapeExprLabel -> ShapeExprLabel -> Bool
$c> :: ShapeExprLabel -> ShapeExprLabel -> Bool
<= :: ShapeExprLabel -> ShapeExprLabel -> Bool
$c<= :: ShapeExprLabel -> ShapeExprLabel -> Bool
< :: ShapeExprLabel -> ShapeExprLabel -> Bool
$c< :: ShapeExprLabel -> ShapeExprLabel -> Bool
compare :: ShapeExprLabel -> ShapeExprLabel -> Ordering
$ccompare :: ShapeExprLabel -> ShapeExprLabel -> Ordering
Ord, ReadPrec [ShapeExprLabel]
ReadPrec ShapeExprLabel
Int -> ReadS ShapeExprLabel
ReadS [ShapeExprLabel]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ShapeExprLabel]
$creadListPrec :: ReadPrec [ShapeExprLabel]
readPrec :: ReadPrec ShapeExprLabel
$creadPrec :: ReadPrec ShapeExprLabel
readList :: ReadS [ShapeExprLabel]
$creadList :: ReadS [ShapeExprLabel]
readsPrec :: Int -> ReadS ShapeExprLabel
$creadsPrec :: Int -> ReadS ShapeExprLabel
Read, Int -> ShapeExprLabel -> ShowS
[ShapeExprLabel] -> ShowS
ShapeExprLabel -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ShapeExprLabel] -> ShowS
$cshowList :: [ShapeExprLabel] -> ShowS
show :: ShapeExprLabel -> String
$cshow :: ShapeExprLabel -> String
showsPrec :: Int -> ShapeExprLabel -> ShowS
$cshowsPrec :: Int -> ShapeExprLabel -> ShowS
Show)

_ShapeExprLabel :: Name
_ShapeExprLabel = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.ShapeExprLabel")

_ShapeExprLabel_iri :: FieldName
_ShapeExprLabel_iri = (String -> FieldName
Core.FieldName String
"iri")

_ShapeExprLabel_blankNode :: FieldName
_ShapeExprLabel_blankNode = (String -> FieldName
Core.FieldName String
"blankNode")

data TripleExprLabel = 
  TripleExprLabel {
    TripleExprLabel -> TripleExprLabel_Alts
tripleExprLabelAlts :: TripleExprLabel_Alts}
  deriving (TripleExprLabel -> TripleExprLabel -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TripleExprLabel -> TripleExprLabel -> Bool
$c/= :: TripleExprLabel -> TripleExprLabel -> Bool
== :: TripleExprLabel -> TripleExprLabel -> Bool
$c== :: TripleExprLabel -> TripleExprLabel -> Bool
Eq, Eq TripleExprLabel
TripleExprLabel -> TripleExprLabel -> Bool
TripleExprLabel -> TripleExprLabel -> Ordering
TripleExprLabel -> TripleExprLabel -> TripleExprLabel
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
min :: TripleExprLabel -> TripleExprLabel -> TripleExprLabel
$cmin :: TripleExprLabel -> TripleExprLabel -> TripleExprLabel
max :: TripleExprLabel -> TripleExprLabel -> TripleExprLabel
$cmax :: TripleExprLabel -> TripleExprLabel -> TripleExprLabel
>= :: TripleExprLabel -> TripleExprLabel -> Bool
$c>= :: TripleExprLabel -> TripleExprLabel -> Bool
> :: TripleExprLabel -> TripleExprLabel -> Bool
$c> :: TripleExprLabel -> TripleExprLabel -> Bool
<= :: TripleExprLabel -> TripleExprLabel -> Bool
$c<= :: TripleExprLabel -> TripleExprLabel -> Bool
< :: TripleExprLabel -> TripleExprLabel -> Bool
$c< :: TripleExprLabel -> TripleExprLabel -> Bool
compare :: TripleExprLabel -> TripleExprLabel -> Ordering
$ccompare :: TripleExprLabel -> TripleExprLabel -> Ordering
Ord, ReadPrec [TripleExprLabel]
ReadPrec TripleExprLabel
Int -> ReadS TripleExprLabel
ReadS [TripleExprLabel]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [TripleExprLabel]
$creadListPrec :: ReadPrec [TripleExprLabel]
readPrec :: ReadPrec TripleExprLabel
$creadPrec :: ReadPrec TripleExprLabel
readList :: ReadS [TripleExprLabel]
$creadList :: ReadS [TripleExprLabel]
readsPrec :: Int -> ReadS TripleExprLabel
$creadsPrec :: Int -> ReadS TripleExprLabel
Read, Int -> TripleExprLabel -> ShowS
[TripleExprLabel] -> ShowS
TripleExprLabel -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TripleExprLabel] -> ShowS
$cshowList :: [TripleExprLabel] -> ShowS
show :: TripleExprLabel -> String
$cshow :: TripleExprLabel -> String
showsPrec :: Int -> TripleExprLabel -> ShowS
$cshowsPrec :: Int -> TripleExprLabel -> ShowS
Show)

_TripleExprLabel :: Name
_TripleExprLabel = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.TripleExprLabel")

_TripleExprLabel_alts :: FieldName
_TripleExprLabel_alts = (String -> FieldName
Core.FieldName String
"alts")

data TripleExprLabel_Alts = 
  TripleExprLabel_AltsIri Iri |
  TripleExprLabel_AltsBlankNode BlankNode
  deriving (TripleExprLabel_Alts -> TripleExprLabel_Alts -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TripleExprLabel_Alts -> TripleExprLabel_Alts -> Bool
$c/= :: TripleExprLabel_Alts -> TripleExprLabel_Alts -> Bool
== :: TripleExprLabel_Alts -> TripleExprLabel_Alts -> Bool
$c== :: TripleExprLabel_Alts -> TripleExprLabel_Alts -> Bool
Eq, Eq TripleExprLabel_Alts
TripleExprLabel_Alts -> TripleExprLabel_Alts -> Bool
TripleExprLabel_Alts -> TripleExprLabel_Alts -> Ordering
TripleExprLabel_Alts
-> TripleExprLabel_Alts -> TripleExprLabel_Alts
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
min :: TripleExprLabel_Alts
-> TripleExprLabel_Alts -> TripleExprLabel_Alts
$cmin :: TripleExprLabel_Alts
-> TripleExprLabel_Alts -> TripleExprLabel_Alts
max :: TripleExprLabel_Alts
-> TripleExprLabel_Alts -> TripleExprLabel_Alts
$cmax :: TripleExprLabel_Alts
-> TripleExprLabel_Alts -> TripleExprLabel_Alts
>= :: TripleExprLabel_Alts -> TripleExprLabel_Alts -> Bool
$c>= :: TripleExprLabel_Alts -> TripleExprLabel_Alts -> Bool
> :: TripleExprLabel_Alts -> TripleExprLabel_Alts -> Bool
$c> :: TripleExprLabel_Alts -> TripleExprLabel_Alts -> Bool
<= :: TripleExprLabel_Alts -> TripleExprLabel_Alts -> Bool
$c<= :: TripleExprLabel_Alts -> TripleExprLabel_Alts -> Bool
< :: TripleExprLabel_Alts -> TripleExprLabel_Alts -> Bool
$c< :: TripleExprLabel_Alts -> TripleExprLabel_Alts -> Bool
compare :: TripleExprLabel_Alts -> TripleExprLabel_Alts -> Ordering
$ccompare :: TripleExprLabel_Alts -> TripleExprLabel_Alts -> Ordering
Ord, ReadPrec [TripleExprLabel_Alts]
ReadPrec TripleExprLabel_Alts
Int -> ReadS TripleExprLabel_Alts
ReadS [TripleExprLabel_Alts]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [TripleExprLabel_Alts]
$creadListPrec :: ReadPrec [TripleExprLabel_Alts]
readPrec :: ReadPrec TripleExprLabel_Alts
$creadPrec :: ReadPrec TripleExprLabel_Alts
readList :: ReadS [TripleExprLabel_Alts]
$creadList :: ReadS [TripleExprLabel_Alts]
readsPrec :: Int -> ReadS TripleExprLabel_Alts
$creadsPrec :: Int -> ReadS TripleExprLabel_Alts
Read, Int -> TripleExprLabel_Alts -> ShowS
[TripleExprLabel_Alts] -> ShowS
TripleExprLabel_Alts -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TripleExprLabel_Alts] -> ShowS
$cshowList :: [TripleExprLabel_Alts] -> ShowS
show :: TripleExprLabel_Alts -> String
$cshow :: TripleExprLabel_Alts -> String
showsPrec :: Int -> TripleExprLabel_Alts -> ShowS
$cshowsPrec :: Int -> TripleExprLabel_Alts -> ShowS
Show)

_TripleExprLabel_Alts :: Name
_TripleExprLabel_Alts = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.TripleExprLabel.Alts")

_TripleExprLabel_Alts_iri :: FieldName
_TripleExprLabel_Alts_iri = (String -> FieldName
Core.FieldName String
"iri")

_TripleExprLabel_Alts_blankNode :: FieldName
_TripleExprLabel_Alts_blankNode = (String -> FieldName
Core.FieldName String
"blankNode")

data NumericLiteral = 
  NumericLiteralInteger Integer_ |
  NumericLiteralDecimal Decimal |
  NumericLiteralDouble Double_
  deriving (NumericLiteral -> NumericLiteral -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NumericLiteral -> NumericLiteral -> Bool
$c/= :: NumericLiteral -> NumericLiteral -> Bool
== :: NumericLiteral -> NumericLiteral -> Bool
$c== :: NumericLiteral -> NumericLiteral -> Bool
Eq, Eq NumericLiteral
NumericLiteral -> NumericLiteral -> Bool
NumericLiteral -> NumericLiteral -> Ordering
NumericLiteral -> NumericLiteral -> NumericLiteral
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
min :: NumericLiteral -> NumericLiteral -> NumericLiteral
$cmin :: NumericLiteral -> NumericLiteral -> NumericLiteral
max :: NumericLiteral -> NumericLiteral -> NumericLiteral
$cmax :: NumericLiteral -> NumericLiteral -> NumericLiteral
>= :: NumericLiteral -> NumericLiteral -> Bool
$c>= :: NumericLiteral -> NumericLiteral -> Bool
> :: NumericLiteral -> NumericLiteral -> Bool
$c> :: NumericLiteral -> NumericLiteral -> Bool
<= :: NumericLiteral -> NumericLiteral -> Bool
$c<= :: NumericLiteral -> NumericLiteral -> Bool
< :: NumericLiteral -> NumericLiteral -> Bool
$c< :: NumericLiteral -> NumericLiteral -> Bool
compare :: NumericLiteral -> NumericLiteral -> Ordering
$ccompare :: NumericLiteral -> NumericLiteral -> Ordering
Ord, ReadPrec [NumericLiteral]
ReadPrec NumericLiteral
Int -> ReadS NumericLiteral
ReadS [NumericLiteral]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [NumericLiteral]
$creadListPrec :: ReadPrec [NumericLiteral]
readPrec :: ReadPrec NumericLiteral
$creadPrec :: ReadPrec NumericLiteral
readList :: ReadS [NumericLiteral]
$creadList :: ReadS [NumericLiteral]
readsPrec :: Int -> ReadS NumericLiteral
$creadsPrec :: Int -> ReadS NumericLiteral
Read, Int -> NumericLiteral -> ShowS
[NumericLiteral] -> ShowS
NumericLiteral -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [NumericLiteral] -> ShowS
$cshowList :: [NumericLiteral] -> ShowS
show :: NumericLiteral -> String
$cshow :: NumericLiteral -> String
showsPrec :: Int -> NumericLiteral -> ShowS
$cshowsPrec :: Int -> NumericLiteral -> ShowS
Show)

_NumericLiteral :: Name
_NumericLiteral = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.NumericLiteral")

_NumericLiteral_integer :: FieldName
_NumericLiteral_integer = (String -> FieldName
Core.FieldName String
"integer")

_NumericLiteral_decimal :: FieldName
_NumericLiteral_decimal = (String -> FieldName
Core.FieldName String
"decimal")

_NumericLiteral_double :: FieldName
_NumericLiteral_double = (String -> FieldName
Core.FieldName String
"double")

data RdfLiteral = 
  RdfLiteral {
    RdfLiteral -> String_
rdfLiteralString :: String_,
    RdfLiteral -> Maybe RdfLiteral_Alts_Option
rdfLiteralAlts :: (Maybe RdfLiteral_Alts_Option)}
  deriving (RdfLiteral -> RdfLiteral -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RdfLiteral -> RdfLiteral -> Bool
$c/= :: RdfLiteral -> RdfLiteral -> Bool
== :: RdfLiteral -> RdfLiteral -> Bool
$c== :: RdfLiteral -> RdfLiteral -> Bool
Eq, Eq RdfLiteral
RdfLiteral -> RdfLiteral -> Bool
RdfLiteral -> RdfLiteral -> Ordering
RdfLiteral -> RdfLiteral -> RdfLiteral
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
min :: RdfLiteral -> RdfLiteral -> RdfLiteral
$cmin :: RdfLiteral -> RdfLiteral -> RdfLiteral
max :: RdfLiteral -> RdfLiteral -> RdfLiteral
$cmax :: RdfLiteral -> RdfLiteral -> RdfLiteral
>= :: RdfLiteral -> RdfLiteral -> Bool
$c>= :: RdfLiteral -> RdfLiteral -> Bool
> :: RdfLiteral -> RdfLiteral -> Bool
$c> :: RdfLiteral -> RdfLiteral -> Bool
<= :: RdfLiteral -> RdfLiteral -> Bool
$c<= :: RdfLiteral -> RdfLiteral -> Bool
< :: RdfLiteral -> RdfLiteral -> Bool
$c< :: RdfLiteral -> RdfLiteral -> Bool
compare :: RdfLiteral -> RdfLiteral -> Ordering
$ccompare :: RdfLiteral -> RdfLiteral -> Ordering
Ord, ReadPrec [RdfLiteral]
ReadPrec RdfLiteral
Int -> ReadS RdfLiteral
ReadS [RdfLiteral]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [RdfLiteral]
$creadListPrec :: ReadPrec [RdfLiteral]
readPrec :: ReadPrec RdfLiteral
$creadPrec :: ReadPrec RdfLiteral
readList :: ReadS [RdfLiteral]
$creadList :: ReadS [RdfLiteral]
readsPrec :: Int -> ReadS RdfLiteral
$creadsPrec :: Int -> ReadS RdfLiteral
Read, Int -> RdfLiteral -> ShowS
[RdfLiteral] -> ShowS
RdfLiteral -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RdfLiteral] -> ShowS
$cshowList :: [RdfLiteral] -> ShowS
show :: RdfLiteral -> String
$cshow :: RdfLiteral -> String
showsPrec :: Int -> RdfLiteral -> ShowS
$cshowsPrec :: Int -> RdfLiteral -> ShowS
Show)

_RdfLiteral :: Name
_RdfLiteral = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.RdfLiteral")

_RdfLiteral_string :: FieldName
_RdfLiteral_string = (String -> FieldName
Core.FieldName String
"string")

_RdfLiteral_alts :: FieldName
_RdfLiteral_alts = (String -> FieldName
Core.FieldName String
"alts")

data RdfLiteral_Alts_Option = 
  RdfLiteral_Alts_OptionLangTag LangTag |
  RdfLiteral_Alts_OptionSequence RdfLiteral_Alts_Option_Sequence
  deriving (RdfLiteral_Alts_Option -> RdfLiteral_Alts_Option -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RdfLiteral_Alts_Option -> RdfLiteral_Alts_Option -> Bool
$c/= :: RdfLiteral_Alts_Option -> RdfLiteral_Alts_Option -> Bool
== :: RdfLiteral_Alts_Option -> RdfLiteral_Alts_Option -> Bool
$c== :: RdfLiteral_Alts_Option -> RdfLiteral_Alts_Option -> Bool
Eq, Eq RdfLiteral_Alts_Option
RdfLiteral_Alts_Option -> RdfLiteral_Alts_Option -> Bool
RdfLiteral_Alts_Option -> RdfLiteral_Alts_Option -> Ordering
RdfLiteral_Alts_Option
-> RdfLiteral_Alts_Option -> RdfLiteral_Alts_Option
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
min :: RdfLiteral_Alts_Option
-> RdfLiteral_Alts_Option -> RdfLiteral_Alts_Option
$cmin :: RdfLiteral_Alts_Option
-> RdfLiteral_Alts_Option -> RdfLiteral_Alts_Option
max :: RdfLiteral_Alts_Option
-> RdfLiteral_Alts_Option -> RdfLiteral_Alts_Option
$cmax :: RdfLiteral_Alts_Option
-> RdfLiteral_Alts_Option -> RdfLiteral_Alts_Option
>= :: RdfLiteral_Alts_Option -> RdfLiteral_Alts_Option -> Bool
$c>= :: RdfLiteral_Alts_Option -> RdfLiteral_Alts_Option -> Bool
> :: RdfLiteral_Alts_Option -> RdfLiteral_Alts_Option -> Bool
$c> :: RdfLiteral_Alts_Option -> RdfLiteral_Alts_Option -> Bool
<= :: RdfLiteral_Alts_Option -> RdfLiteral_Alts_Option -> Bool
$c<= :: RdfLiteral_Alts_Option -> RdfLiteral_Alts_Option -> Bool
< :: RdfLiteral_Alts_Option -> RdfLiteral_Alts_Option -> Bool
$c< :: RdfLiteral_Alts_Option -> RdfLiteral_Alts_Option -> Bool
compare :: RdfLiteral_Alts_Option -> RdfLiteral_Alts_Option -> Ordering
$ccompare :: RdfLiteral_Alts_Option -> RdfLiteral_Alts_Option -> Ordering
Ord, ReadPrec [RdfLiteral_Alts_Option]
ReadPrec RdfLiteral_Alts_Option
Int -> ReadS RdfLiteral_Alts_Option
ReadS [RdfLiteral_Alts_Option]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [RdfLiteral_Alts_Option]
$creadListPrec :: ReadPrec [RdfLiteral_Alts_Option]
readPrec :: ReadPrec RdfLiteral_Alts_Option
$creadPrec :: ReadPrec RdfLiteral_Alts_Option
readList :: ReadS [RdfLiteral_Alts_Option]
$creadList :: ReadS [RdfLiteral_Alts_Option]
readsPrec :: Int -> ReadS RdfLiteral_Alts_Option
$creadsPrec :: Int -> ReadS RdfLiteral_Alts_Option
Read, Int -> RdfLiteral_Alts_Option -> ShowS
[RdfLiteral_Alts_Option] -> ShowS
RdfLiteral_Alts_Option -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RdfLiteral_Alts_Option] -> ShowS
$cshowList :: [RdfLiteral_Alts_Option] -> ShowS
show :: RdfLiteral_Alts_Option -> String
$cshow :: RdfLiteral_Alts_Option -> String
showsPrec :: Int -> RdfLiteral_Alts_Option -> ShowS
$cshowsPrec :: Int -> RdfLiteral_Alts_Option -> ShowS
Show)

_RdfLiteral_Alts_Option :: Name
_RdfLiteral_Alts_Option = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.RdfLiteral.Alts.Option")

_RdfLiteral_Alts_Option_langTag :: FieldName
_RdfLiteral_Alts_Option_langTag = (String -> FieldName
Core.FieldName String
"langTag")

_RdfLiteral_Alts_Option_sequence :: FieldName
_RdfLiteral_Alts_Option_sequence = (String -> FieldName
Core.FieldName String
"sequence")

data RdfLiteral_Alts_Option_Sequence = 
  RdfLiteral_Alts_Option_Sequence {
    RdfLiteral_Alts_Option_Sequence -> Datatype
rdfLiteral_Alts_Option_SequenceDatatype :: Datatype}
  deriving (RdfLiteral_Alts_Option_Sequence
-> RdfLiteral_Alts_Option_Sequence -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RdfLiteral_Alts_Option_Sequence
-> RdfLiteral_Alts_Option_Sequence -> Bool
$c/= :: RdfLiteral_Alts_Option_Sequence
-> RdfLiteral_Alts_Option_Sequence -> Bool
== :: RdfLiteral_Alts_Option_Sequence
-> RdfLiteral_Alts_Option_Sequence -> Bool
$c== :: RdfLiteral_Alts_Option_Sequence
-> RdfLiteral_Alts_Option_Sequence -> Bool
Eq, Eq RdfLiteral_Alts_Option_Sequence
RdfLiteral_Alts_Option_Sequence
-> RdfLiteral_Alts_Option_Sequence -> Bool
RdfLiteral_Alts_Option_Sequence
-> RdfLiteral_Alts_Option_Sequence -> Ordering
RdfLiteral_Alts_Option_Sequence
-> RdfLiteral_Alts_Option_Sequence
-> RdfLiteral_Alts_Option_Sequence
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
min :: RdfLiteral_Alts_Option_Sequence
-> RdfLiteral_Alts_Option_Sequence
-> RdfLiteral_Alts_Option_Sequence
$cmin :: RdfLiteral_Alts_Option_Sequence
-> RdfLiteral_Alts_Option_Sequence
-> RdfLiteral_Alts_Option_Sequence
max :: RdfLiteral_Alts_Option_Sequence
-> RdfLiteral_Alts_Option_Sequence
-> RdfLiteral_Alts_Option_Sequence
$cmax :: RdfLiteral_Alts_Option_Sequence
-> RdfLiteral_Alts_Option_Sequence
-> RdfLiteral_Alts_Option_Sequence
>= :: RdfLiteral_Alts_Option_Sequence
-> RdfLiteral_Alts_Option_Sequence -> Bool
$c>= :: RdfLiteral_Alts_Option_Sequence
-> RdfLiteral_Alts_Option_Sequence -> Bool
> :: RdfLiteral_Alts_Option_Sequence
-> RdfLiteral_Alts_Option_Sequence -> Bool
$c> :: RdfLiteral_Alts_Option_Sequence
-> RdfLiteral_Alts_Option_Sequence -> Bool
<= :: RdfLiteral_Alts_Option_Sequence
-> RdfLiteral_Alts_Option_Sequence -> Bool
$c<= :: RdfLiteral_Alts_Option_Sequence
-> RdfLiteral_Alts_Option_Sequence -> Bool
< :: RdfLiteral_Alts_Option_Sequence
-> RdfLiteral_Alts_Option_Sequence -> Bool
$c< :: RdfLiteral_Alts_Option_Sequence
-> RdfLiteral_Alts_Option_Sequence -> Bool
compare :: RdfLiteral_Alts_Option_Sequence
-> RdfLiteral_Alts_Option_Sequence -> Ordering
$ccompare :: RdfLiteral_Alts_Option_Sequence
-> RdfLiteral_Alts_Option_Sequence -> Ordering
Ord, ReadPrec [RdfLiteral_Alts_Option_Sequence]
ReadPrec RdfLiteral_Alts_Option_Sequence
Int -> ReadS RdfLiteral_Alts_Option_Sequence
ReadS [RdfLiteral_Alts_Option_Sequence]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [RdfLiteral_Alts_Option_Sequence]
$creadListPrec :: ReadPrec [RdfLiteral_Alts_Option_Sequence]
readPrec :: ReadPrec RdfLiteral_Alts_Option_Sequence
$creadPrec :: ReadPrec RdfLiteral_Alts_Option_Sequence
readList :: ReadS [RdfLiteral_Alts_Option_Sequence]
$creadList :: ReadS [RdfLiteral_Alts_Option_Sequence]
readsPrec :: Int -> ReadS RdfLiteral_Alts_Option_Sequence
$creadsPrec :: Int -> ReadS RdfLiteral_Alts_Option_Sequence
Read, Int -> RdfLiteral_Alts_Option_Sequence -> ShowS
[RdfLiteral_Alts_Option_Sequence] -> ShowS
RdfLiteral_Alts_Option_Sequence -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RdfLiteral_Alts_Option_Sequence] -> ShowS
$cshowList :: [RdfLiteral_Alts_Option_Sequence] -> ShowS
show :: RdfLiteral_Alts_Option_Sequence -> String
$cshow :: RdfLiteral_Alts_Option_Sequence -> String
showsPrec :: Int -> RdfLiteral_Alts_Option_Sequence -> ShowS
$cshowsPrec :: Int -> RdfLiteral_Alts_Option_Sequence -> ShowS
Show)

_RdfLiteral_Alts_Option_Sequence :: Name
_RdfLiteral_Alts_Option_Sequence = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.RdfLiteral.Alts.Option.Sequence")

_RdfLiteral_Alts_Option_Sequence_datatype :: FieldName
_RdfLiteral_Alts_Option_Sequence_datatype = (String -> FieldName
Core.FieldName String
"datatype")

data BooleanLiteral = 
  BooleanLiteralTrue  |
  BooleanLiteralFalse 
  deriving (BooleanLiteral -> BooleanLiteral -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BooleanLiteral -> BooleanLiteral -> Bool
$c/= :: BooleanLiteral -> BooleanLiteral -> Bool
== :: BooleanLiteral -> BooleanLiteral -> Bool
$c== :: BooleanLiteral -> BooleanLiteral -> Bool
Eq, Eq BooleanLiteral
BooleanLiteral -> BooleanLiteral -> Bool
BooleanLiteral -> BooleanLiteral -> Ordering
BooleanLiteral -> BooleanLiteral -> BooleanLiteral
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
min :: BooleanLiteral -> BooleanLiteral -> BooleanLiteral
$cmin :: BooleanLiteral -> BooleanLiteral -> BooleanLiteral
max :: BooleanLiteral -> BooleanLiteral -> BooleanLiteral
$cmax :: BooleanLiteral -> BooleanLiteral -> BooleanLiteral
>= :: BooleanLiteral -> BooleanLiteral -> Bool
$c>= :: BooleanLiteral -> BooleanLiteral -> Bool
> :: BooleanLiteral -> BooleanLiteral -> Bool
$c> :: BooleanLiteral -> BooleanLiteral -> Bool
<= :: BooleanLiteral -> BooleanLiteral -> Bool
$c<= :: BooleanLiteral -> BooleanLiteral -> Bool
< :: BooleanLiteral -> BooleanLiteral -> Bool
$c< :: BooleanLiteral -> BooleanLiteral -> Bool
compare :: BooleanLiteral -> BooleanLiteral -> Ordering
$ccompare :: BooleanLiteral -> BooleanLiteral -> Ordering
Ord, ReadPrec [BooleanLiteral]
ReadPrec BooleanLiteral
Int -> ReadS BooleanLiteral
ReadS [BooleanLiteral]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [BooleanLiteral]
$creadListPrec :: ReadPrec [BooleanLiteral]
readPrec :: ReadPrec BooleanLiteral
$creadPrec :: ReadPrec BooleanLiteral
readList :: ReadS [BooleanLiteral]
$creadList :: ReadS [BooleanLiteral]
readsPrec :: Int -> ReadS BooleanLiteral
$creadsPrec :: Int -> ReadS BooleanLiteral
Read, Int -> BooleanLiteral -> ShowS
[BooleanLiteral] -> ShowS
BooleanLiteral -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BooleanLiteral] -> ShowS
$cshowList :: [BooleanLiteral] -> ShowS
show :: BooleanLiteral -> String
$cshow :: BooleanLiteral -> String
showsPrec :: Int -> BooleanLiteral -> ShowS
$cshowsPrec :: Int -> BooleanLiteral -> ShowS
Show)

_BooleanLiteral :: Name
_BooleanLiteral = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.BooleanLiteral")

_BooleanLiteral_true :: FieldName
_BooleanLiteral_true = (String -> FieldName
Core.FieldName String
"true")

_BooleanLiteral_false :: FieldName
_BooleanLiteral_false = (String -> FieldName
Core.FieldName String
"false")

data String_ = 
  StringStringLiteral1 StringLiteral1 |
  StringStringLiteralLong1 StringLiteralLong1 |
  StringStringLiteral2 StringLiteral2 |
  StringStringLiteralLong2 StringLiteralLong2
  deriving (String_ -> String_ -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: String_ -> String_ -> Bool
$c/= :: String_ -> String_ -> Bool
== :: String_ -> String_ -> Bool
$c== :: String_ -> String_ -> Bool
Eq, Eq 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
min :: String_ -> String_ -> String_
$cmin :: String_ -> String_ -> String_
max :: String_ -> String_ -> String_
$cmax :: String_ -> String_ -> String_
>= :: String_ -> String_ -> Bool
$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
compare :: String_ -> String_ -> Ordering
$ccompare :: String_ -> String_ -> Ordering
Ord, ReadPrec [String_]
ReadPrec String_
Int -> ReadS String_
ReadS [String_]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [String_]
$creadListPrec :: ReadPrec [String_]
readPrec :: ReadPrec String_
$creadPrec :: ReadPrec String_
readList :: ReadS [String_]
$creadList :: ReadS [String_]
readsPrec :: Int -> ReadS String_
$creadsPrec :: Int -> ReadS String_
Read, Int -> String_ -> ShowS
[String_] -> ShowS
String_ -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [String_] -> ShowS
$cshowList :: [String_] -> ShowS
show :: String_ -> String
$cshow :: String_ -> String
showsPrec :: Int -> String_ -> ShowS
$cshowsPrec :: Int -> String_ -> ShowS
Show)

_String :: Name
_String = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.String")

_String_stringLiteral1 :: FieldName
_String_stringLiteral1 = (String -> FieldName
Core.FieldName String
"stringLiteral1")

_String_stringLiteralLong1 :: FieldName
_String_stringLiteralLong1 = (String -> FieldName
Core.FieldName String
"stringLiteralLong1")

_String_stringLiteral2 :: FieldName
_String_stringLiteral2 = (String -> FieldName
Core.FieldName String
"stringLiteral2")

_String_stringLiteralLong2 :: FieldName
_String_stringLiteralLong2 = (String -> FieldName
Core.FieldName String
"stringLiteralLong2")

data Iri = 
  IriIriRef IriRef |
  IriPrefixedName PrefixedName
  deriving (Iri -> Iri -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Iri -> Iri -> Bool
$c/= :: Iri -> Iri -> Bool
== :: Iri -> Iri -> Bool
$c== :: Iri -> Iri -> Bool
Eq, Eq Iri
Iri -> Iri -> Bool
Iri -> Iri -> Ordering
Iri -> Iri -> Iri
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
min :: Iri -> Iri -> Iri
$cmin :: Iri -> Iri -> Iri
max :: Iri -> Iri -> Iri
$cmax :: Iri -> Iri -> Iri
>= :: Iri -> Iri -> Bool
$c>= :: Iri -> Iri -> Bool
> :: Iri -> Iri -> Bool
$c> :: Iri -> Iri -> Bool
<= :: Iri -> Iri -> Bool
$c<= :: Iri -> Iri -> Bool
< :: Iri -> Iri -> Bool
$c< :: Iri -> Iri -> Bool
compare :: Iri -> Iri -> Ordering
$ccompare :: Iri -> Iri -> Ordering
Ord, ReadPrec [Iri]
ReadPrec Iri
Int -> ReadS Iri
ReadS [Iri]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Iri]
$creadListPrec :: ReadPrec [Iri]
readPrec :: ReadPrec Iri
$creadPrec :: ReadPrec Iri
readList :: ReadS [Iri]
$creadList :: ReadS [Iri]
readsPrec :: Int -> ReadS Iri
$creadsPrec :: Int -> ReadS Iri
Read, Int -> Iri -> ShowS
[Iri] -> ShowS
Iri -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Iri] -> ShowS
$cshowList :: [Iri] -> ShowS
show :: Iri -> String
$cshow :: Iri -> String
showsPrec :: Int -> Iri -> ShowS
$cshowsPrec :: Int -> Iri -> ShowS
Show)

_Iri :: Name
_Iri = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.Iri")

_Iri_iriRef :: FieldName
_Iri_iriRef = (String -> FieldName
Core.FieldName String
"iriRef")

_Iri_prefixedName :: FieldName
_Iri_prefixedName = (String -> FieldName
Core.FieldName String
"prefixedName")

data PrefixedName = 
  PrefixedNamePnameLn PnameLn |
  PrefixedNamePnameNs PnameNs
  deriving (PrefixedName -> PrefixedName -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PrefixedName -> PrefixedName -> Bool
$c/= :: PrefixedName -> PrefixedName -> Bool
== :: PrefixedName -> PrefixedName -> Bool
$c== :: PrefixedName -> PrefixedName -> Bool
Eq, Eq PrefixedName
PrefixedName -> PrefixedName -> Bool
PrefixedName -> PrefixedName -> Ordering
PrefixedName -> PrefixedName -> PrefixedName
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
min :: PrefixedName -> PrefixedName -> PrefixedName
$cmin :: PrefixedName -> PrefixedName -> PrefixedName
max :: PrefixedName -> PrefixedName -> PrefixedName
$cmax :: PrefixedName -> PrefixedName -> PrefixedName
>= :: PrefixedName -> PrefixedName -> Bool
$c>= :: PrefixedName -> PrefixedName -> Bool
> :: PrefixedName -> PrefixedName -> Bool
$c> :: PrefixedName -> PrefixedName -> Bool
<= :: PrefixedName -> PrefixedName -> Bool
$c<= :: PrefixedName -> PrefixedName -> Bool
< :: PrefixedName -> PrefixedName -> Bool
$c< :: PrefixedName -> PrefixedName -> Bool
compare :: PrefixedName -> PrefixedName -> Ordering
$ccompare :: PrefixedName -> PrefixedName -> Ordering
Ord, ReadPrec [PrefixedName]
ReadPrec PrefixedName
Int -> ReadS PrefixedName
ReadS [PrefixedName]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [PrefixedName]
$creadListPrec :: ReadPrec [PrefixedName]
readPrec :: ReadPrec PrefixedName
$creadPrec :: ReadPrec PrefixedName
readList :: ReadS [PrefixedName]
$creadList :: ReadS [PrefixedName]
readsPrec :: Int -> ReadS PrefixedName
$creadsPrec :: Int -> ReadS PrefixedName
Read, Int -> PrefixedName -> ShowS
[PrefixedName] -> ShowS
PrefixedName -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PrefixedName] -> ShowS
$cshowList :: [PrefixedName] -> ShowS
show :: PrefixedName -> String
$cshow :: PrefixedName -> String
showsPrec :: Int -> PrefixedName -> ShowS
$cshowsPrec :: Int -> PrefixedName -> ShowS
Show)

_PrefixedName :: Name
_PrefixedName = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.PrefixedName")

_PrefixedName_pnameLn :: FieldName
_PrefixedName_pnameLn = (String -> FieldName
Core.FieldName String
"pnameLn")

_PrefixedName_pnameNs :: FieldName
_PrefixedName_pnameNs = (String -> FieldName
Core.FieldName String
"pnameNs")

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

_BlankNode :: Name
_BlankNode = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.BlankNode")

data IncludeSet = 
  IncludeSet {
    IncludeSet -> [ShapeExprLabel]
includeSetListOfShapeExprLabel :: [ShapeExprLabel]}
  deriving (IncludeSet -> IncludeSet -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: IncludeSet -> IncludeSet -> Bool
$c/= :: IncludeSet -> IncludeSet -> Bool
== :: IncludeSet -> IncludeSet -> Bool
$c== :: IncludeSet -> IncludeSet -> Bool
Eq, Eq IncludeSet
IncludeSet -> IncludeSet -> Bool
IncludeSet -> IncludeSet -> Ordering
IncludeSet -> IncludeSet -> IncludeSet
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
min :: IncludeSet -> IncludeSet -> IncludeSet
$cmin :: IncludeSet -> IncludeSet -> IncludeSet
max :: IncludeSet -> IncludeSet -> IncludeSet
$cmax :: IncludeSet -> IncludeSet -> IncludeSet
>= :: IncludeSet -> IncludeSet -> Bool
$c>= :: IncludeSet -> IncludeSet -> Bool
> :: IncludeSet -> IncludeSet -> Bool
$c> :: IncludeSet -> IncludeSet -> Bool
<= :: IncludeSet -> IncludeSet -> Bool
$c<= :: IncludeSet -> IncludeSet -> Bool
< :: IncludeSet -> IncludeSet -> Bool
$c< :: IncludeSet -> IncludeSet -> Bool
compare :: IncludeSet -> IncludeSet -> Ordering
$ccompare :: IncludeSet -> IncludeSet -> Ordering
Ord, ReadPrec [IncludeSet]
ReadPrec IncludeSet
Int -> ReadS IncludeSet
ReadS [IncludeSet]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [IncludeSet]
$creadListPrec :: ReadPrec [IncludeSet]
readPrec :: ReadPrec IncludeSet
$creadPrec :: ReadPrec IncludeSet
readList :: ReadS [IncludeSet]
$creadList :: ReadS [IncludeSet]
readsPrec :: Int -> ReadS IncludeSet
$creadsPrec :: Int -> ReadS IncludeSet
Read, Int -> IncludeSet -> ShowS
[IncludeSet] -> ShowS
IncludeSet -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [IncludeSet] -> ShowS
$cshowList :: [IncludeSet] -> ShowS
show :: IncludeSet -> String
$cshow :: IncludeSet -> String
showsPrec :: Int -> IncludeSet -> ShowS
$cshowsPrec :: Int -> IncludeSet -> ShowS
Show)

_IncludeSet :: Name
_IncludeSet = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.IncludeSet")

_IncludeSet_listOfShapeExprLabel :: FieldName
_IncludeSet_listOfShapeExprLabel = (String -> FieldName
Core.FieldName String
"listOfShapeExprLabel")

data Code = 
  Code {
    Code -> [Code_ListOfAlts_Elmt]
codeListOfAlts :: [Code_ListOfAlts_Elmt]}
  deriving (Code -> Code -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Code -> Code -> Bool
$c/= :: Code -> Code -> Bool
== :: Code -> Code -> Bool
$c== :: Code -> Code -> Bool
Eq, Eq Code
Code -> Code -> Bool
Code -> Code -> Ordering
Code -> Code -> Code
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
min :: Code -> Code -> Code
$cmin :: Code -> Code -> Code
max :: Code -> Code -> Code
$cmax :: Code -> Code -> Code
>= :: Code -> Code -> Bool
$c>= :: Code -> Code -> Bool
> :: Code -> Code -> Bool
$c> :: Code -> Code -> Bool
<= :: Code -> Code -> Bool
$c<= :: Code -> Code -> Bool
< :: Code -> Code -> Bool
$c< :: Code -> Code -> Bool
compare :: Code -> Code -> Ordering
$ccompare :: Code -> Code -> Ordering
Ord, ReadPrec [Code]
ReadPrec Code
Int -> ReadS Code
ReadS [Code]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Code]
$creadListPrec :: ReadPrec [Code]
readPrec :: ReadPrec Code
$creadPrec :: ReadPrec Code
readList :: ReadS [Code]
$creadList :: ReadS [Code]
readsPrec :: Int -> ReadS Code
$creadsPrec :: Int -> ReadS Code
Read, Int -> Code -> ShowS
[Code] -> ShowS
Code -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Code] -> ShowS
$cshowList :: [Code] -> ShowS
show :: Code -> String
$cshow :: Code -> String
showsPrec :: Int -> Code -> ShowS
$cshowsPrec :: Int -> Code -> ShowS
Show)

_Code :: Name
_Code = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.Code")

_Code_listOfAlts :: FieldName
_Code_listOfAlts = (String -> FieldName
Core.FieldName String
"listOfAlts")

data Code_ListOfAlts_Elmt = 
  Code_ListOfAlts_ElmtRegex String |
  Code_ListOfAlts_ElmtSequence Code_ListOfAlts_Elmt_Sequence |
  Code_ListOfAlts_ElmtUchar Uchar
  deriving (Code_ListOfAlts_Elmt -> Code_ListOfAlts_Elmt -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Code_ListOfAlts_Elmt -> Code_ListOfAlts_Elmt -> Bool
$c/= :: Code_ListOfAlts_Elmt -> Code_ListOfAlts_Elmt -> Bool
== :: Code_ListOfAlts_Elmt -> Code_ListOfAlts_Elmt -> Bool
$c== :: Code_ListOfAlts_Elmt -> Code_ListOfAlts_Elmt -> Bool
Eq, Eq Code_ListOfAlts_Elmt
Code_ListOfAlts_Elmt -> Code_ListOfAlts_Elmt -> Bool
Code_ListOfAlts_Elmt -> Code_ListOfAlts_Elmt -> Ordering
Code_ListOfAlts_Elmt
-> Code_ListOfAlts_Elmt -> Code_ListOfAlts_Elmt
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
min :: Code_ListOfAlts_Elmt
-> Code_ListOfAlts_Elmt -> Code_ListOfAlts_Elmt
$cmin :: Code_ListOfAlts_Elmt
-> Code_ListOfAlts_Elmt -> Code_ListOfAlts_Elmt
max :: Code_ListOfAlts_Elmt
-> Code_ListOfAlts_Elmt -> Code_ListOfAlts_Elmt
$cmax :: Code_ListOfAlts_Elmt
-> Code_ListOfAlts_Elmt -> Code_ListOfAlts_Elmt
>= :: Code_ListOfAlts_Elmt -> Code_ListOfAlts_Elmt -> Bool
$c>= :: Code_ListOfAlts_Elmt -> Code_ListOfAlts_Elmt -> Bool
> :: Code_ListOfAlts_Elmt -> Code_ListOfAlts_Elmt -> Bool
$c> :: Code_ListOfAlts_Elmt -> Code_ListOfAlts_Elmt -> Bool
<= :: Code_ListOfAlts_Elmt -> Code_ListOfAlts_Elmt -> Bool
$c<= :: Code_ListOfAlts_Elmt -> Code_ListOfAlts_Elmt -> Bool
< :: Code_ListOfAlts_Elmt -> Code_ListOfAlts_Elmt -> Bool
$c< :: Code_ListOfAlts_Elmt -> Code_ListOfAlts_Elmt -> Bool
compare :: Code_ListOfAlts_Elmt -> Code_ListOfAlts_Elmt -> Ordering
$ccompare :: Code_ListOfAlts_Elmt -> Code_ListOfAlts_Elmt -> Ordering
Ord, ReadPrec [Code_ListOfAlts_Elmt]
ReadPrec Code_ListOfAlts_Elmt
Int -> ReadS Code_ListOfAlts_Elmt
ReadS [Code_ListOfAlts_Elmt]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Code_ListOfAlts_Elmt]
$creadListPrec :: ReadPrec [Code_ListOfAlts_Elmt]
readPrec :: ReadPrec Code_ListOfAlts_Elmt
$creadPrec :: ReadPrec Code_ListOfAlts_Elmt
readList :: ReadS [Code_ListOfAlts_Elmt]
$creadList :: ReadS [Code_ListOfAlts_Elmt]
readsPrec :: Int -> ReadS Code_ListOfAlts_Elmt
$creadsPrec :: Int -> ReadS Code_ListOfAlts_Elmt
Read, Int -> Code_ListOfAlts_Elmt -> ShowS
[Code_ListOfAlts_Elmt] -> ShowS
Code_ListOfAlts_Elmt -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Code_ListOfAlts_Elmt] -> ShowS
$cshowList :: [Code_ListOfAlts_Elmt] -> ShowS
show :: Code_ListOfAlts_Elmt -> String
$cshow :: Code_ListOfAlts_Elmt -> String
showsPrec :: Int -> Code_ListOfAlts_Elmt -> ShowS
$cshowsPrec :: Int -> Code_ListOfAlts_Elmt -> ShowS
Show)

_Code_ListOfAlts_Elmt :: Name
_Code_ListOfAlts_Elmt = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.Code.ListOfAlts.Elmt")

_Code_ListOfAlts_Elmt_regex :: FieldName
_Code_ListOfAlts_Elmt_regex = (String -> FieldName
Core.FieldName String
"regex")

_Code_ListOfAlts_Elmt_sequence :: FieldName
_Code_ListOfAlts_Elmt_sequence = (String -> FieldName
Core.FieldName String
"sequence")

_Code_ListOfAlts_Elmt_uchar :: FieldName
_Code_ListOfAlts_Elmt_uchar = (String -> FieldName
Core.FieldName String
"uchar")

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

_Code_ListOfAlts_Elmt_Sequence :: Name
_Code_ListOfAlts_Elmt_Sequence = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.Code.ListOfAlts.Elmt.Sequence")

_Code_ListOfAlts_Elmt_Sequence_regex :: FieldName
_Code_ListOfAlts_Elmt_Sequence_regex = (String -> FieldName
Core.FieldName String
"regex")

data RepeatRange = 
  RepeatRange {
    RepeatRange -> Integer_
repeatRangeInteger :: Integer_,
    RepeatRange -> Maybe RepeatRange_Sequence_Option
repeatRangeSequence :: (Maybe RepeatRange_Sequence_Option)}
  deriving (RepeatRange -> RepeatRange -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RepeatRange -> RepeatRange -> Bool
$c/= :: RepeatRange -> RepeatRange -> Bool
== :: RepeatRange -> RepeatRange -> Bool
$c== :: RepeatRange -> RepeatRange -> Bool
Eq, Eq RepeatRange
RepeatRange -> RepeatRange -> Bool
RepeatRange -> RepeatRange -> Ordering
RepeatRange -> RepeatRange -> RepeatRange
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
min :: RepeatRange -> RepeatRange -> RepeatRange
$cmin :: RepeatRange -> RepeatRange -> RepeatRange
max :: RepeatRange -> RepeatRange -> RepeatRange
$cmax :: RepeatRange -> RepeatRange -> RepeatRange
>= :: RepeatRange -> RepeatRange -> Bool
$c>= :: RepeatRange -> RepeatRange -> Bool
> :: RepeatRange -> RepeatRange -> Bool
$c> :: RepeatRange -> RepeatRange -> Bool
<= :: RepeatRange -> RepeatRange -> Bool
$c<= :: RepeatRange -> RepeatRange -> Bool
< :: RepeatRange -> RepeatRange -> Bool
$c< :: RepeatRange -> RepeatRange -> Bool
compare :: RepeatRange -> RepeatRange -> Ordering
$ccompare :: RepeatRange -> RepeatRange -> Ordering
Ord, ReadPrec [RepeatRange]
ReadPrec RepeatRange
Int -> ReadS RepeatRange
ReadS [RepeatRange]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [RepeatRange]
$creadListPrec :: ReadPrec [RepeatRange]
readPrec :: ReadPrec RepeatRange
$creadPrec :: ReadPrec RepeatRange
readList :: ReadS [RepeatRange]
$creadList :: ReadS [RepeatRange]
readsPrec :: Int -> ReadS RepeatRange
$creadsPrec :: Int -> ReadS RepeatRange
Read, Int -> RepeatRange -> ShowS
[RepeatRange] -> ShowS
RepeatRange -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RepeatRange] -> ShowS
$cshowList :: [RepeatRange] -> ShowS
show :: RepeatRange -> String
$cshow :: RepeatRange -> String
showsPrec :: Int -> RepeatRange -> ShowS
$cshowsPrec :: Int -> RepeatRange -> ShowS
Show)

_RepeatRange :: Name
_RepeatRange = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.RepeatRange")

_RepeatRange_integer :: FieldName
_RepeatRange_integer = (String -> FieldName
Core.FieldName String
"integer")

_RepeatRange_sequence :: FieldName
_RepeatRange_sequence = (String -> FieldName
Core.FieldName String
"sequence")

data RepeatRange_Sequence_Option = 
  RepeatRange_Sequence_Option {
    RepeatRange_Sequence_Option
-> Maybe (Maybe RepeatRange_Sequence_Option_Alts_Option_Option)
repeatRange_Sequence_OptionAlts :: (Maybe (Maybe RepeatRange_Sequence_Option_Alts_Option_Option))}
  deriving (RepeatRange_Sequence_Option -> RepeatRange_Sequence_Option -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RepeatRange_Sequence_Option -> RepeatRange_Sequence_Option -> Bool
$c/= :: RepeatRange_Sequence_Option -> RepeatRange_Sequence_Option -> Bool
== :: RepeatRange_Sequence_Option -> RepeatRange_Sequence_Option -> Bool
$c== :: RepeatRange_Sequence_Option -> RepeatRange_Sequence_Option -> Bool
Eq, Eq RepeatRange_Sequence_Option
RepeatRange_Sequence_Option -> RepeatRange_Sequence_Option -> Bool
RepeatRange_Sequence_Option
-> RepeatRange_Sequence_Option -> Ordering
RepeatRange_Sequence_Option
-> RepeatRange_Sequence_Option -> RepeatRange_Sequence_Option
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
min :: RepeatRange_Sequence_Option
-> RepeatRange_Sequence_Option -> RepeatRange_Sequence_Option
$cmin :: RepeatRange_Sequence_Option
-> RepeatRange_Sequence_Option -> RepeatRange_Sequence_Option
max :: RepeatRange_Sequence_Option
-> RepeatRange_Sequence_Option -> RepeatRange_Sequence_Option
$cmax :: RepeatRange_Sequence_Option
-> RepeatRange_Sequence_Option -> RepeatRange_Sequence_Option
>= :: RepeatRange_Sequence_Option -> RepeatRange_Sequence_Option -> Bool
$c>= :: RepeatRange_Sequence_Option -> RepeatRange_Sequence_Option -> Bool
> :: RepeatRange_Sequence_Option -> RepeatRange_Sequence_Option -> Bool
$c> :: RepeatRange_Sequence_Option -> RepeatRange_Sequence_Option -> Bool
<= :: RepeatRange_Sequence_Option -> RepeatRange_Sequence_Option -> Bool
$c<= :: RepeatRange_Sequence_Option -> RepeatRange_Sequence_Option -> Bool
< :: RepeatRange_Sequence_Option -> RepeatRange_Sequence_Option -> Bool
$c< :: RepeatRange_Sequence_Option -> RepeatRange_Sequence_Option -> Bool
compare :: RepeatRange_Sequence_Option
-> RepeatRange_Sequence_Option -> Ordering
$ccompare :: RepeatRange_Sequence_Option
-> RepeatRange_Sequence_Option -> Ordering
Ord, ReadPrec [RepeatRange_Sequence_Option]
ReadPrec RepeatRange_Sequence_Option
Int -> ReadS RepeatRange_Sequence_Option
ReadS [RepeatRange_Sequence_Option]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [RepeatRange_Sequence_Option]
$creadListPrec :: ReadPrec [RepeatRange_Sequence_Option]
readPrec :: ReadPrec RepeatRange_Sequence_Option
$creadPrec :: ReadPrec RepeatRange_Sequence_Option
readList :: ReadS [RepeatRange_Sequence_Option]
$creadList :: ReadS [RepeatRange_Sequence_Option]
readsPrec :: Int -> ReadS RepeatRange_Sequence_Option
$creadsPrec :: Int -> ReadS RepeatRange_Sequence_Option
Read, Int -> RepeatRange_Sequence_Option -> ShowS
[RepeatRange_Sequence_Option] -> ShowS
RepeatRange_Sequence_Option -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RepeatRange_Sequence_Option] -> ShowS
$cshowList :: [RepeatRange_Sequence_Option] -> ShowS
show :: RepeatRange_Sequence_Option -> String
$cshow :: RepeatRange_Sequence_Option -> String
showsPrec :: Int -> RepeatRange_Sequence_Option -> ShowS
$cshowsPrec :: Int -> RepeatRange_Sequence_Option -> ShowS
Show)

_RepeatRange_Sequence_Option :: Name
_RepeatRange_Sequence_Option = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.RepeatRange.Sequence.Option")

_RepeatRange_Sequence_Option_alts :: FieldName
_RepeatRange_Sequence_Option_alts = (String -> FieldName
Core.FieldName String
"alts")

data RepeatRange_Sequence_Option_Alts_Option_Option = 
  RepeatRange_Sequence_Option_Alts_Option_OptionInteger Integer_ |
  RepeatRange_Sequence_Option_Alts_Option_OptionAst 
  deriving (RepeatRange_Sequence_Option_Alts_Option_Option
-> RepeatRange_Sequence_Option_Alts_Option_Option -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RepeatRange_Sequence_Option_Alts_Option_Option
-> RepeatRange_Sequence_Option_Alts_Option_Option -> Bool
$c/= :: RepeatRange_Sequence_Option_Alts_Option_Option
-> RepeatRange_Sequence_Option_Alts_Option_Option -> Bool
== :: RepeatRange_Sequence_Option_Alts_Option_Option
-> RepeatRange_Sequence_Option_Alts_Option_Option -> Bool
$c== :: RepeatRange_Sequence_Option_Alts_Option_Option
-> RepeatRange_Sequence_Option_Alts_Option_Option -> Bool
Eq, Eq RepeatRange_Sequence_Option_Alts_Option_Option
RepeatRange_Sequence_Option_Alts_Option_Option
-> RepeatRange_Sequence_Option_Alts_Option_Option -> Bool
RepeatRange_Sequence_Option_Alts_Option_Option
-> RepeatRange_Sequence_Option_Alts_Option_Option -> Ordering
RepeatRange_Sequence_Option_Alts_Option_Option
-> RepeatRange_Sequence_Option_Alts_Option_Option
-> RepeatRange_Sequence_Option_Alts_Option_Option
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
min :: RepeatRange_Sequence_Option_Alts_Option_Option
-> RepeatRange_Sequence_Option_Alts_Option_Option
-> RepeatRange_Sequence_Option_Alts_Option_Option
$cmin :: RepeatRange_Sequence_Option_Alts_Option_Option
-> RepeatRange_Sequence_Option_Alts_Option_Option
-> RepeatRange_Sequence_Option_Alts_Option_Option
max :: RepeatRange_Sequence_Option_Alts_Option_Option
-> RepeatRange_Sequence_Option_Alts_Option_Option
-> RepeatRange_Sequence_Option_Alts_Option_Option
$cmax :: RepeatRange_Sequence_Option_Alts_Option_Option
-> RepeatRange_Sequence_Option_Alts_Option_Option
-> RepeatRange_Sequence_Option_Alts_Option_Option
>= :: RepeatRange_Sequence_Option_Alts_Option_Option
-> RepeatRange_Sequence_Option_Alts_Option_Option -> Bool
$c>= :: RepeatRange_Sequence_Option_Alts_Option_Option
-> RepeatRange_Sequence_Option_Alts_Option_Option -> Bool
> :: RepeatRange_Sequence_Option_Alts_Option_Option
-> RepeatRange_Sequence_Option_Alts_Option_Option -> Bool
$c> :: RepeatRange_Sequence_Option_Alts_Option_Option
-> RepeatRange_Sequence_Option_Alts_Option_Option -> Bool
<= :: RepeatRange_Sequence_Option_Alts_Option_Option
-> RepeatRange_Sequence_Option_Alts_Option_Option -> Bool
$c<= :: RepeatRange_Sequence_Option_Alts_Option_Option
-> RepeatRange_Sequence_Option_Alts_Option_Option -> Bool
< :: RepeatRange_Sequence_Option_Alts_Option_Option
-> RepeatRange_Sequence_Option_Alts_Option_Option -> Bool
$c< :: RepeatRange_Sequence_Option_Alts_Option_Option
-> RepeatRange_Sequence_Option_Alts_Option_Option -> Bool
compare :: RepeatRange_Sequence_Option_Alts_Option_Option
-> RepeatRange_Sequence_Option_Alts_Option_Option -> Ordering
$ccompare :: RepeatRange_Sequence_Option_Alts_Option_Option
-> RepeatRange_Sequence_Option_Alts_Option_Option -> Ordering
Ord, ReadPrec [RepeatRange_Sequence_Option_Alts_Option_Option]
ReadPrec RepeatRange_Sequence_Option_Alts_Option_Option
Int -> ReadS RepeatRange_Sequence_Option_Alts_Option_Option
ReadS [RepeatRange_Sequence_Option_Alts_Option_Option]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [RepeatRange_Sequence_Option_Alts_Option_Option]
$creadListPrec :: ReadPrec [RepeatRange_Sequence_Option_Alts_Option_Option]
readPrec :: ReadPrec RepeatRange_Sequence_Option_Alts_Option_Option
$creadPrec :: ReadPrec RepeatRange_Sequence_Option_Alts_Option_Option
readList :: ReadS [RepeatRange_Sequence_Option_Alts_Option_Option]
$creadList :: ReadS [RepeatRange_Sequence_Option_Alts_Option_Option]
readsPrec :: Int -> ReadS RepeatRange_Sequence_Option_Alts_Option_Option
$creadsPrec :: Int -> ReadS RepeatRange_Sequence_Option_Alts_Option_Option
Read, Int -> RepeatRange_Sequence_Option_Alts_Option_Option -> ShowS
[RepeatRange_Sequence_Option_Alts_Option_Option] -> ShowS
RepeatRange_Sequence_Option_Alts_Option_Option -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RepeatRange_Sequence_Option_Alts_Option_Option] -> ShowS
$cshowList :: [RepeatRange_Sequence_Option_Alts_Option_Option] -> ShowS
show :: RepeatRange_Sequence_Option_Alts_Option_Option -> String
$cshow :: RepeatRange_Sequence_Option_Alts_Option_Option -> String
showsPrec :: Int -> RepeatRange_Sequence_Option_Alts_Option_Option -> ShowS
$cshowsPrec :: Int -> RepeatRange_Sequence_Option_Alts_Option_Option -> ShowS
Show)

_RepeatRange_Sequence_Option_Alts_Option_Option :: Name
_RepeatRange_Sequence_Option_Alts_Option_Option = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.RepeatRange.Sequence.Option.Alts.Option.Option")

_RepeatRange_Sequence_Option_Alts_Option_Option_integer :: FieldName
_RepeatRange_Sequence_Option_Alts_Option_Option_integer = (String -> FieldName
Core.FieldName String
"integer")

_RepeatRange_Sequence_Option_Alts_Option_Option_ast :: FieldName
_RepeatRange_Sequence_Option_Alts_Option_Option_ast = (String -> FieldName
Core.FieldName String
"ast")

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

_RdfType :: Name
_RdfType = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.RdfType")

data IriRef = 
  IriRef {
    IriRef -> [IriRef_ListOfAlts_Elmt]
iriRefListOfAlts :: [IriRef_ListOfAlts_Elmt]}
  deriving (IriRef -> IriRef -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: IriRef -> IriRef -> Bool
$c/= :: IriRef -> IriRef -> Bool
== :: IriRef -> IriRef -> Bool
$c== :: IriRef -> IriRef -> Bool
Eq, Eq IriRef
IriRef -> IriRef -> Bool
IriRef -> IriRef -> Ordering
IriRef -> IriRef -> IriRef
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
min :: IriRef -> IriRef -> IriRef
$cmin :: IriRef -> IriRef -> IriRef
max :: IriRef -> IriRef -> IriRef
$cmax :: IriRef -> IriRef -> IriRef
>= :: IriRef -> IriRef -> Bool
$c>= :: IriRef -> IriRef -> Bool
> :: IriRef -> IriRef -> Bool
$c> :: IriRef -> IriRef -> Bool
<= :: IriRef -> IriRef -> Bool
$c<= :: IriRef -> IriRef -> Bool
< :: IriRef -> IriRef -> Bool
$c< :: IriRef -> IriRef -> Bool
compare :: IriRef -> IriRef -> Ordering
$ccompare :: IriRef -> IriRef -> Ordering
Ord, ReadPrec [IriRef]
ReadPrec IriRef
Int -> ReadS IriRef
ReadS [IriRef]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [IriRef]
$creadListPrec :: ReadPrec [IriRef]
readPrec :: ReadPrec IriRef
$creadPrec :: ReadPrec IriRef
readList :: ReadS [IriRef]
$creadList :: ReadS [IriRef]
readsPrec :: Int -> ReadS IriRef
$creadsPrec :: Int -> ReadS IriRef
Read, Int -> IriRef -> ShowS
[IriRef] -> ShowS
IriRef -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [IriRef] -> ShowS
$cshowList :: [IriRef] -> ShowS
show :: IriRef -> String
$cshow :: IriRef -> String
showsPrec :: Int -> IriRef -> ShowS
$cshowsPrec :: Int -> IriRef -> ShowS
Show)

_IriRef :: Name
_IriRef = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.IriRef")

_IriRef_listOfAlts :: FieldName
_IriRef_listOfAlts = (String -> FieldName
Core.FieldName String
"listOfAlts")

data IriRef_ListOfAlts_Elmt = 
  IriRef_ListOfAlts_ElmtRegex String |
  IriRef_ListOfAlts_ElmtUchar Uchar
  deriving (IriRef_ListOfAlts_Elmt -> IriRef_ListOfAlts_Elmt -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: IriRef_ListOfAlts_Elmt -> IriRef_ListOfAlts_Elmt -> Bool
$c/= :: IriRef_ListOfAlts_Elmt -> IriRef_ListOfAlts_Elmt -> Bool
== :: IriRef_ListOfAlts_Elmt -> IriRef_ListOfAlts_Elmt -> Bool
$c== :: IriRef_ListOfAlts_Elmt -> IriRef_ListOfAlts_Elmt -> Bool
Eq, Eq IriRef_ListOfAlts_Elmt
IriRef_ListOfAlts_Elmt -> IriRef_ListOfAlts_Elmt -> Bool
IriRef_ListOfAlts_Elmt -> IriRef_ListOfAlts_Elmt -> Ordering
IriRef_ListOfAlts_Elmt
-> IriRef_ListOfAlts_Elmt -> IriRef_ListOfAlts_Elmt
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
min :: IriRef_ListOfAlts_Elmt
-> IriRef_ListOfAlts_Elmt -> IriRef_ListOfAlts_Elmt
$cmin :: IriRef_ListOfAlts_Elmt
-> IriRef_ListOfAlts_Elmt -> IriRef_ListOfAlts_Elmt
max :: IriRef_ListOfAlts_Elmt
-> IriRef_ListOfAlts_Elmt -> IriRef_ListOfAlts_Elmt
$cmax :: IriRef_ListOfAlts_Elmt
-> IriRef_ListOfAlts_Elmt -> IriRef_ListOfAlts_Elmt
>= :: IriRef_ListOfAlts_Elmt -> IriRef_ListOfAlts_Elmt -> Bool
$c>= :: IriRef_ListOfAlts_Elmt -> IriRef_ListOfAlts_Elmt -> Bool
> :: IriRef_ListOfAlts_Elmt -> IriRef_ListOfAlts_Elmt -> Bool
$c> :: IriRef_ListOfAlts_Elmt -> IriRef_ListOfAlts_Elmt -> Bool
<= :: IriRef_ListOfAlts_Elmt -> IriRef_ListOfAlts_Elmt -> Bool
$c<= :: IriRef_ListOfAlts_Elmt -> IriRef_ListOfAlts_Elmt -> Bool
< :: IriRef_ListOfAlts_Elmt -> IriRef_ListOfAlts_Elmt -> Bool
$c< :: IriRef_ListOfAlts_Elmt -> IriRef_ListOfAlts_Elmt -> Bool
compare :: IriRef_ListOfAlts_Elmt -> IriRef_ListOfAlts_Elmt -> Ordering
$ccompare :: IriRef_ListOfAlts_Elmt -> IriRef_ListOfAlts_Elmt -> Ordering
Ord, ReadPrec [IriRef_ListOfAlts_Elmt]
ReadPrec IriRef_ListOfAlts_Elmt
Int -> ReadS IriRef_ListOfAlts_Elmt
ReadS [IriRef_ListOfAlts_Elmt]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [IriRef_ListOfAlts_Elmt]
$creadListPrec :: ReadPrec [IriRef_ListOfAlts_Elmt]
readPrec :: ReadPrec IriRef_ListOfAlts_Elmt
$creadPrec :: ReadPrec IriRef_ListOfAlts_Elmt
readList :: ReadS [IriRef_ListOfAlts_Elmt]
$creadList :: ReadS [IriRef_ListOfAlts_Elmt]
readsPrec :: Int -> ReadS IriRef_ListOfAlts_Elmt
$creadsPrec :: Int -> ReadS IriRef_ListOfAlts_Elmt
Read, Int -> IriRef_ListOfAlts_Elmt -> ShowS
[IriRef_ListOfAlts_Elmt] -> ShowS
IriRef_ListOfAlts_Elmt -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [IriRef_ListOfAlts_Elmt] -> ShowS
$cshowList :: [IriRef_ListOfAlts_Elmt] -> ShowS
show :: IriRef_ListOfAlts_Elmt -> String
$cshow :: IriRef_ListOfAlts_Elmt -> String
showsPrec :: Int -> IriRef_ListOfAlts_Elmt -> ShowS
$cshowsPrec :: Int -> IriRef_ListOfAlts_Elmt -> ShowS
Show)

_IriRef_ListOfAlts_Elmt :: Name
_IriRef_ListOfAlts_Elmt = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.IriRef.ListOfAlts.Elmt")

_IriRef_ListOfAlts_Elmt_regex :: FieldName
_IriRef_ListOfAlts_Elmt_regex = (String -> FieldName
Core.FieldName String
"regex")

_IriRef_ListOfAlts_Elmt_uchar :: FieldName
_IriRef_ListOfAlts_Elmt_uchar = (String -> FieldName
Core.FieldName String
"uchar")

data PnameNs = 
  PnameNs {
    PnameNs -> Maybe PnPrefix
pnameNsPnPrefix :: (Maybe PnPrefix)}
  deriving (PnameNs -> PnameNs -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PnameNs -> PnameNs -> Bool
$c/= :: PnameNs -> PnameNs -> Bool
== :: PnameNs -> PnameNs -> Bool
$c== :: PnameNs -> PnameNs -> Bool
Eq, Eq PnameNs
PnameNs -> PnameNs -> Bool
PnameNs -> PnameNs -> Ordering
PnameNs -> PnameNs -> PnameNs
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
min :: PnameNs -> PnameNs -> PnameNs
$cmin :: PnameNs -> PnameNs -> PnameNs
max :: PnameNs -> PnameNs -> PnameNs
$cmax :: PnameNs -> PnameNs -> PnameNs
>= :: PnameNs -> PnameNs -> Bool
$c>= :: PnameNs -> PnameNs -> Bool
> :: PnameNs -> PnameNs -> Bool
$c> :: PnameNs -> PnameNs -> Bool
<= :: PnameNs -> PnameNs -> Bool
$c<= :: PnameNs -> PnameNs -> Bool
< :: PnameNs -> PnameNs -> Bool
$c< :: PnameNs -> PnameNs -> Bool
compare :: PnameNs -> PnameNs -> Ordering
$ccompare :: PnameNs -> PnameNs -> Ordering
Ord, ReadPrec [PnameNs]
ReadPrec PnameNs
Int -> ReadS PnameNs
ReadS [PnameNs]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [PnameNs]
$creadListPrec :: ReadPrec [PnameNs]
readPrec :: ReadPrec PnameNs
$creadPrec :: ReadPrec PnameNs
readList :: ReadS [PnameNs]
$creadList :: ReadS [PnameNs]
readsPrec :: Int -> ReadS PnameNs
$creadsPrec :: Int -> ReadS PnameNs
Read, Int -> PnameNs -> ShowS
[PnameNs] -> ShowS
PnameNs -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PnameNs] -> ShowS
$cshowList :: [PnameNs] -> ShowS
show :: PnameNs -> String
$cshow :: PnameNs -> String
showsPrec :: Int -> PnameNs -> ShowS
$cshowsPrec :: Int -> PnameNs -> ShowS
Show)

_PnameNs :: Name
_PnameNs = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.PnameNs")

_PnameNs_pnPrefix :: FieldName
_PnameNs_pnPrefix = (String -> FieldName
Core.FieldName String
"pnPrefix")

data PnameLn = 
  PnameLn {
    PnameLn -> PnameNs
pnameLnPnameNs :: PnameNs,
    PnameLn -> PnLocal
pnameLnPnLocal :: PnLocal}
  deriving (PnameLn -> PnameLn -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PnameLn -> PnameLn -> Bool
$c/= :: PnameLn -> PnameLn -> Bool
== :: PnameLn -> PnameLn -> Bool
$c== :: PnameLn -> PnameLn -> Bool
Eq, Eq PnameLn
PnameLn -> PnameLn -> Bool
PnameLn -> PnameLn -> Ordering
PnameLn -> PnameLn -> PnameLn
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
min :: PnameLn -> PnameLn -> PnameLn
$cmin :: PnameLn -> PnameLn -> PnameLn
max :: PnameLn -> PnameLn -> PnameLn
$cmax :: PnameLn -> PnameLn -> PnameLn
>= :: PnameLn -> PnameLn -> Bool
$c>= :: PnameLn -> PnameLn -> Bool
> :: PnameLn -> PnameLn -> Bool
$c> :: PnameLn -> PnameLn -> Bool
<= :: PnameLn -> PnameLn -> Bool
$c<= :: PnameLn -> PnameLn -> Bool
< :: PnameLn -> PnameLn -> Bool
$c< :: PnameLn -> PnameLn -> Bool
compare :: PnameLn -> PnameLn -> Ordering
$ccompare :: PnameLn -> PnameLn -> Ordering
Ord, ReadPrec [PnameLn]
ReadPrec PnameLn
Int -> ReadS PnameLn
ReadS [PnameLn]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [PnameLn]
$creadListPrec :: ReadPrec [PnameLn]
readPrec :: ReadPrec PnameLn
$creadPrec :: ReadPrec PnameLn
readList :: ReadS [PnameLn]
$creadList :: ReadS [PnameLn]
readsPrec :: Int -> ReadS PnameLn
$creadsPrec :: Int -> ReadS PnameLn
Read, Int -> PnameLn -> ShowS
[PnameLn] -> ShowS
PnameLn -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PnameLn] -> ShowS
$cshowList :: [PnameLn] -> ShowS
show :: PnameLn -> String
$cshow :: PnameLn -> String
showsPrec :: Int -> PnameLn -> ShowS
$cshowsPrec :: Int -> PnameLn -> ShowS
Show)

_PnameLn :: Name
_PnameLn = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.PnameLn")

_PnameLn_pnameNs :: FieldName
_PnameLn_pnameNs = (String -> FieldName
Core.FieldName String
"pnameNs")

_PnameLn_pnLocal :: FieldName
_PnameLn_pnLocal = (String -> FieldName
Core.FieldName String
"pnLocal")

data AtpNameNs = 
  AtpNameNs {
    AtpNameNs -> Maybe PnPrefix
atpNameNsPnPrefix :: (Maybe PnPrefix)}
  deriving (AtpNameNs -> AtpNameNs -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AtpNameNs -> AtpNameNs -> Bool
$c/= :: AtpNameNs -> AtpNameNs -> Bool
== :: AtpNameNs -> AtpNameNs -> Bool
$c== :: AtpNameNs -> AtpNameNs -> Bool
Eq, Eq AtpNameNs
AtpNameNs -> AtpNameNs -> Bool
AtpNameNs -> AtpNameNs -> Ordering
AtpNameNs -> AtpNameNs -> AtpNameNs
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
min :: AtpNameNs -> AtpNameNs -> AtpNameNs
$cmin :: AtpNameNs -> AtpNameNs -> AtpNameNs
max :: AtpNameNs -> AtpNameNs -> AtpNameNs
$cmax :: AtpNameNs -> AtpNameNs -> AtpNameNs
>= :: AtpNameNs -> AtpNameNs -> Bool
$c>= :: AtpNameNs -> AtpNameNs -> Bool
> :: AtpNameNs -> AtpNameNs -> Bool
$c> :: AtpNameNs -> AtpNameNs -> Bool
<= :: AtpNameNs -> AtpNameNs -> Bool
$c<= :: AtpNameNs -> AtpNameNs -> Bool
< :: AtpNameNs -> AtpNameNs -> Bool
$c< :: AtpNameNs -> AtpNameNs -> Bool
compare :: AtpNameNs -> AtpNameNs -> Ordering
$ccompare :: AtpNameNs -> AtpNameNs -> Ordering
Ord, ReadPrec [AtpNameNs]
ReadPrec AtpNameNs
Int -> ReadS AtpNameNs
ReadS [AtpNameNs]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [AtpNameNs]
$creadListPrec :: ReadPrec [AtpNameNs]
readPrec :: ReadPrec AtpNameNs
$creadPrec :: ReadPrec AtpNameNs
readList :: ReadS [AtpNameNs]
$creadList :: ReadS [AtpNameNs]
readsPrec :: Int -> ReadS AtpNameNs
$creadsPrec :: Int -> ReadS AtpNameNs
Read, Int -> AtpNameNs -> ShowS
[AtpNameNs] -> ShowS
AtpNameNs -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AtpNameNs] -> ShowS
$cshowList :: [AtpNameNs] -> ShowS
show :: AtpNameNs -> String
$cshow :: AtpNameNs -> String
showsPrec :: Int -> AtpNameNs -> ShowS
$cshowsPrec :: Int -> AtpNameNs -> ShowS
Show)

_AtpNameNs :: Name
_AtpNameNs = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.AtpNameNs")

_AtpNameNs_pnPrefix :: FieldName
_AtpNameNs_pnPrefix = (String -> FieldName
Core.FieldName String
"pnPrefix")

data AtpNameLn = 
  AtpNameLn {
    AtpNameLn -> PnameNs
atpNameLnPnameNs :: PnameNs,
    AtpNameLn -> PnLocal
atpNameLnPnLocal :: PnLocal}
  deriving (AtpNameLn -> AtpNameLn -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AtpNameLn -> AtpNameLn -> Bool
$c/= :: AtpNameLn -> AtpNameLn -> Bool
== :: AtpNameLn -> AtpNameLn -> Bool
$c== :: AtpNameLn -> AtpNameLn -> Bool
Eq, Eq AtpNameLn
AtpNameLn -> AtpNameLn -> Bool
AtpNameLn -> AtpNameLn -> Ordering
AtpNameLn -> AtpNameLn -> AtpNameLn
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
min :: AtpNameLn -> AtpNameLn -> AtpNameLn
$cmin :: AtpNameLn -> AtpNameLn -> AtpNameLn
max :: AtpNameLn -> AtpNameLn -> AtpNameLn
$cmax :: AtpNameLn -> AtpNameLn -> AtpNameLn
>= :: AtpNameLn -> AtpNameLn -> Bool
$c>= :: AtpNameLn -> AtpNameLn -> Bool
> :: AtpNameLn -> AtpNameLn -> Bool
$c> :: AtpNameLn -> AtpNameLn -> Bool
<= :: AtpNameLn -> AtpNameLn -> Bool
$c<= :: AtpNameLn -> AtpNameLn -> Bool
< :: AtpNameLn -> AtpNameLn -> Bool
$c< :: AtpNameLn -> AtpNameLn -> Bool
compare :: AtpNameLn -> AtpNameLn -> Ordering
$ccompare :: AtpNameLn -> AtpNameLn -> Ordering
Ord, ReadPrec [AtpNameLn]
ReadPrec AtpNameLn
Int -> ReadS AtpNameLn
ReadS [AtpNameLn]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [AtpNameLn]
$creadListPrec :: ReadPrec [AtpNameLn]
readPrec :: ReadPrec AtpNameLn
$creadPrec :: ReadPrec AtpNameLn
readList :: ReadS [AtpNameLn]
$creadList :: ReadS [AtpNameLn]
readsPrec :: Int -> ReadS AtpNameLn
$creadsPrec :: Int -> ReadS AtpNameLn
Read, Int -> AtpNameLn -> ShowS
[AtpNameLn] -> ShowS
AtpNameLn -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AtpNameLn] -> ShowS
$cshowList :: [AtpNameLn] -> ShowS
show :: AtpNameLn -> String
$cshow :: AtpNameLn -> String
showsPrec :: Int -> AtpNameLn -> ShowS
$cshowsPrec :: Int -> AtpNameLn -> ShowS
Show)

_AtpNameLn :: Name
_AtpNameLn = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.AtpNameLn")

_AtpNameLn_pnameNs :: FieldName
_AtpNameLn_pnameNs = (String -> FieldName
Core.FieldName String
"pnameNs")

_AtpNameLn_pnLocal :: FieldName
_AtpNameLn_pnLocal = (String -> FieldName
Core.FieldName String
"pnLocal")

data Regexp = 
  Regexp {
    Regexp -> [Regexp_ListOfAlts_Elmt]
regexpListOfAlts :: [Regexp_ListOfAlts_Elmt],
    Regexp -> [String]
regexpListOfRegex :: [String]}
  deriving (Regexp -> Regexp -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Regexp -> Regexp -> Bool
$c/= :: Regexp -> Regexp -> Bool
== :: Regexp -> Regexp -> Bool
$c== :: Regexp -> Regexp -> Bool
Eq, Eq Regexp
Regexp -> Regexp -> Bool
Regexp -> Regexp -> Ordering
Regexp -> Regexp -> Regexp
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
min :: Regexp -> Regexp -> Regexp
$cmin :: Regexp -> Regexp -> Regexp
max :: Regexp -> Regexp -> Regexp
$cmax :: Regexp -> Regexp -> Regexp
>= :: Regexp -> Regexp -> Bool
$c>= :: Regexp -> Regexp -> Bool
> :: Regexp -> Regexp -> Bool
$c> :: Regexp -> Regexp -> Bool
<= :: Regexp -> Regexp -> Bool
$c<= :: Regexp -> Regexp -> Bool
< :: Regexp -> Regexp -> Bool
$c< :: Regexp -> Regexp -> Bool
compare :: Regexp -> Regexp -> Ordering
$ccompare :: Regexp -> Regexp -> Ordering
Ord, ReadPrec [Regexp]
ReadPrec Regexp
Int -> ReadS Regexp
ReadS [Regexp]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Regexp]
$creadListPrec :: ReadPrec [Regexp]
readPrec :: ReadPrec Regexp
$creadPrec :: ReadPrec Regexp
readList :: ReadS [Regexp]
$creadList :: ReadS [Regexp]
readsPrec :: Int -> ReadS Regexp
$creadsPrec :: Int -> ReadS Regexp
Read, Int -> Regexp -> ShowS
[Regexp] -> ShowS
Regexp -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Regexp] -> ShowS
$cshowList :: [Regexp] -> ShowS
show :: Regexp -> String
$cshow :: Regexp -> String
showsPrec :: Int -> Regexp -> ShowS
$cshowsPrec :: Int -> Regexp -> ShowS
Show)

_Regexp :: Name
_Regexp = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.Regexp")

_Regexp_listOfAlts :: FieldName
_Regexp_listOfAlts = (String -> FieldName
Core.FieldName String
"listOfAlts")

_Regexp_listOfRegex :: FieldName
_Regexp_listOfRegex = (String -> FieldName
Core.FieldName String
"listOfRegex")

data Regexp_ListOfAlts_Elmt = 
  Regexp_ListOfAlts_ElmtRegex String |
  Regexp_ListOfAlts_ElmtSequence Regexp_ListOfAlts_Elmt_Sequence |
  Regexp_ListOfAlts_ElmtUchar Uchar
  deriving (Regexp_ListOfAlts_Elmt -> Regexp_ListOfAlts_Elmt -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Regexp_ListOfAlts_Elmt -> Regexp_ListOfAlts_Elmt -> Bool
$c/= :: Regexp_ListOfAlts_Elmt -> Regexp_ListOfAlts_Elmt -> Bool
== :: Regexp_ListOfAlts_Elmt -> Regexp_ListOfAlts_Elmt -> Bool
$c== :: Regexp_ListOfAlts_Elmt -> Regexp_ListOfAlts_Elmt -> Bool
Eq, Eq Regexp_ListOfAlts_Elmt
Regexp_ListOfAlts_Elmt -> Regexp_ListOfAlts_Elmt -> Bool
Regexp_ListOfAlts_Elmt -> Regexp_ListOfAlts_Elmt -> Ordering
Regexp_ListOfAlts_Elmt
-> Regexp_ListOfAlts_Elmt -> Regexp_ListOfAlts_Elmt
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
min :: Regexp_ListOfAlts_Elmt
-> Regexp_ListOfAlts_Elmt -> Regexp_ListOfAlts_Elmt
$cmin :: Regexp_ListOfAlts_Elmt
-> Regexp_ListOfAlts_Elmt -> Regexp_ListOfAlts_Elmt
max :: Regexp_ListOfAlts_Elmt
-> Regexp_ListOfAlts_Elmt -> Regexp_ListOfAlts_Elmt
$cmax :: Regexp_ListOfAlts_Elmt
-> Regexp_ListOfAlts_Elmt -> Regexp_ListOfAlts_Elmt
>= :: Regexp_ListOfAlts_Elmt -> Regexp_ListOfAlts_Elmt -> Bool
$c>= :: Regexp_ListOfAlts_Elmt -> Regexp_ListOfAlts_Elmt -> Bool
> :: Regexp_ListOfAlts_Elmt -> Regexp_ListOfAlts_Elmt -> Bool
$c> :: Regexp_ListOfAlts_Elmt -> Regexp_ListOfAlts_Elmt -> Bool
<= :: Regexp_ListOfAlts_Elmt -> Regexp_ListOfAlts_Elmt -> Bool
$c<= :: Regexp_ListOfAlts_Elmt -> Regexp_ListOfAlts_Elmt -> Bool
< :: Regexp_ListOfAlts_Elmt -> Regexp_ListOfAlts_Elmt -> Bool
$c< :: Regexp_ListOfAlts_Elmt -> Regexp_ListOfAlts_Elmt -> Bool
compare :: Regexp_ListOfAlts_Elmt -> Regexp_ListOfAlts_Elmt -> Ordering
$ccompare :: Regexp_ListOfAlts_Elmt -> Regexp_ListOfAlts_Elmt -> Ordering
Ord, ReadPrec [Regexp_ListOfAlts_Elmt]
ReadPrec Regexp_ListOfAlts_Elmt
Int -> ReadS Regexp_ListOfAlts_Elmt
ReadS [Regexp_ListOfAlts_Elmt]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Regexp_ListOfAlts_Elmt]
$creadListPrec :: ReadPrec [Regexp_ListOfAlts_Elmt]
readPrec :: ReadPrec Regexp_ListOfAlts_Elmt
$creadPrec :: ReadPrec Regexp_ListOfAlts_Elmt
readList :: ReadS [Regexp_ListOfAlts_Elmt]
$creadList :: ReadS [Regexp_ListOfAlts_Elmt]
readsPrec :: Int -> ReadS Regexp_ListOfAlts_Elmt
$creadsPrec :: Int -> ReadS Regexp_ListOfAlts_Elmt
Read, Int -> Regexp_ListOfAlts_Elmt -> ShowS
[Regexp_ListOfAlts_Elmt] -> ShowS
Regexp_ListOfAlts_Elmt -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Regexp_ListOfAlts_Elmt] -> ShowS
$cshowList :: [Regexp_ListOfAlts_Elmt] -> ShowS
show :: Regexp_ListOfAlts_Elmt -> String
$cshow :: Regexp_ListOfAlts_Elmt -> String
showsPrec :: Int -> Regexp_ListOfAlts_Elmt -> ShowS
$cshowsPrec :: Int -> Regexp_ListOfAlts_Elmt -> ShowS
Show)

_Regexp_ListOfAlts_Elmt :: Name
_Regexp_ListOfAlts_Elmt = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.Regexp.ListOfAlts.Elmt")

_Regexp_ListOfAlts_Elmt_regex :: FieldName
_Regexp_ListOfAlts_Elmt_regex = (String -> FieldName
Core.FieldName String
"regex")

_Regexp_ListOfAlts_Elmt_sequence :: FieldName
_Regexp_ListOfAlts_Elmt_sequence = (String -> FieldName
Core.FieldName String
"sequence")

_Regexp_ListOfAlts_Elmt_uchar :: FieldName
_Regexp_ListOfAlts_Elmt_uchar = (String -> FieldName
Core.FieldName String
"uchar")

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

_Regexp_ListOfAlts_Elmt_Sequence :: Name
_Regexp_ListOfAlts_Elmt_Sequence = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.Regexp.ListOfAlts.Elmt.Sequence")

_Regexp_ListOfAlts_Elmt_Sequence_regex :: FieldName
_Regexp_ListOfAlts_Elmt_Sequence_regex = (String -> FieldName
Core.FieldName String
"regex")

data BlankNodeLabel = 
  BlankNodeLabel {
    BlankNodeLabel -> BlankNodeLabel_Alts
blankNodeLabelAlts :: BlankNodeLabel_Alts,
    BlankNodeLabel -> Maybe [BlankNodeLabel_ListOfAlts_Option_Elmt]
blankNodeLabelListOfAlts :: (Maybe [BlankNodeLabel_ListOfAlts_Option_Elmt]),
    BlankNodeLabel -> PnChars
blankNodeLabelPnChars :: PnChars}
  deriving (BlankNodeLabel -> BlankNodeLabel -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BlankNodeLabel -> BlankNodeLabel -> Bool
$c/= :: BlankNodeLabel -> BlankNodeLabel -> Bool
== :: BlankNodeLabel -> BlankNodeLabel -> Bool
$c== :: BlankNodeLabel -> BlankNodeLabel -> Bool
Eq, Eq BlankNodeLabel
BlankNodeLabel -> BlankNodeLabel -> Bool
BlankNodeLabel -> BlankNodeLabel -> Ordering
BlankNodeLabel -> BlankNodeLabel -> BlankNodeLabel
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
min :: BlankNodeLabel -> BlankNodeLabel -> BlankNodeLabel
$cmin :: BlankNodeLabel -> BlankNodeLabel -> BlankNodeLabel
max :: BlankNodeLabel -> BlankNodeLabel -> BlankNodeLabel
$cmax :: BlankNodeLabel -> BlankNodeLabel -> BlankNodeLabel
>= :: BlankNodeLabel -> BlankNodeLabel -> Bool
$c>= :: BlankNodeLabel -> BlankNodeLabel -> Bool
> :: BlankNodeLabel -> BlankNodeLabel -> Bool
$c> :: BlankNodeLabel -> BlankNodeLabel -> Bool
<= :: BlankNodeLabel -> BlankNodeLabel -> Bool
$c<= :: BlankNodeLabel -> BlankNodeLabel -> Bool
< :: BlankNodeLabel -> BlankNodeLabel -> Bool
$c< :: BlankNodeLabel -> BlankNodeLabel -> Bool
compare :: BlankNodeLabel -> BlankNodeLabel -> Ordering
$ccompare :: BlankNodeLabel -> BlankNodeLabel -> Ordering
Ord, ReadPrec [BlankNodeLabel]
ReadPrec BlankNodeLabel
Int -> ReadS BlankNodeLabel
ReadS [BlankNodeLabel]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [BlankNodeLabel]
$creadListPrec :: ReadPrec [BlankNodeLabel]
readPrec :: ReadPrec BlankNodeLabel
$creadPrec :: ReadPrec BlankNodeLabel
readList :: ReadS [BlankNodeLabel]
$creadList :: ReadS [BlankNodeLabel]
readsPrec :: Int -> ReadS BlankNodeLabel
$creadsPrec :: Int -> ReadS BlankNodeLabel
Read, Int -> BlankNodeLabel -> ShowS
[BlankNodeLabel] -> ShowS
BlankNodeLabel -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BlankNodeLabel] -> ShowS
$cshowList :: [BlankNodeLabel] -> ShowS
show :: BlankNodeLabel -> String
$cshow :: BlankNodeLabel -> String
showsPrec :: Int -> BlankNodeLabel -> ShowS
$cshowsPrec :: Int -> BlankNodeLabel -> ShowS
Show)

_BlankNodeLabel :: Name
_BlankNodeLabel = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.BlankNodeLabel")

_BlankNodeLabel_alts :: FieldName
_BlankNodeLabel_alts = (String -> FieldName
Core.FieldName String
"alts")

_BlankNodeLabel_listOfAlts :: FieldName
_BlankNodeLabel_listOfAlts = (String -> FieldName
Core.FieldName String
"listOfAlts")

_BlankNodeLabel_pnChars :: FieldName
_BlankNodeLabel_pnChars = (String -> FieldName
Core.FieldName String
"pnChars")

data BlankNodeLabel_Alts = 
  BlankNodeLabel_AltsPnCharsU PnCharsU |
  BlankNodeLabel_AltsRegex String
  deriving (BlankNodeLabel_Alts -> BlankNodeLabel_Alts -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BlankNodeLabel_Alts -> BlankNodeLabel_Alts -> Bool
$c/= :: BlankNodeLabel_Alts -> BlankNodeLabel_Alts -> Bool
== :: BlankNodeLabel_Alts -> BlankNodeLabel_Alts -> Bool
$c== :: BlankNodeLabel_Alts -> BlankNodeLabel_Alts -> Bool
Eq, Eq BlankNodeLabel_Alts
BlankNodeLabel_Alts -> BlankNodeLabel_Alts -> Bool
BlankNodeLabel_Alts -> BlankNodeLabel_Alts -> Ordering
BlankNodeLabel_Alts -> BlankNodeLabel_Alts -> BlankNodeLabel_Alts
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
min :: BlankNodeLabel_Alts -> BlankNodeLabel_Alts -> BlankNodeLabel_Alts
$cmin :: BlankNodeLabel_Alts -> BlankNodeLabel_Alts -> BlankNodeLabel_Alts
max :: BlankNodeLabel_Alts -> BlankNodeLabel_Alts -> BlankNodeLabel_Alts
$cmax :: BlankNodeLabel_Alts -> BlankNodeLabel_Alts -> BlankNodeLabel_Alts
>= :: BlankNodeLabel_Alts -> BlankNodeLabel_Alts -> Bool
$c>= :: BlankNodeLabel_Alts -> BlankNodeLabel_Alts -> Bool
> :: BlankNodeLabel_Alts -> BlankNodeLabel_Alts -> Bool
$c> :: BlankNodeLabel_Alts -> BlankNodeLabel_Alts -> Bool
<= :: BlankNodeLabel_Alts -> BlankNodeLabel_Alts -> Bool
$c<= :: BlankNodeLabel_Alts -> BlankNodeLabel_Alts -> Bool
< :: BlankNodeLabel_Alts -> BlankNodeLabel_Alts -> Bool
$c< :: BlankNodeLabel_Alts -> BlankNodeLabel_Alts -> Bool
compare :: BlankNodeLabel_Alts -> BlankNodeLabel_Alts -> Ordering
$ccompare :: BlankNodeLabel_Alts -> BlankNodeLabel_Alts -> Ordering
Ord, ReadPrec [BlankNodeLabel_Alts]
ReadPrec BlankNodeLabel_Alts
Int -> ReadS BlankNodeLabel_Alts
ReadS [BlankNodeLabel_Alts]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [BlankNodeLabel_Alts]
$creadListPrec :: ReadPrec [BlankNodeLabel_Alts]
readPrec :: ReadPrec BlankNodeLabel_Alts
$creadPrec :: ReadPrec BlankNodeLabel_Alts
readList :: ReadS [BlankNodeLabel_Alts]
$creadList :: ReadS [BlankNodeLabel_Alts]
readsPrec :: Int -> ReadS BlankNodeLabel_Alts
$creadsPrec :: Int -> ReadS BlankNodeLabel_Alts
Read, Int -> BlankNodeLabel_Alts -> ShowS
[BlankNodeLabel_Alts] -> ShowS
BlankNodeLabel_Alts -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BlankNodeLabel_Alts] -> ShowS
$cshowList :: [BlankNodeLabel_Alts] -> ShowS
show :: BlankNodeLabel_Alts -> String
$cshow :: BlankNodeLabel_Alts -> String
showsPrec :: Int -> BlankNodeLabel_Alts -> ShowS
$cshowsPrec :: Int -> BlankNodeLabel_Alts -> ShowS
Show)

_BlankNodeLabel_Alts :: Name
_BlankNodeLabel_Alts = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.BlankNodeLabel.Alts")

_BlankNodeLabel_Alts_pnCharsU :: FieldName
_BlankNodeLabel_Alts_pnCharsU = (String -> FieldName
Core.FieldName String
"pnCharsU")

_BlankNodeLabel_Alts_regex :: FieldName
_BlankNodeLabel_Alts_regex = (String -> FieldName
Core.FieldName String
"regex")

data BlankNodeLabel_ListOfAlts_Option_Elmt = 
  BlankNodeLabel_ListOfAlts_Option_ElmtPnChars PnChars |
  BlankNodeLabel_ListOfAlts_Option_ElmtPeriod 
  deriving (BlankNodeLabel_ListOfAlts_Option_Elmt
-> BlankNodeLabel_ListOfAlts_Option_Elmt -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BlankNodeLabel_ListOfAlts_Option_Elmt
-> BlankNodeLabel_ListOfAlts_Option_Elmt -> Bool
$c/= :: BlankNodeLabel_ListOfAlts_Option_Elmt
-> BlankNodeLabel_ListOfAlts_Option_Elmt -> Bool
== :: BlankNodeLabel_ListOfAlts_Option_Elmt
-> BlankNodeLabel_ListOfAlts_Option_Elmt -> Bool
$c== :: BlankNodeLabel_ListOfAlts_Option_Elmt
-> BlankNodeLabel_ListOfAlts_Option_Elmt -> Bool
Eq, Eq BlankNodeLabel_ListOfAlts_Option_Elmt
BlankNodeLabel_ListOfAlts_Option_Elmt
-> BlankNodeLabel_ListOfAlts_Option_Elmt -> Bool
BlankNodeLabel_ListOfAlts_Option_Elmt
-> BlankNodeLabel_ListOfAlts_Option_Elmt -> Ordering
BlankNodeLabel_ListOfAlts_Option_Elmt
-> BlankNodeLabel_ListOfAlts_Option_Elmt
-> BlankNodeLabel_ListOfAlts_Option_Elmt
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
min :: BlankNodeLabel_ListOfAlts_Option_Elmt
-> BlankNodeLabel_ListOfAlts_Option_Elmt
-> BlankNodeLabel_ListOfAlts_Option_Elmt
$cmin :: BlankNodeLabel_ListOfAlts_Option_Elmt
-> BlankNodeLabel_ListOfAlts_Option_Elmt
-> BlankNodeLabel_ListOfAlts_Option_Elmt
max :: BlankNodeLabel_ListOfAlts_Option_Elmt
-> BlankNodeLabel_ListOfAlts_Option_Elmt
-> BlankNodeLabel_ListOfAlts_Option_Elmt
$cmax :: BlankNodeLabel_ListOfAlts_Option_Elmt
-> BlankNodeLabel_ListOfAlts_Option_Elmt
-> BlankNodeLabel_ListOfAlts_Option_Elmt
>= :: BlankNodeLabel_ListOfAlts_Option_Elmt
-> BlankNodeLabel_ListOfAlts_Option_Elmt -> Bool
$c>= :: BlankNodeLabel_ListOfAlts_Option_Elmt
-> BlankNodeLabel_ListOfAlts_Option_Elmt -> Bool
> :: BlankNodeLabel_ListOfAlts_Option_Elmt
-> BlankNodeLabel_ListOfAlts_Option_Elmt -> Bool
$c> :: BlankNodeLabel_ListOfAlts_Option_Elmt
-> BlankNodeLabel_ListOfAlts_Option_Elmt -> Bool
<= :: BlankNodeLabel_ListOfAlts_Option_Elmt
-> BlankNodeLabel_ListOfAlts_Option_Elmt -> Bool
$c<= :: BlankNodeLabel_ListOfAlts_Option_Elmt
-> BlankNodeLabel_ListOfAlts_Option_Elmt -> Bool
< :: BlankNodeLabel_ListOfAlts_Option_Elmt
-> BlankNodeLabel_ListOfAlts_Option_Elmt -> Bool
$c< :: BlankNodeLabel_ListOfAlts_Option_Elmt
-> BlankNodeLabel_ListOfAlts_Option_Elmt -> Bool
compare :: BlankNodeLabel_ListOfAlts_Option_Elmt
-> BlankNodeLabel_ListOfAlts_Option_Elmt -> Ordering
$ccompare :: BlankNodeLabel_ListOfAlts_Option_Elmt
-> BlankNodeLabel_ListOfAlts_Option_Elmt -> Ordering
Ord, ReadPrec [BlankNodeLabel_ListOfAlts_Option_Elmt]
ReadPrec BlankNodeLabel_ListOfAlts_Option_Elmt
Int -> ReadS BlankNodeLabel_ListOfAlts_Option_Elmt
ReadS [BlankNodeLabel_ListOfAlts_Option_Elmt]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [BlankNodeLabel_ListOfAlts_Option_Elmt]
$creadListPrec :: ReadPrec [BlankNodeLabel_ListOfAlts_Option_Elmt]
readPrec :: ReadPrec BlankNodeLabel_ListOfAlts_Option_Elmt
$creadPrec :: ReadPrec BlankNodeLabel_ListOfAlts_Option_Elmt
readList :: ReadS [BlankNodeLabel_ListOfAlts_Option_Elmt]
$creadList :: ReadS [BlankNodeLabel_ListOfAlts_Option_Elmt]
readsPrec :: Int -> ReadS BlankNodeLabel_ListOfAlts_Option_Elmt
$creadsPrec :: Int -> ReadS BlankNodeLabel_ListOfAlts_Option_Elmt
Read, Int -> BlankNodeLabel_ListOfAlts_Option_Elmt -> ShowS
[BlankNodeLabel_ListOfAlts_Option_Elmt] -> ShowS
BlankNodeLabel_ListOfAlts_Option_Elmt -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BlankNodeLabel_ListOfAlts_Option_Elmt] -> ShowS
$cshowList :: [BlankNodeLabel_ListOfAlts_Option_Elmt] -> ShowS
show :: BlankNodeLabel_ListOfAlts_Option_Elmt -> String
$cshow :: BlankNodeLabel_ListOfAlts_Option_Elmt -> String
showsPrec :: Int -> BlankNodeLabel_ListOfAlts_Option_Elmt -> ShowS
$cshowsPrec :: Int -> BlankNodeLabel_ListOfAlts_Option_Elmt -> ShowS
Show)

_BlankNodeLabel_ListOfAlts_Option_Elmt :: Name
_BlankNodeLabel_ListOfAlts_Option_Elmt = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.BlankNodeLabel.ListOfAlts.Option.Elmt")

_BlankNodeLabel_ListOfAlts_Option_Elmt_pnChars :: FieldName
_BlankNodeLabel_ListOfAlts_Option_Elmt_pnChars = (String -> FieldName
Core.FieldName String
"pnChars")

_BlankNodeLabel_ListOfAlts_Option_Elmt_period :: FieldName
_BlankNodeLabel_ListOfAlts_Option_Elmt_period = (String -> FieldName
Core.FieldName String
"period")

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

_LangTag :: Name
_LangTag = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.LangTag")

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

_Integer :: Name
_Integer = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.Integer")

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

_Decimal :: Name
_Decimal = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.Decimal")

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

_Double :: Name
_Double = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.Double")

data StringLiteral1 = 
  StringLiteral1 {
    StringLiteral1 -> [StringLiteral1_ListOfAlts_Elmt]
stringLiteral1ListOfAlts :: [StringLiteral1_ListOfAlts_Elmt]}
  deriving (StringLiteral1 -> StringLiteral1 -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StringLiteral1 -> StringLiteral1 -> Bool
$c/= :: StringLiteral1 -> StringLiteral1 -> Bool
== :: StringLiteral1 -> StringLiteral1 -> Bool
$c== :: StringLiteral1 -> StringLiteral1 -> Bool
Eq, Eq StringLiteral1
StringLiteral1 -> StringLiteral1 -> Bool
StringLiteral1 -> StringLiteral1 -> Ordering
StringLiteral1 -> StringLiteral1 -> StringLiteral1
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
min :: StringLiteral1 -> StringLiteral1 -> StringLiteral1
$cmin :: StringLiteral1 -> StringLiteral1 -> StringLiteral1
max :: StringLiteral1 -> StringLiteral1 -> StringLiteral1
$cmax :: StringLiteral1 -> StringLiteral1 -> StringLiteral1
>= :: StringLiteral1 -> StringLiteral1 -> Bool
$c>= :: StringLiteral1 -> StringLiteral1 -> Bool
> :: StringLiteral1 -> StringLiteral1 -> Bool
$c> :: StringLiteral1 -> StringLiteral1 -> Bool
<= :: StringLiteral1 -> StringLiteral1 -> Bool
$c<= :: StringLiteral1 -> StringLiteral1 -> Bool
< :: StringLiteral1 -> StringLiteral1 -> Bool
$c< :: StringLiteral1 -> StringLiteral1 -> Bool
compare :: StringLiteral1 -> StringLiteral1 -> Ordering
$ccompare :: StringLiteral1 -> StringLiteral1 -> Ordering
Ord, ReadPrec [StringLiteral1]
ReadPrec StringLiteral1
Int -> ReadS StringLiteral1
ReadS [StringLiteral1]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [StringLiteral1]
$creadListPrec :: ReadPrec [StringLiteral1]
readPrec :: ReadPrec StringLiteral1
$creadPrec :: ReadPrec StringLiteral1
readList :: ReadS [StringLiteral1]
$creadList :: ReadS [StringLiteral1]
readsPrec :: Int -> ReadS StringLiteral1
$creadsPrec :: Int -> ReadS StringLiteral1
Read, Int -> StringLiteral1 -> ShowS
[StringLiteral1] -> ShowS
StringLiteral1 -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StringLiteral1] -> ShowS
$cshowList :: [StringLiteral1] -> ShowS
show :: StringLiteral1 -> String
$cshow :: StringLiteral1 -> String
showsPrec :: Int -> StringLiteral1 -> ShowS
$cshowsPrec :: Int -> StringLiteral1 -> ShowS
Show)

_StringLiteral1 :: Name
_StringLiteral1 = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.StringLiteral1")

_StringLiteral1_listOfAlts :: FieldName
_StringLiteral1_listOfAlts = (String -> FieldName
Core.FieldName String
"listOfAlts")

data StringLiteral1_ListOfAlts_Elmt = 
  StringLiteral1_ListOfAlts_ElmtRegex String |
  StringLiteral1_ListOfAlts_ElmtEchar Echar |
  StringLiteral1_ListOfAlts_ElmtUchar Uchar
  deriving (StringLiteral1_ListOfAlts_Elmt
-> StringLiteral1_ListOfAlts_Elmt -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StringLiteral1_ListOfAlts_Elmt
-> StringLiteral1_ListOfAlts_Elmt -> Bool
$c/= :: StringLiteral1_ListOfAlts_Elmt
-> StringLiteral1_ListOfAlts_Elmt -> Bool
== :: StringLiteral1_ListOfAlts_Elmt
-> StringLiteral1_ListOfAlts_Elmt -> Bool
$c== :: StringLiteral1_ListOfAlts_Elmt
-> StringLiteral1_ListOfAlts_Elmt -> Bool
Eq, Eq StringLiteral1_ListOfAlts_Elmt
StringLiteral1_ListOfAlts_Elmt
-> StringLiteral1_ListOfAlts_Elmt -> Bool
StringLiteral1_ListOfAlts_Elmt
-> StringLiteral1_ListOfAlts_Elmt -> Ordering
StringLiteral1_ListOfAlts_Elmt
-> StringLiteral1_ListOfAlts_Elmt -> StringLiteral1_ListOfAlts_Elmt
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
min :: StringLiteral1_ListOfAlts_Elmt
-> StringLiteral1_ListOfAlts_Elmt -> StringLiteral1_ListOfAlts_Elmt
$cmin :: StringLiteral1_ListOfAlts_Elmt
-> StringLiteral1_ListOfAlts_Elmt -> StringLiteral1_ListOfAlts_Elmt
max :: StringLiteral1_ListOfAlts_Elmt
-> StringLiteral1_ListOfAlts_Elmt -> StringLiteral1_ListOfAlts_Elmt
$cmax :: StringLiteral1_ListOfAlts_Elmt
-> StringLiteral1_ListOfAlts_Elmt -> StringLiteral1_ListOfAlts_Elmt
>= :: StringLiteral1_ListOfAlts_Elmt
-> StringLiteral1_ListOfAlts_Elmt -> Bool
$c>= :: StringLiteral1_ListOfAlts_Elmt
-> StringLiteral1_ListOfAlts_Elmt -> Bool
> :: StringLiteral1_ListOfAlts_Elmt
-> StringLiteral1_ListOfAlts_Elmt -> Bool
$c> :: StringLiteral1_ListOfAlts_Elmt
-> StringLiteral1_ListOfAlts_Elmt -> Bool
<= :: StringLiteral1_ListOfAlts_Elmt
-> StringLiteral1_ListOfAlts_Elmt -> Bool
$c<= :: StringLiteral1_ListOfAlts_Elmt
-> StringLiteral1_ListOfAlts_Elmt -> Bool
< :: StringLiteral1_ListOfAlts_Elmt
-> StringLiteral1_ListOfAlts_Elmt -> Bool
$c< :: StringLiteral1_ListOfAlts_Elmt
-> StringLiteral1_ListOfAlts_Elmt -> Bool
compare :: StringLiteral1_ListOfAlts_Elmt
-> StringLiteral1_ListOfAlts_Elmt -> Ordering
$ccompare :: StringLiteral1_ListOfAlts_Elmt
-> StringLiteral1_ListOfAlts_Elmt -> Ordering
Ord, ReadPrec [StringLiteral1_ListOfAlts_Elmt]
ReadPrec StringLiteral1_ListOfAlts_Elmt
Int -> ReadS StringLiteral1_ListOfAlts_Elmt
ReadS [StringLiteral1_ListOfAlts_Elmt]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [StringLiteral1_ListOfAlts_Elmt]
$creadListPrec :: ReadPrec [StringLiteral1_ListOfAlts_Elmt]
readPrec :: ReadPrec StringLiteral1_ListOfAlts_Elmt
$creadPrec :: ReadPrec StringLiteral1_ListOfAlts_Elmt
readList :: ReadS [StringLiteral1_ListOfAlts_Elmt]
$creadList :: ReadS [StringLiteral1_ListOfAlts_Elmt]
readsPrec :: Int -> ReadS StringLiteral1_ListOfAlts_Elmt
$creadsPrec :: Int -> ReadS StringLiteral1_ListOfAlts_Elmt
Read, Int -> StringLiteral1_ListOfAlts_Elmt -> ShowS
[StringLiteral1_ListOfAlts_Elmt] -> ShowS
StringLiteral1_ListOfAlts_Elmt -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StringLiteral1_ListOfAlts_Elmt] -> ShowS
$cshowList :: [StringLiteral1_ListOfAlts_Elmt] -> ShowS
show :: StringLiteral1_ListOfAlts_Elmt -> String
$cshow :: StringLiteral1_ListOfAlts_Elmt -> String
showsPrec :: Int -> StringLiteral1_ListOfAlts_Elmt -> ShowS
$cshowsPrec :: Int -> StringLiteral1_ListOfAlts_Elmt -> ShowS
Show)

_StringLiteral1_ListOfAlts_Elmt :: Name
_StringLiteral1_ListOfAlts_Elmt = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.StringLiteral1.ListOfAlts.Elmt")

_StringLiteral1_ListOfAlts_Elmt_regex :: FieldName
_StringLiteral1_ListOfAlts_Elmt_regex = (String -> FieldName
Core.FieldName String
"regex")

_StringLiteral1_ListOfAlts_Elmt_echar :: FieldName
_StringLiteral1_ListOfAlts_Elmt_echar = (String -> FieldName
Core.FieldName String
"echar")

_StringLiteral1_ListOfAlts_Elmt_uchar :: FieldName
_StringLiteral1_ListOfAlts_Elmt_uchar = (String -> FieldName
Core.FieldName String
"uchar")

data StringLiteral2 = 
  StringLiteral2 {
    StringLiteral2 -> [StringLiteral2_ListOfAlts_Elmt]
stringLiteral2ListOfAlts :: [StringLiteral2_ListOfAlts_Elmt]}
  deriving (StringLiteral2 -> StringLiteral2 -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StringLiteral2 -> StringLiteral2 -> Bool
$c/= :: StringLiteral2 -> StringLiteral2 -> Bool
== :: StringLiteral2 -> StringLiteral2 -> Bool
$c== :: StringLiteral2 -> StringLiteral2 -> Bool
Eq, Eq StringLiteral2
StringLiteral2 -> StringLiteral2 -> Bool
StringLiteral2 -> StringLiteral2 -> Ordering
StringLiteral2 -> StringLiteral2 -> StringLiteral2
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
min :: StringLiteral2 -> StringLiteral2 -> StringLiteral2
$cmin :: StringLiteral2 -> StringLiteral2 -> StringLiteral2
max :: StringLiteral2 -> StringLiteral2 -> StringLiteral2
$cmax :: StringLiteral2 -> StringLiteral2 -> StringLiteral2
>= :: StringLiteral2 -> StringLiteral2 -> Bool
$c>= :: StringLiteral2 -> StringLiteral2 -> Bool
> :: StringLiteral2 -> StringLiteral2 -> Bool
$c> :: StringLiteral2 -> StringLiteral2 -> Bool
<= :: StringLiteral2 -> StringLiteral2 -> Bool
$c<= :: StringLiteral2 -> StringLiteral2 -> Bool
< :: StringLiteral2 -> StringLiteral2 -> Bool
$c< :: StringLiteral2 -> StringLiteral2 -> Bool
compare :: StringLiteral2 -> StringLiteral2 -> Ordering
$ccompare :: StringLiteral2 -> StringLiteral2 -> Ordering
Ord, ReadPrec [StringLiteral2]
ReadPrec StringLiteral2
Int -> ReadS StringLiteral2
ReadS [StringLiteral2]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [StringLiteral2]
$creadListPrec :: ReadPrec [StringLiteral2]
readPrec :: ReadPrec StringLiteral2
$creadPrec :: ReadPrec StringLiteral2
readList :: ReadS [StringLiteral2]
$creadList :: ReadS [StringLiteral2]
readsPrec :: Int -> ReadS StringLiteral2
$creadsPrec :: Int -> ReadS StringLiteral2
Read, Int -> StringLiteral2 -> ShowS
[StringLiteral2] -> ShowS
StringLiteral2 -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StringLiteral2] -> ShowS
$cshowList :: [StringLiteral2] -> ShowS
show :: StringLiteral2 -> String
$cshow :: StringLiteral2 -> String
showsPrec :: Int -> StringLiteral2 -> ShowS
$cshowsPrec :: Int -> StringLiteral2 -> ShowS
Show)

_StringLiteral2 :: Name
_StringLiteral2 = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.StringLiteral2")

_StringLiteral2_listOfAlts :: FieldName
_StringLiteral2_listOfAlts = (String -> FieldName
Core.FieldName String
"listOfAlts")

data StringLiteral2_ListOfAlts_Elmt = 
  StringLiteral2_ListOfAlts_ElmtRegex String |
  StringLiteral2_ListOfAlts_ElmtEchar Echar |
  StringLiteral2_ListOfAlts_ElmtUchar Uchar
  deriving (StringLiteral2_ListOfAlts_Elmt
-> StringLiteral2_ListOfAlts_Elmt -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StringLiteral2_ListOfAlts_Elmt
-> StringLiteral2_ListOfAlts_Elmt -> Bool
$c/= :: StringLiteral2_ListOfAlts_Elmt
-> StringLiteral2_ListOfAlts_Elmt -> Bool
== :: StringLiteral2_ListOfAlts_Elmt
-> StringLiteral2_ListOfAlts_Elmt -> Bool
$c== :: StringLiteral2_ListOfAlts_Elmt
-> StringLiteral2_ListOfAlts_Elmt -> Bool
Eq, Eq StringLiteral2_ListOfAlts_Elmt
StringLiteral2_ListOfAlts_Elmt
-> StringLiteral2_ListOfAlts_Elmt -> Bool
StringLiteral2_ListOfAlts_Elmt
-> StringLiteral2_ListOfAlts_Elmt -> Ordering
StringLiteral2_ListOfAlts_Elmt
-> StringLiteral2_ListOfAlts_Elmt -> StringLiteral2_ListOfAlts_Elmt
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
min :: StringLiteral2_ListOfAlts_Elmt
-> StringLiteral2_ListOfAlts_Elmt -> StringLiteral2_ListOfAlts_Elmt
$cmin :: StringLiteral2_ListOfAlts_Elmt
-> StringLiteral2_ListOfAlts_Elmt -> StringLiteral2_ListOfAlts_Elmt
max :: StringLiteral2_ListOfAlts_Elmt
-> StringLiteral2_ListOfAlts_Elmt -> StringLiteral2_ListOfAlts_Elmt
$cmax :: StringLiteral2_ListOfAlts_Elmt
-> StringLiteral2_ListOfAlts_Elmt -> StringLiteral2_ListOfAlts_Elmt
>= :: StringLiteral2_ListOfAlts_Elmt
-> StringLiteral2_ListOfAlts_Elmt -> Bool
$c>= :: StringLiteral2_ListOfAlts_Elmt
-> StringLiteral2_ListOfAlts_Elmt -> Bool
> :: StringLiteral2_ListOfAlts_Elmt
-> StringLiteral2_ListOfAlts_Elmt -> Bool
$c> :: StringLiteral2_ListOfAlts_Elmt
-> StringLiteral2_ListOfAlts_Elmt -> Bool
<= :: StringLiteral2_ListOfAlts_Elmt
-> StringLiteral2_ListOfAlts_Elmt -> Bool
$c<= :: StringLiteral2_ListOfAlts_Elmt
-> StringLiteral2_ListOfAlts_Elmt -> Bool
< :: StringLiteral2_ListOfAlts_Elmt
-> StringLiteral2_ListOfAlts_Elmt -> Bool
$c< :: StringLiteral2_ListOfAlts_Elmt
-> StringLiteral2_ListOfAlts_Elmt -> Bool
compare :: StringLiteral2_ListOfAlts_Elmt
-> StringLiteral2_ListOfAlts_Elmt -> Ordering
$ccompare :: StringLiteral2_ListOfAlts_Elmt
-> StringLiteral2_ListOfAlts_Elmt -> Ordering
Ord, ReadPrec [StringLiteral2_ListOfAlts_Elmt]
ReadPrec StringLiteral2_ListOfAlts_Elmt
Int -> ReadS StringLiteral2_ListOfAlts_Elmt
ReadS [StringLiteral2_ListOfAlts_Elmt]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [StringLiteral2_ListOfAlts_Elmt]
$creadListPrec :: ReadPrec [StringLiteral2_ListOfAlts_Elmt]
readPrec :: ReadPrec StringLiteral2_ListOfAlts_Elmt
$creadPrec :: ReadPrec StringLiteral2_ListOfAlts_Elmt
readList :: ReadS [StringLiteral2_ListOfAlts_Elmt]
$creadList :: ReadS [StringLiteral2_ListOfAlts_Elmt]
readsPrec :: Int -> ReadS StringLiteral2_ListOfAlts_Elmt
$creadsPrec :: Int -> ReadS StringLiteral2_ListOfAlts_Elmt
Read, Int -> StringLiteral2_ListOfAlts_Elmt -> ShowS
[StringLiteral2_ListOfAlts_Elmt] -> ShowS
StringLiteral2_ListOfAlts_Elmt -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StringLiteral2_ListOfAlts_Elmt] -> ShowS
$cshowList :: [StringLiteral2_ListOfAlts_Elmt] -> ShowS
show :: StringLiteral2_ListOfAlts_Elmt -> String
$cshow :: StringLiteral2_ListOfAlts_Elmt -> String
showsPrec :: Int -> StringLiteral2_ListOfAlts_Elmt -> ShowS
$cshowsPrec :: Int -> StringLiteral2_ListOfAlts_Elmt -> ShowS
Show)

_StringLiteral2_ListOfAlts_Elmt :: Name
_StringLiteral2_ListOfAlts_Elmt = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.StringLiteral2.ListOfAlts.Elmt")

_StringLiteral2_ListOfAlts_Elmt_regex :: FieldName
_StringLiteral2_ListOfAlts_Elmt_regex = (String -> FieldName
Core.FieldName String
"regex")

_StringLiteral2_ListOfAlts_Elmt_echar :: FieldName
_StringLiteral2_ListOfAlts_Elmt_echar = (String -> FieldName
Core.FieldName String
"echar")

_StringLiteral2_ListOfAlts_Elmt_uchar :: FieldName
_StringLiteral2_ListOfAlts_Elmt_uchar = (String -> FieldName
Core.FieldName String
"uchar")

data StringLiteralLong1 = 
  StringLiteralLong1 {
    StringLiteralLong1 -> [StringLiteralLong1_ListOfAlts_Elmt]
stringLiteralLong1ListOfAlts :: [StringLiteralLong1_ListOfAlts_Elmt]}
  deriving (StringLiteralLong1 -> StringLiteralLong1 -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StringLiteralLong1 -> StringLiteralLong1 -> Bool
$c/= :: StringLiteralLong1 -> StringLiteralLong1 -> Bool
== :: StringLiteralLong1 -> StringLiteralLong1 -> Bool
$c== :: StringLiteralLong1 -> StringLiteralLong1 -> Bool
Eq, Eq StringLiteralLong1
StringLiteralLong1 -> StringLiteralLong1 -> Bool
StringLiteralLong1 -> StringLiteralLong1 -> Ordering
StringLiteralLong1 -> StringLiteralLong1 -> StringLiteralLong1
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
min :: StringLiteralLong1 -> StringLiteralLong1 -> StringLiteralLong1
$cmin :: StringLiteralLong1 -> StringLiteralLong1 -> StringLiteralLong1
max :: StringLiteralLong1 -> StringLiteralLong1 -> StringLiteralLong1
$cmax :: StringLiteralLong1 -> StringLiteralLong1 -> StringLiteralLong1
>= :: StringLiteralLong1 -> StringLiteralLong1 -> Bool
$c>= :: StringLiteralLong1 -> StringLiteralLong1 -> Bool
> :: StringLiteralLong1 -> StringLiteralLong1 -> Bool
$c> :: StringLiteralLong1 -> StringLiteralLong1 -> Bool
<= :: StringLiteralLong1 -> StringLiteralLong1 -> Bool
$c<= :: StringLiteralLong1 -> StringLiteralLong1 -> Bool
< :: StringLiteralLong1 -> StringLiteralLong1 -> Bool
$c< :: StringLiteralLong1 -> StringLiteralLong1 -> Bool
compare :: StringLiteralLong1 -> StringLiteralLong1 -> Ordering
$ccompare :: StringLiteralLong1 -> StringLiteralLong1 -> Ordering
Ord, ReadPrec [StringLiteralLong1]
ReadPrec StringLiteralLong1
Int -> ReadS StringLiteralLong1
ReadS [StringLiteralLong1]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [StringLiteralLong1]
$creadListPrec :: ReadPrec [StringLiteralLong1]
readPrec :: ReadPrec StringLiteralLong1
$creadPrec :: ReadPrec StringLiteralLong1
readList :: ReadS [StringLiteralLong1]
$creadList :: ReadS [StringLiteralLong1]
readsPrec :: Int -> ReadS StringLiteralLong1
$creadsPrec :: Int -> ReadS StringLiteralLong1
Read, Int -> StringLiteralLong1 -> ShowS
[StringLiteralLong1] -> ShowS
StringLiteralLong1 -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StringLiteralLong1] -> ShowS
$cshowList :: [StringLiteralLong1] -> ShowS
show :: StringLiteralLong1 -> String
$cshow :: StringLiteralLong1 -> String
showsPrec :: Int -> StringLiteralLong1 -> ShowS
$cshowsPrec :: Int -> StringLiteralLong1 -> ShowS
Show)

_StringLiteralLong1 :: Name
_StringLiteralLong1 = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.StringLiteralLong1")

_StringLiteralLong1_listOfAlts :: FieldName
_StringLiteralLong1_listOfAlts = (String -> FieldName
Core.FieldName String
"listOfAlts")

data StringLiteralLong1_ListOfAlts_Elmt = 
  StringLiteralLong1_ListOfAlts_ElmtSequence StringLiteralLong1_ListOfAlts_Elmt_Sequence |
  StringLiteralLong1_ListOfAlts_ElmtEchar Echar |
  StringLiteralLong1_ListOfAlts_ElmtUchar Uchar
  deriving (StringLiteralLong1_ListOfAlts_Elmt
-> StringLiteralLong1_ListOfAlts_Elmt -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StringLiteralLong1_ListOfAlts_Elmt
-> StringLiteralLong1_ListOfAlts_Elmt -> Bool
$c/= :: StringLiteralLong1_ListOfAlts_Elmt
-> StringLiteralLong1_ListOfAlts_Elmt -> Bool
== :: StringLiteralLong1_ListOfAlts_Elmt
-> StringLiteralLong1_ListOfAlts_Elmt -> Bool
$c== :: StringLiteralLong1_ListOfAlts_Elmt
-> StringLiteralLong1_ListOfAlts_Elmt -> Bool
Eq, Eq StringLiteralLong1_ListOfAlts_Elmt
StringLiteralLong1_ListOfAlts_Elmt
-> StringLiteralLong1_ListOfAlts_Elmt -> Bool
StringLiteralLong1_ListOfAlts_Elmt
-> StringLiteralLong1_ListOfAlts_Elmt -> Ordering
StringLiteralLong1_ListOfAlts_Elmt
-> StringLiteralLong1_ListOfAlts_Elmt
-> StringLiteralLong1_ListOfAlts_Elmt
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
min :: StringLiteralLong1_ListOfAlts_Elmt
-> StringLiteralLong1_ListOfAlts_Elmt
-> StringLiteralLong1_ListOfAlts_Elmt
$cmin :: StringLiteralLong1_ListOfAlts_Elmt
-> StringLiteralLong1_ListOfAlts_Elmt
-> StringLiteralLong1_ListOfAlts_Elmt
max :: StringLiteralLong1_ListOfAlts_Elmt
-> StringLiteralLong1_ListOfAlts_Elmt
-> StringLiteralLong1_ListOfAlts_Elmt
$cmax :: StringLiteralLong1_ListOfAlts_Elmt
-> StringLiteralLong1_ListOfAlts_Elmt
-> StringLiteralLong1_ListOfAlts_Elmt
>= :: StringLiteralLong1_ListOfAlts_Elmt
-> StringLiteralLong1_ListOfAlts_Elmt -> Bool
$c>= :: StringLiteralLong1_ListOfAlts_Elmt
-> StringLiteralLong1_ListOfAlts_Elmt -> Bool
> :: StringLiteralLong1_ListOfAlts_Elmt
-> StringLiteralLong1_ListOfAlts_Elmt -> Bool
$c> :: StringLiteralLong1_ListOfAlts_Elmt
-> StringLiteralLong1_ListOfAlts_Elmt -> Bool
<= :: StringLiteralLong1_ListOfAlts_Elmt
-> StringLiteralLong1_ListOfAlts_Elmt -> Bool
$c<= :: StringLiteralLong1_ListOfAlts_Elmt
-> StringLiteralLong1_ListOfAlts_Elmt -> Bool
< :: StringLiteralLong1_ListOfAlts_Elmt
-> StringLiteralLong1_ListOfAlts_Elmt -> Bool
$c< :: StringLiteralLong1_ListOfAlts_Elmt
-> StringLiteralLong1_ListOfAlts_Elmt -> Bool
compare :: StringLiteralLong1_ListOfAlts_Elmt
-> StringLiteralLong1_ListOfAlts_Elmt -> Ordering
$ccompare :: StringLiteralLong1_ListOfAlts_Elmt
-> StringLiteralLong1_ListOfAlts_Elmt -> Ordering
Ord, ReadPrec [StringLiteralLong1_ListOfAlts_Elmt]
ReadPrec StringLiteralLong1_ListOfAlts_Elmt
Int -> ReadS StringLiteralLong1_ListOfAlts_Elmt
ReadS [StringLiteralLong1_ListOfAlts_Elmt]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [StringLiteralLong1_ListOfAlts_Elmt]
$creadListPrec :: ReadPrec [StringLiteralLong1_ListOfAlts_Elmt]
readPrec :: ReadPrec StringLiteralLong1_ListOfAlts_Elmt
$creadPrec :: ReadPrec StringLiteralLong1_ListOfAlts_Elmt
readList :: ReadS [StringLiteralLong1_ListOfAlts_Elmt]
$creadList :: ReadS [StringLiteralLong1_ListOfAlts_Elmt]
readsPrec :: Int -> ReadS StringLiteralLong1_ListOfAlts_Elmt
$creadsPrec :: Int -> ReadS StringLiteralLong1_ListOfAlts_Elmt
Read, Int -> StringLiteralLong1_ListOfAlts_Elmt -> ShowS
[StringLiteralLong1_ListOfAlts_Elmt] -> ShowS
StringLiteralLong1_ListOfAlts_Elmt -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StringLiteralLong1_ListOfAlts_Elmt] -> ShowS
$cshowList :: [StringLiteralLong1_ListOfAlts_Elmt] -> ShowS
show :: StringLiteralLong1_ListOfAlts_Elmt -> String
$cshow :: StringLiteralLong1_ListOfAlts_Elmt -> String
showsPrec :: Int -> StringLiteralLong1_ListOfAlts_Elmt -> ShowS
$cshowsPrec :: Int -> StringLiteralLong1_ListOfAlts_Elmt -> ShowS
Show)

_StringLiteralLong1_ListOfAlts_Elmt :: Name
_StringLiteralLong1_ListOfAlts_Elmt = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.StringLiteralLong1.ListOfAlts.Elmt")

_StringLiteralLong1_ListOfAlts_Elmt_sequence :: FieldName
_StringLiteralLong1_ListOfAlts_Elmt_sequence = (String -> FieldName
Core.FieldName String
"sequence")

_StringLiteralLong1_ListOfAlts_Elmt_echar :: FieldName
_StringLiteralLong1_ListOfAlts_Elmt_echar = (String -> FieldName
Core.FieldName String
"echar")

_StringLiteralLong1_ListOfAlts_Elmt_uchar :: FieldName
_StringLiteralLong1_ListOfAlts_Elmt_uchar = (String -> FieldName
Core.FieldName String
"uchar")

data StringLiteralLong1_ListOfAlts_Elmt_Sequence = 
  StringLiteralLong1_ListOfAlts_Elmt_Sequence {
    StringLiteralLong1_ListOfAlts_Elmt_Sequence
-> Maybe StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option
stringLiteralLong1_ListOfAlts_Elmt_SequenceAlts :: (Maybe StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option),
    StringLiteralLong1_ListOfAlts_Elmt_Sequence -> String
stringLiteralLong1_ListOfAlts_Elmt_SequenceRegex :: String}
  deriving (StringLiteralLong1_ListOfAlts_Elmt_Sequence
-> StringLiteralLong1_ListOfAlts_Elmt_Sequence -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StringLiteralLong1_ListOfAlts_Elmt_Sequence
-> StringLiteralLong1_ListOfAlts_Elmt_Sequence -> Bool
$c/= :: StringLiteralLong1_ListOfAlts_Elmt_Sequence
-> StringLiteralLong1_ListOfAlts_Elmt_Sequence -> Bool
== :: StringLiteralLong1_ListOfAlts_Elmt_Sequence
-> StringLiteralLong1_ListOfAlts_Elmt_Sequence -> Bool
$c== :: StringLiteralLong1_ListOfAlts_Elmt_Sequence
-> StringLiteralLong1_ListOfAlts_Elmt_Sequence -> Bool
Eq, Eq StringLiteralLong1_ListOfAlts_Elmt_Sequence
StringLiteralLong1_ListOfAlts_Elmt_Sequence
-> StringLiteralLong1_ListOfAlts_Elmt_Sequence -> Bool
StringLiteralLong1_ListOfAlts_Elmt_Sequence
-> StringLiteralLong1_ListOfAlts_Elmt_Sequence -> Ordering
StringLiteralLong1_ListOfAlts_Elmt_Sequence
-> StringLiteralLong1_ListOfAlts_Elmt_Sequence
-> StringLiteralLong1_ListOfAlts_Elmt_Sequence
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
min :: StringLiteralLong1_ListOfAlts_Elmt_Sequence
-> StringLiteralLong1_ListOfAlts_Elmt_Sequence
-> StringLiteralLong1_ListOfAlts_Elmt_Sequence
$cmin :: StringLiteralLong1_ListOfAlts_Elmt_Sequence
-> StringLiteralLong1_ListOfAlts_Elmt_Sequence
-> StringLiteralLong1_ListOfAlts_Elmt_Sequence
max :: StringLiteralLong1_ListOfAlts_Elmt_Sequence
-> StringLiteralLong1_ListOfAlts_Elmt_Sequence
-> StringLiteralLong1_ListOfAlts_Elmt_Sequence
$cmax :: StringLiteralLong1_ListOfAlts_Elmt_Sequence
-> StringLiteralLong1_ListOfAlts_Elmt_Sequence
-> StringLiteralLong1_ListOfAlts_Elmt_Sequence
>= :: StringLiteralLong1_ListOfAlts_Elmt_Sequence
-> StringLiteralLong1_ListOfAlts_Elmt_Sequence -> Bool
$c>= :: StringLiteralLong1_ListOfAlts_Elmt_Sequence
-> StringLiteralLong1_ListOfAlts_Elmt_Sequence -> Bool
> :: StringLiteralLong1_ListOfAlts_Elmt_Sequence
-> StringLiteralLong1_ListOfAlts_Elmt_Sequence -> Bool
$c> :: StringLiteralLong1_ListOfAlts_Elmt_Sequence
-> StringLiteralLong1_ListOfAlts_Elmt_Sequence -> Bool
<= :: StringLiteralLong1_ListOfAlts_Elmt_Sequence
-> StringLiteralLong1_ListOfAlts_Elmt_Sequence -> Bool
$c<= :: StringLiteralLong1_ListOfAlts_Elmt_Sequence
-> StringLiteralLong1_ListOfAlts_Elmt_Sequence -> Bool
< :: StringLiteralLong1_ListOfAlts_Elmt_Sequence
-> StringLiteralLong1_ListOfAlts_Elmt_Sequence -> Bool
$c< :: StringLiteralLong1_ListOfAlts_Elmt_Sequence
-> StringLiteralLong1_ListOfAlts_Elmt_Sequence -> Bool
compare :: StringLiteralLong1_ListOfAlts_Elmt_Sequence
-> StringLiteralLong1_ListOfAlts_Elmt_Sequence -> Ordering
$ccompare :: StringLiteralLong1_ListOfAlts_Elmt_Sequence
-> StringLiteralLong1_ListOfAlts_Elmt_Sequence -> Ordering
Ord, ReadPrec [StringLiteralLong1_ListOfAlts_Elmt_Sequence]
ReadPrec StringLiteralLong1_ListOfAlts_Elmt_Sequence
Int -> ReadS StringLiteralLong1_ListOfAlts_Elmt_Sequence
ReadS [StringLiteralLong1_ListOfAlts_Elmt_Sequence]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [StringLiteralLong1_ListOfAlts_Elmt_Sequence]
$creadListPrec :: ReadPrec [StringLiteralLong1_ListOfAlts_Elmt_Sequence]
readPrec :: ReadPrec StringLiteralLong1_ListOfAlts_Elmt_Sequence
$creadPrec :: ReadPrec StringLiteralLong1_ListOfAlts_Elmt_Sequence
readList :: ReadS [StringLiteralLong1_ListOfAlts_Elmt_Sequence]
$creadList :: ReadS [StringLiteralLong1_ListOfAlts_Elmt_Sequence]
readsPrec :: Int -> ReadS StringLiteralLong1_ListOfAlts_Elmt_Sequence
$creadsPrec :: Int -> ReadS StringLiteralLong1_ListOfAlts_Elmt_Sequence
Read, Int -> StringLiteralLong1_ListOfAlts_Elmt_Sequence -> ShowS
[StringLiteralLong1_ListOfAlts_Elmt_Sequence] -> ShowS
StringLiteralLong1_ListOfAlts_Elmt_Sequence -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StringLiteralLong1_ListOfAlts_Elmt_Sequence] -> ShowS
$cshowList :: [StringLiteralLong1_ListOfAlts_Elmt_Sequence] -> ShowS
show :: StringLiteralLong1_ListOfAlts_Elmt_Sequence -> String
$cshow :: StringLiteralLong1_ListOfAlts_Elmt_Sequence -> String
showsPrec :: Int -> StringLiteralLong1_ListOfAlts_Elmt_Sequence -> ShowS
$cshowsPrec :: Int -> StringLiteralLong1_ListOfAlts_Elmt_Sequence -> ShowS
Show)

_StringLiteralLong1_ListOfAlts_Elmt_Sequence :: Name
_StringLiteralLong1_ListOfAlts_Elmt_Sequence = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.StringLiteralLong1.ListOfAlts.Elmt.Sequence")

_StringLiteralLong1_ListOfAlts_Elmt_Sequence_alts :: FieldName
_StringLiteralLong1_ListOfAlts_Elmt_Sequence_alts = (String -> FieldName
Core.FieldName String
"alts")

_StringLiteralLong1_ListOfAlts_Elmt_Sequence_regex :: FieldName
_StringLiteralLong1_ListOfAlts_Elmt_Sequence_regex = (String -> FieldName
Core.FieldName String
"regex")

data StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option = 
  StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_OptionApos  |
  StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_OptionSequence StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option_Sequence
  deriving (StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option
-> StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option
-> StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option -> Bool
$c/= :: StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option
-> StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option -> Bool
== :: StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option
-> StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option -> Bool
$c== :: StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option
-> StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option -> Bool
Eq, Eq StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option
StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option
-> StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option -> Bool
StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option
-> StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option
-> Ordering
StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option
-> StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option
-> StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option
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
min :: StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option
-> StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option
-> StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option
$cmin :: StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option
-> StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option
-> StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option
max :: StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option
-> StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option
-> StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option
$cmax :: StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option
-> StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option
-> StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option
>= :: StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option
-> StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option -> Bool
$c>= :: StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option
-> StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option -> Bool
> :: StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option
-> StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option -> Bool
$c> :: StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option
-> StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option -> Bool
<= :: StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option
-> StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option -> Bool
$c<= :: StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option
-> StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option -> Bool
< :: StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option
-> StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option -> Bool
$c< :: StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option
-> StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option -> Bool
compare :: StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option
-> StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option
-> Ordering
$ccompare :: StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option
-> StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option
-> Ordering
Ord, ReadPrec [StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option]
ReadPrec StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option
Int
-> ReadS StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option
ReadS [StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option]
$creadListPrec :: ReadPrec [StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option]
readPrec :: ReadPrec StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option
$creadPrec :: ReadPrec StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option
readList :: ReadS [StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option]
$creadList :: ReadS [StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option]
readsPrec :: Int
-> ReadS StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option
$creadsPrec :: Int
-> ReadS StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option
Read, Int
-> StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option -> ShowS
[StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option] -> ShowS
StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option] -> ShowS
$cshowList :: [StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option] -> ShowS
show :: StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option -> String
$cshow :: StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option -> String
showsPrec :: Int
-> StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option -> ShowS
$cshowsPrec :: Int
-> StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option -> ShowS
Show)

_StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option :: Name
_StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.StringLiteralLong1.ListOfAlts.Elmt.Sequence.Alts.Option")

_StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option_apos :: FieldName
_StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option_apos = (String -> FieldName
Core.FieldName String
"apos")

_StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option_sequence :: FieldName
_StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option_sequence = (String -> FieldName
Core.FieldName String
"sequence")

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

_StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option_Sequence :: Name
_StringLiteralLong1_ListOfAlts_Elmt_Sequence_Alts_Option_Sequence = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.StringLiteralLong1.ListOfAlts.Elmt.Sequence.Alts.Option.Sequence")

data StringLiteralLong2 = 
  StringLiteralLong2 {
    StringLiteralLong2 -> [StringLiteralLong2_ListOfAlts_Elmt]
stringLiteralLong2ListOfAlts :: [StringLiteralLong2_ListOfAlts_Elmt]}
  deriving (StringLiteralLong2 -> StringLiteralLong2 -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StringLiteralLong2 -> StringLiteralLong2 -> Bool
$c/= :: StringLiteralLong2 -> StringLiteralLong2 -> Bool
== :: StringLiteralLong2 -> StringLiteralLong2 -> Bool
$c== :: StringLiteralLong2 -> StringLiteralLong2 -> Bool
Eq, Eq StringLiteralLong2
StringLiteralLong2 -> StringLiteralLong2 -> Bool
StringLiteralLong2 -> StringLiteralLong2 -> Ordering
StringLiteralLong2 -> StringLiteralLong2 -> StringLiteralLong2
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
min :: StringLiteralLong2 -> StringLiteralLong2 -> StringLiteralLong2
$cmin :: StringLiteralLong2 -> StringLiteralLong2 -> StringLiteralLong2
max :: StringLiteralLong2 -> StringLiteralLong2 -> StringLiteralLong2
$cmax :: StringLiteralLong2 -> StringLiteralLong2 -> StringLiteralLong2
>= :: StringLiteralLong2 -> StringLiteralLong2 -> Bool
$c>= :: StringLiteralLong2 -> StringLiteralLong2 -> Bool
> :: StringLiteralLong2 -> StringLiteralLong2 -> Bool
$c> :: StringLiteralLong2 -> StringLiteralLong2 -> Bool
<= :: StringLiteralLong2 -> StringLiteralLong2 -> Bool
$c<= :: StringLiteralLong2 -> StringLiteralLong2 -> Bool
< :: StringLiteralLong2 -> StringLiteralLong2 -> Bool
$c< :: StringLiteralLong2 -> StringLiteralLong2 -> Bool
compare :: StringLiteralLong2 -> StringLiteralLong2 -> Ordering
$ccompare :: StringLiteralLong2 -> StringLiteralLong2 -> Ordering
Ord, ReadPrec [StringLiteralLong2]
ReadPrec StringLiteralLong2
Int -> ReadS StringLiteralLong2
ReadS [StringLiteralLong2]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [StringLiteralLong2]
$creadListPrec :: ReadPrec [StringLiteralLong2]
readPrec :: ReadPrec StringLiteralLong2
$creadPrec :: ReadPrec StringLiteralLong2
readList :: ReadS [StringLiteralLong2]
$creadList :: ReadS [StringLiteralLong2]
readsPrec :: Int -> ReadS StringLiteralLong2
$creadsPrec :: Int -> ReadS StringLiteralLong2
Read, Int -> StringLiteralLong2 -> ShowS
[StringLiteralLong2] -> ShowS
StringLiteralLong2 -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StringLiteralLong2] -> ShowS
$cshowList :: [StringLiteralLong2] -> ShowS
show :: StringLiteralLong2 -> String
$cshow :: StringLiteralLong2 -> String
showsPrec :: Int -> StringLiteralLong2 -> ShowS
$cshowsPrec :: Int -> StringLiteralLong2 -> ShowS
Show)

_StringLiteralLong2 :: Name
_StringLiteralLong2 = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.StringLiteralLong2")

_StringLiteralLong2_listOfAlts :: FieldName
_StringLiteralLong2_listOfAlts = (String -> FieldName
Core.FieldName String
"listOfAlts")

data StringLiteralLong2_ListOfAlts_Elmt = 
  StringLiteralLong2_ListOfAlts_ElmtSequence StringLiteralLong2_ListOfAlts_Elmt_Sequence |
  StringLiteralLong2_ListOfAlts_ElmtEchar Echar |
  StringLiteralLong2_ListOfAlts_ElmtUchar Uchar
  deriving (StringLiteralLong2_ListOfAlts_Elmt
-> StringLiteralLong2_ListOfAlts_Elmt -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StringLiteralLong2_ListOfAlts_Elmt
-> StringLiteralLong2_ListOfAlts_Elmt -> Bool
$c/= :: StringLiteralLong2_ListOfAlts_Elmt
-> StringLiteralLong2_ListOfAlts_Elmt -> Bool
== :: StringLiteralLong2_ListOfAlts_Elmt
-> StringLiteralLong2_ListOfAlts_Elmt -> Bool
$c== :: StringLiteralLong2_ListOfAlts_Elmt
-> StringLiteralLong2_ListOfAlts_Elmt -> Bool
Eq, Eq StringLiteralLong2_ListOfAlts_Elmt
StringLiteralLong2_ListOfAlts_Elmt
-> StringLiteralLong2_ListOfAlts_Elmt -> Bool
StringLiteralLong2_ListOfAlts_Elmt
-> StringLiteralLong2_ListOfAlts_Elmt -> Ordering
StringLiteralLong2_ListOfAlts_Elmt
-> StringLiteralLong2_ListOfAlts_Elmt
-> StringLiteralLong2_ListOfAlts_Elmt
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
min :: StringLiteralLong2_ListOfAlts_Elmt
-> StringLiteralLong2_ListOfAlts_Elmt
-> StringLiteralLong2_ListOfAlts_Elmt
$cmin :: StringLiteralLong2_ListOfAlts_Elmt
-> StringLiteralLong2_ListOfAlts_Elmt
-> StringLiteralLong2_ListOfAlts_Elmt
max :: StringLiteralLong2_ListOfAlts_Elmt
-> StringLiteralLong2_ListOfAlts_Elmt
-> StringLiteralLong2_ListOfAlts_Elmt
$cmax :: StringLiteralLong2_ListOfAlts_Elmt
-> StringLiteralLong2_ListOfAlts_Elmt
-> StringLiteralLong2_ListOfAlts_Elmt
>= :: StringLiteralLong2_ListOfAlts_Elmt
-> StringLiteralLong2_ListOfAlts_Elmt -> Bool
$c>= :: StringLiteralLong2_ListOfAlts_Elmt
-> StringLiteralLong2_ListOfAlts_Elmt -> Bool
> :: StringLiteralLong2_ListOfAlts_Elmt
-> StringLiteralLong2_ListOfAlts_Elmt -> Bool
$c> :: StringLiteralLong2_ListOfAlts_Elmt
-> StringLiteralLong2_ListOfAlts_Elmt -> Bool
<= :: StringLiteralLong2_ListOfAlts_Elmt
-> StringLiteralLong2_ListOfAlts_Elmt -> Bool
$c<= :: StringLiteralLong2_ListOfAlts_Elmt
-> StringLiteralLong2_ListOfAlts_Elmt -> Bool
< :: StringLiteralLong2_ListOfAlts_Elmt
-> StringLiteralLong2_ListOfAlts_Elmt -> Bool
$c< :: StringLiteralLong2_ListOfAlts_Elmt
-> StringLiteralLong2_ListOfAlts_Elmt -> Bool
compare :: StringLiteralLong2_ListOfAlts_Elmt
-> StringLiteralLong2_ListOfAlts_Elmt -> Ordering
$ccompare :: StringLiteralLong2_ListOfAlts_Elmt
-> StringLiteralLong2_ListOfAlts_Elmt -> Ordering
Ord, ReadPrec [StringLiteralLong2_ListOfAlts_Elmt]
ReadPrec StringLiteralLong2_ListOfAlts_Elmt
Int -> ReadS StringLiteralLong2_ListOfAlts_Elmt
ReadS [StringLiteralLong2_ListOfAlts_Elmt]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [StringLiteralLong2_ListOfAlts_Elmt]
$creadListPrec :: ReadPrec [StringLiteralLong2_ListOfAlts_Elmt]
readPrec :: ReadPrec StringLiteralLong2_ListOfAlts_Elmt
$creadPrec :: ReadPrec StringLiteralLong2_ListOfAlts_Elmt
readList :: ReadS [StringLiteralLong2_ListOfAlts_Elmt]
$creadList :: ReadS [StringLiteralLong2_ListOfAlts_Elmt]
readsPrec :: Int -> ReadS StringLiteralLong2_ListOfAlts_Elmt
$creadsPrec :: Int -> ReadS StringLiteralLong2_ListOfAlts_Elmt
Read, Int -> StringLiteralLong2_ListOfAlts_Elmt -> ShowS
[StringLiteralLong2_ListOfAlts_Elmt] -> ShowS
StringLiteralLong2_ListOfAlts_Elmt -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StringLiteralLong2_ListOfAlts_Elmt] -> ShowS
$cshowList :: [StringLiteralLong2_ListOfAlts_Elmt] -> ShowS
show :: StringLiteralLong2_ListOfAlts_Elmt -> String
$cshow :: StringLiteralLong2_ListOfAlts_Elmt -> String
showsPrec :: Int -> StringLiteralLong2_ListOfAlts_Elmt -> ShowS
$cshowsPrec :: Int -> StringLiteralLong2_ListOfAlts_Elmt -> ShowS
Show)

_StringLiteralLong2_ListOfAlts_Elmt :: Name
_StringLiteralLong2_ListOfAlts_Elmt = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.StringLiteralLong2.ListOfAlts.Elmt")

_StringLiteralLong2_ListOfAlts_Elmt_sequence :: FieldName
_StringLiteralLong2_ListOfAlts_Elmt_sequence = (String -> FieldName
Core.FieldName String
"sequence")

_StringLiteralLong2_ListOfAlts_Elmt_echar :: FieldName
_StringLiteralLong2_ListOfAlts_Elmt_echar = (String -> FieldName
Core.FieldName String
"echar")

_StringLiteralLong2_ListOfAlts_Elmt_uchar :: FieldName
_StringLiteralLong2_ListOfAlts_Elmt_uchar = (String -> FieldName
Core.FieldName String
"uchar")

data StringLiteralLong2_ListOfAlts_Elmt_Sequence = 
  StringLiteralLong2_ListOfAlts_Elmt_Sequence {
    StringLiteralLong2_ListOfAlts_Elmt_Sequence
-> Maybe StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option
stringLiteralLong2_ListOfAlts_Elmt_SequenceAlts :: (Maybe StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option),
    StringLiteralLong2_ListOfAlts_Elmt_Sequence -> String
stringLiteralLong2_ListOfAlts_Elmt_SequenceRegex :: String}
  deriving (StringLiteralLong2_ListOfAlts_Elmt_Sequence
-> StringLiteralLong2_ListOfAlts_Elmt_Sequence -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StringLiteralLong2_ListOfAlts_Elmt_Sequence
-> StringLiteralLong2_ListOfAlts_Elmt_Sequence -> Bool
$c/= :: StringLiteralLong2_ListOfAlts_Elmt_Sequence
-> StringLiteralLong2_ListOfAlts_Elmt_Sequence -> Bool
== :: StringLiteralLong2_ListOfAlts_Elmt_Sequence
-> StringLiteralLong2_ListOfAlts_Elmt_Sequence -> Bool
$c== :: StringLiteralLong2_ListOfAlts_Elmt_Sequence
-> StringLiteralLong2_ListOfAlts_Elmt_Sequence -> Bool
Eq, Eq StringLiteralLong2_ListOfAlts_Elmt_Sequence
StringLiteralLong2_ListOfAlts_Elmt_Sequence
-> StringLiteralLong2_ListOfAlts_Elmt_Sequence -> Bool
StringLiteralLong2_ListOfAlts_Elmt_Sequence
-> StringLiteralLong2_ListOfAlts_Elmt_Sequence -> Ordering
StringLiteralLong2_ListOfAlts_Elmt_Sequence
-> StringLiteralLong2_ListOfAlts_Elmt_Sequence
-> StringLiteralLong2_ListOfAlts_Elmt_Sequence
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
min :: StringLiteralLong2_ListOfAlts_Elmt_Sequence
-> StringLiteralLong2_ListOfAlts_Elmt_Sequence
-> StringLiteralLong2_ListOfAlts_Elmt_Sequence
$cmin :: StringLiteralLong2_ListOfAlts_Elmt_Sequence
-> StringLiteralLong2_ListOfAlts_Elmt_Sequence
-> StringLiteralLong2_ListOfAlts_Elmt_Sequence
max :: StringLiteralLong2_ListOfAlts_Elmt_Sequence
-> StringLiteralLong2_ListOfAlts_Elmt_Sequence
-> StringLiteralLong2_ListOfAlts_Elmt_Sequence
$cmax :: StringLiteralLong2_ListOfAlts_Elmt_Sequence
-> StringLiteralLong2_ListOfAlts_Elmt_Sequence
-> StringLiteralLong2_ListOfAlts_Elmt_Sequence
>= :: StringLiteralLong2_ListOfAlts_Elmt_Sequence
-> StringLiteralLong2_ListOfAlts_Elmt_Sequence -> Bool
$c>= :: StringLiteralLong2_ListOfAlts_Elmt_Sequence
-> StringLiteralLong2_ListOfAlts_Elmt_Sequence -> Bool
> :: StringLiteralLong2_ListOfAlts_Elmt_Sequence
-> StringLiteralLong2_ListOfAlts_Elmt_Sequence -> Bool
$c> :: StringLiteralLong2_ListOfAlts_Elmt_Sequence
-> StringLiteralLong2_ListOfAlts_Elmt_Sequence -> Bool
<= :: StringLiteralLong2_ListOfAlts_Elmt_Sequence
-> StringLiteralLong2_ListOfAlts_Elmt_Sequence -> Bool
$c<= :: StringLiteralLong2_ListOfAlts_Elmt_Sequence
-> StringLiteralLong2_ListOfAlts_Elmt_Sequence -> Bool
< :: StringLiteralLong2_ListOfAlts_Elmt_Sequence
-> StringLiteralLong2_ListOfAlts_Elmt_Sequence -> Bool
$c< :: StringLiteralLong2_ListOfAlts_Elmt_Sequence
-> StringLiteralLong2_ListOfAlts_Elmt_Sequence -> Bool
compare :: StringLiteralLong2_ListOfAlts_Elmt_Sequence
-> StringLiteralLong2_ListOfAlts_Elmt_Sequence -> Ordering
$ccompare :: StringLiteralLong2_ListOfAlts_Elmt_Sequence
-> StringLiteralLong2_ListOfAlts_Elmt_Sequence -> Ordering
Ord, ReadPrec [StringLiteralLong2_ListOfAlts_Elmt_Sequence]
ReadPrec StringLiteralLong2_ListOfAlts_Elmt_Sequence
Int -> ReadS StringLiteralLong2_ListOfAlts_Elmt_Sequence
ReadS [StringLiteralLong2_ListOfAlts_Elmt_Sequence]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [StringLiteralLong2_ListOfAlts_Elmt_Sequence]
$creadListPrec :: ReadPrec [StringLiteralLong2_ListOfAlts_Elmt_Sequence]
readPrec :: ReadPrec StringLiteralLong2_ListOfAlts_Elmt_Sequence
$creadPrec :: ReadPrec StringLiteralLong2_ListOfAlts_Elmt_Sequence
readList :: ReadS [StringLiteralLong2_ListOfAlts_Elmt_Sequence]
$creadList :: ReadS [StringLiteralLong2_ListOfAlts_Elmt_Sequence]
readsPrec :: Int -> ReadS StringLiteralLong2_ListOfAlts_Elmt_Sequence
$creadsPrec :: Int -> ReadS StringLiteralLong2_ListOfAlts_Elmt_Sequence
Read, Int -> StringLiteralLong2_ListOfAlts_Elmt_Sequence -> ShowS
[StringLiteralLong2_ListOfAlts_Elmt_Sequence] -> ShowS
StringLiteralLong2_ListOfAlts_Elmt_Sequence -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StringLiteralLong2_ListOfAlts_Elmt_Sequence] -> ShowS
$cshowList :: [StringLiteralLong2_ListOfAlts_Elmt_Sequence] -> ShowS
show :: StringLiteralLong2_ListOfAlts_Elmt_Sequence -> String
$cshow :: StringLiteralLong2_ListOfAlts_Elmt_Sequence -> String
showsPrec :: Int -> StringLiteralLong2_ListOfAlts_Elmt_Sequence -> ShowS
$cshowsPrec :: Int -> StringLiteralLong2_ListOfAlts_Elmt_Sequence -> ShowS
Show)

_StringLiteralLong2_ListOfAlts_Elmt_Sequence :: Name
_StringLiteralLong2_ListOfAlts_Elmt_Sequence = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.StringLiteralLong2.ListOfAlts.Elmt.Sequence")

_StringLiteralLong2_ListOfAlts_Elmt_Sequence_alts :: FieldName
_StringLiteralLong2_ListOfAlts_Elmt_Sequence_alts = (String -> FieldName
Core.FieldName String
"alts")

_StringLiteralLong2_ListOfAlts_Elmt_Sequence_regex :: FieldName
_StringLiteralLong2_ListOfAlts_Elmt_Sequence_regex = (String -> FieldName
Core.FieldName String
"regex")

data StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option = 
  StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_OptionQuot  |
  StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_OptionSequence StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option_Sequence
  deriving (StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option
-> StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option
-> StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option -> Bool
$c/= :: StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option
-> StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option -> Bool
== :: StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option
-> StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option -> Bool
$c== :: StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option
-> StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option -> Bool
Eq, Eq StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option
StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option
-> StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option -> Bool
StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option
-> StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option
-> Ordering
StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option
-> StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option
-> StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option
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
min :: StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option
-> StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option
-> StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option
$cmin :: StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option
-> StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option
-> StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option
max :: StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option
-> StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option
-> StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option
$cmax :: StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option
-> StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option
-> StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option
>= :: StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option
-> StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option -> Bool
$c>= :: StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option
-> StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option -> Bool
> :: StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option
-> StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option -> Bool
$c> :: StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option
-> StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option -> Bool
<= :: StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option
-> StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option -> Bool
$c<= :: StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option
-> StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option -> Bool
< :: StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option
-> StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option -> Bool
$c< :: StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option
-> StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option -> Bool
compare :: StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option
-> StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option
-> Ordering
$ccompare :: StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option
-> StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option
-> Ordering
Ord, ReadPrec [StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option]
ReadPrec StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option
Int
-> ReadS StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option
ReadS [StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option]
$creadListPrec :: ReadPrec [StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option]
readPrec :: ReadPrec StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option
$creadPrec :: ReadPrec StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option
readList :: ReadS [StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option]
$creadList :: ReadS [StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option]
readsPrec :: Int
-> ReadS StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option
$creadsPrec :: Int
-> ReadS StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option
Read, Int
-> StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option -> ShowS
[StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option] -> ShowS
StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option] -> ShowS
$cshowList :: [StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option] -> ShowS
show :: StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option -> String
$cshow :: StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option -> String
showsPrec :: Int
-> StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option -> ShowS
$cshowsPrec :: Int
-> StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option -> ShowS
Show)

_StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option :: Name
_StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.StringLiteralLong2.ListOfAlts.Elmt.Sequence.Alts.Option")

_StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option_quot :: FieldName
_StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option_quot = (String -> FieldName
Core.FieldName String
"quot")

_StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option_sequence :: FieldName
_StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option_sequence = (String -> FieldName
Core.FieldName String
"sequence")

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

_StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option_Sequence :: Name
_StringLiteralLong2_ListOfAlts_Elmt_Sequence_Alts_Option_Sequence = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.StringLiteralLong2.ListOfAlts.Elmt.Sequence.Alts.Option.Sequence")

data Uchar = 
  UcharSequence Uchar_Sequence |
  UcharSequence2 Uchar_Sequence2
  deriving (Uchar -> Uchar -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Uchar -> Uchar -> Bool
$c/= :: Uchar -> Uchar -> Bool
== :: Uchar -> Uchar -> Bool
$c== :: Uchar -> Uchar -> Bool
Eq, Eq Uchar
Uchar -> Uchar -> Bool
Uchar -> Uchar -> Ordering
Uchar -> Uchar -> Uchar
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
min :: Uchar -> Uchar -> Uchar
$cmin :: Uchar -> Uchar -> Uchar
max :: Uchar -> Uchar -> Uchar
$cmax :: Uchar -> Uchar -> Uchar
>= :: Uchar -> Uchar -> Bool
$c>= :: Uchar -> Uchar -> Bool
> :: Uchar -> Uchar -> Bool
$c> :: Uchar -> Uchar -> Bool
<= :: Uchar -> Uchar -> Bool
$c<= :: Uchar -> Uchar -> Bool
< :: Uchar -> Uchar -> Bool
$c< :: Uchar -> Uchar -> Bool
compare :: Uchar -> Uchar -> Ordering
$ccompare :: Uchar -> Uchar -> Ordering
Ord, ReadPrec [Uchar]
ReadPrec Uchar
Int -> ReadS Uchar
ReadS [Uchar]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Uchar]
$creadListPrec :: ReadPrec [Uchar]
readPrec :: ReadPrec Uchar
$creadPrec :: ReadPrec Uchar
readList :: ReadS [Uchar]
$creadList :: ReadS [Uchar]
readsPrec :: Int -> ReadS Uchar
$creadsPrec :: Int -> ReadS Uchar
Read, Int -> Uchar -> ShowS
[Uchar] -> ShowS
Uchar -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Uchar] -> ShowS
$cshowList :: [Uchar] -> ShowS
show :: Uchar -> String
$cshow :: Uchar -> String
showsPrec :: Int -> Uchar -> ShowS
$cshowsPrec :: Int -> Uchar -> ShowS
Show)

_Uchar :: Name
_Uchar = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.Uchar")

_Uchar_sequence :: FieldName
_Uchar_sequence = (String -> FieldName
Core.FieldName String
"sequence")

_Uchar_sequence2 :: FieldName
_Uchar_sequence2 = (String -> FieldName
Core.FieldName String
"sequence2")

data Uchar_Sequence = 
  Uchar_Sequence {
    Uchar_Sequence -> Hex
uchar_SequenceHex :: Hex,
    Uchar_Sequence -> Hex
uchar_SequenceHex2 :: Hex,
    Uchar_Sequence -> Hex
uchar_SequenceHex3 :: Hex,
    Uchar_Sequence -> Hex
uchar_SequenceHex4 :: Hex}
  deriving (Uchar_Sequence -> Uchar_Sequence -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Uchar_Sequence -> Uchar_Sequence -> Bool
$c/= :: Uchar_Sequence -> Uchar_Sequence -> Bool
== :: Uchar_Sequence -> Uchar_Sequence -> Bool
$c== :: Uchar_Sequence -> Uchar_Sequence -> Bool
Eq, Eq Uchar_Sequence
Uchar_Sequence -> Uchar_Sequence -> Bool
Uchar_Sequence -> Uchar_Sequence -> Ordering
Uchar_Sequence -> Uchar_Sequence -> Uchar_Sequence
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
min :: Uchar_Sequence -> Uchar_Sequence -> Uchar_Sequence
$cmin :: Uchar_Sequence -> Uchar_Sequence -> Uchar_Sequence
max :: Uchar_Sequence -> Uchar_Sequence -> Uchar_Sequence
$cmax :: Uchar_Sequence -> Uchar_Sequence -> Uchar_Sequence
>= :: Uchar_Sequence -> Uchar_Sequence -> Bool
$c>= :: Uchar_Sequence -> Uchar_Sequence -> Bool
> :: Uchar_Sequence -> Uchar_Sequence -> Bool
$c> :: Uchar_Sequence -> Uchar_Sequence -> Bool
<= :: Uchar_Sequence -> Uchar_Sequence -> Bool
$c<= :: Uchar_Sequence -> Uchar_Sequence -> Bool
< :: Uchar_Sequence -> Uchar_Sequence -> Bool
$c< :: Uchar_Sequence -> Uchar_Sequence -> Bool
compare :: Uchar_Sequence -> Uchar_Sequence -> Ordering
$ccompare :: Uchar_Sequence -> Uchar_Sequence -> Ordering
Ord, ReadPrec [Uchar_Sequence]
ReadPrec Uchar_Sequence
Int -> ReadS Uchar_Sequence
ReadS [Uchar_Sequence]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Uchar_Sequence]
$creadListPrec :: ReadPrec [Uchar_Sequence]
readPrec :: ReadPrec Uchar_Sequence
$creadPrec :: ReadPrec Uchar_Sequence
readList :: ReadS [Uchar_Sequence]
$creadList :: ReadS [Uchar_Sequence]
readsPrec :: Int -> ReadS Uchar_Sequence
$creadsPrec :: Int -> ReadS Uchar_Sequence
Read, Int -> Uchar_Sequence -> ShowS
[Uchar_Sequence] -> ShowS
Uchar_Sequence -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Uchar_Sequence] -> ShowS
$cshowList :: [Uchar_Sequence] -> ShowS
show :: Uchar_Sequence -> String
$cshow :: Uchar_Sequence -> String
showsPrec :: Int -> Uchar_Sequence -> ShowS
$cshowsPrec :: Int -> Uchar_Sequence -> ShowS
Show)

_Uchar_Sequence :: Name
_Uchar_Sequence = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.Uchar.Sequence")

_Uchar_Sequence_hex :: FieldName
_Uchar_Sequence_hex = (String -> FieldName
Core.FieldName String
"hex")

_Uchar_Sequence_hex2 :: FieldName
_Uchar_Sequence_hex2 = (String -> FieldName
Core.FieldName String
"hex2")

_Uchar_Sequence_hex3 :: FieldName
_Uchar_Sequence_hex3 = (String -> FieldName
Core.FieldName String
"hex3")

_Uchar_Sequence_hex4 :: FieldName
_Uchar_Sequence_hex4 = (String -> FieldName
Core.FieldName String
"hex4")

data Uchar_Sequence2 = 
  Uchar_Sequence2 {
    Uchar_Sequence2 -> Hex
uchar_Sequence2Hex :: Hex,
    Uchar_Sequence2 -> Hex
uchar_Sequence2Hex2 :: Hex,
    Uchar_Sequence2 -> Hex
uchar_Sequence2Hex3 :: Hex,
    Uchar_Sequence2 -> Hex
uchar_Sequence2Hex4 :: Hex,
    Uchar_Sequence2 -> Hex
uchar_Sequence2Hex5 :: Hex,
    Uchar_Sequence2 -> Hex
uchar_Sequence2Hex6 :: Hex,
    Uchar_Sequence2 -> Hex
uchar_Sequence2Hex7 :: Hex,
    Uchar_Sequence2 -> Hex
uchar_Sequence2Hex8 :: Hex}
  deriving (Uchar_Sequence2 -> Uchar_Sequence2 -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Uchar_Sequence2 -> Uchar_Sequence2 -> Bool
$c/= :: Uchar_Sequence2 -> Uchar_Sequence2 -> Bool
== :: Uchar_Sequence2 -> Uchar_Sequence2 -> Bool
$c== :: Uchar_Sequence2 -> Uchar_Sequence2 -> Bool
Eq, Eq Uchar_Sequence2
Uchar_Sequence2 -> Uchar_Sequence2 -> Bool
Uchar_Sequence2 -> Uchar_Sequence2 -> Ordering
Uchar_Sequence2 -> Uchar_Sequence2 -> Uchar_Sequence2
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
min :: Uchar_Sequence2 -> Uchar_Sequence2 -> Uchar_Sequence2
$cmin :: Uchar_Sequence2 -> Uchar_Sequence2 -> Uchar_Sequence2
max :: Uchar_Sequence2 -> Uchar_Sequence2 -> Uchar_Sequence2
$cmax :: Uchar_Sequence2 -> Uchar_Sequence2 -> Uchar_Sequence2
>= :: Uchar_Sequence2 -> Uchar_Sequence2 -> Bool
$c>= :: Uchar_Sequence2 -> Uchar_Sequence2 -> Bool
> :: Uchar_Sequence2 -> Uchar_Sequence2 -> Bool
$c> :: Uchar_Sequence2 -> Uchar_Sequence2 -> Bool
<= :: Uchar_Sequence2 -> Uchar_Sequence2 -> Bool
$c<= :: Uchar_Sequence2 -> Uchar_Sequence2 -> Bool
< :: Uchar_Sequence2 -> Uchar_Sequence2 -> Bool
$c< :: Uchar_Sequence2 -> Uchar_Sequence2 -> Bool
compare :: Uchar_Sequence2 -> Uchar_Sequence2 -> Ordering
$ccompare :: Uchar_Sequence2 -> Uchar_Sequence2 -> Ordering
Ord, ReadPrec [Uchar_Sequence2]
ReadPrec Uchar_Sequence2
Int -> ReadS Uchar_Sequence2
ReadS [Uchar_Sequence2]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Uchar_Sequence2]
$creadListPrec :: ReadPrec [Uchar_Sequence2]
readPrec :: ReadPrec Uchar_Sequence2
$creadPrec :: ReadPrec Uchar_Sequence2
readList :: ReadS [Uchar_Sequence2]
$creadList :: ReadS [Uchar_Sequence2]
readsPrec :: Int -> ReadS Uchar_Sequence2
$creadsPrec :: Int -> ReadS Uchar_Sequence2
Read, Int -> Uchar_Sequence2 -> ShowS
[Uchar_Sequence2] -> ShowS
Uchar_Sequence2 -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Uchar_Sequence2] -> ShowS
$cshowList :: [Uchar_Sequence2] -> ShowS
show :: Uchar_Sequence2 -> String
$cshow :: Uchar_Sequence2 -> String
showsPrec :: Int -> Uchar_Sequence2 -> ShowS
$cshowsPrec :: Int -> Uchar_Sequence2 -> ShowS
Show)

_Uchar_Sequence2 :: Name
_Uchar_Sequence2 = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.Uchar.Sequence2")

_Uchar_Sequence2_hex :: FieldName
_Uchar_Sequence2_hex = (String -> FieldName
Core.FieldName String
"hex")

_Uchar_Sequence2_hex2 :: FieldName
_Uchar_Sequence2_hex2 = (String -> FieldName
Core.FieldName String
"hex2")

_Uchar_Sequence2_hex3 :: FieldName
_Uchar_Sequence2_hex3 = (String -> FieldName
Core.FieldName String
"hex3")

_Uchar_Sequence2_hex4 :: FieldName
_Uchar_Sequence2_hex4 = (String -> FieldName
Core.FieldName String
"hex4")

_Uchar_Sequence2_hex5 :: FieldName
_Uchar_Sequence2_hex5 = (String -> FieldName
Core.FieldName String
"hex5")

_Uchar_Sequence2_hex6 :: FieldName
_Uchar_Sequence2_hex6 = (String -> FieldName
Core.FieldName String
"hex6")

_Uchar_Sequence2_hex7 :: FieldName
_Uchar_Sequence2_hex7 = (String -> FieldName
Core.FieldName String
"hex7")

_Uchar_Sequence2_hex8 :: FieldName
_Uchar_Sequence2_hex8 = (String -> FieldName
Core.FieldName String
"hex8")

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

_Echar :: Name
_Echar = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.Echar")

_Echar_regex :: FieldName
_Echar_regex = (String -> FieldName
Core.FieldName String
"regex")

data PnCharsBase = 
  PnCharsBaseRegex String |
  PnCharsBaseRegex2 String
  deriving (PnCharsBase -> PnCharsBase -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PnCharsBase -> PnCharsBase -> Bool
$c/= :: PnCharsBase -> PnCharsBase -> Bool
== :: PnCharsBase -> PnCharsBase -> Bool
$c== :: PnCharsBase -> PnCharsBase -> Bool
Eq, Eq PnCharsBase
PnCharsBase -> PnCharsBase -> Bool
PnCharsBase -> PnCharsBase -> Ordering
PnCharsBase -> PnCharsBase -> PnCharsBase
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
min :: PnCharsBase -> PnCharsBase -> PnCharsBase
$cmin :: PnCharsBase -> PnCharsBase -> PnCharsBase
max :: PnCharsBase -> PnCharsBase -> PnCharsBase
$cmax :: PnCharsBase -> PnCharsBase -> PnCharsBase
>= :: PnCharsBase -> PnCharsBase -> Bool
$c>= :: PnCharsBase -> PnCharsBase -> Bool
> :: PnCharsBase -> PnCharsBase -> Bool
$c> :: PnCharsBase -> PnCharsBase -> Bool
<= :: PnCharsBase -> PnCharsBase -> Bool
$c<= :: PnCharsBase -> PnCharsBase -> Bool
< :: PnCharsBase -> PnCharsBase -> Bool
$c< :: PnCharsBase -> PnCharsBase -> Bool
compare :: PnCharsBase -> PnCharsBase -> Ordering
$ccompare :: PnCharsBase -> PnCharsBase -> Ordering
Ord, ReadPrec [PnCharsBase]
ReadPrec PnCharsBase
Int -> ReadS PnCharsBase
ReadS [PnCharsBase]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [PnCharsBase]
$creadListPrec :: ReadPrec [PnCharsBase]
readPrec :: ReadPrec PnCharsBase
$creadPrec :: ReadPrec PnCharsBase
readList :: ReadS [PnCharsBase]
$creadList :: ReadS [PnCharsBase]
readsPrec :: Int -> ReadS PnCharsBase
$creadsPrec :: Int -> ReadS PnCharsBase
Read, Int -> PnCharsBase -> ShowS
[PnCharsBase] -> ShowS
PnCharsBase -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PnCharsBase] -> ShowS
$cshowList :: [PnCharsBase] -> ShowS
show :: PnCharsBase -> String
$cshow :: PnCharsBase -> String
showsPrec :: Int -> PnCharsBase -> ShowS
$cshowsPrec :: Int -> PnCharsBase -> ShowS
Show)

_PnCharsBase :: Name
_PnCharsBase = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.PnCharsBase")

_PnCharsBase_regex :: FieldName
_PnCharsBase_regex = (String -> FieldName
Core.FieldName String
"regex")

_PnCharsBase_regex2 :: FieldName
_PnCharsBase_regex2 = (String -> FieldName
Core.FieldName String
"regex2")

data PnCharsU = 
  PnCharsUPnCharsBase PnCharsBase |
  PnCharsULowbar 
  deriving (PnCharsU -> PnCharsU -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PnCharsU -> PnCharsU -> Bool
$c/= :: PnCharsU -> PnCharsU -> Bool
== :: PnCharsU -> PnCharsU -> Bool
$c== :: PnCharsU -> PnCharsU -> Bool
Eq, Eq PnCharsU
PnCharsU -> PnCharsU -> Bool
PnCharsU -> PnCharsU -> Ordering
PnCharsU -> PnCharsU -> PnCharsU
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
min :: PnCharsU -> PnCharsU -> PnCharsU
$cmin :: PnCharsU -> PnCharsU -> PnCharsU
max :: PnCharsU -> PnCharsU -> PnCharsU
$cmax :: PnCharsU -> PnCharsU -> PnCharsU
>= :: PnCharsU -> PnCharsU -> Bool
$c>= :: PnCharsU -> PnCharsU -> Bool
> :: PnCharsU -> PnCharsU -> Bool
$c> :: PnCharsU -> PnCharsU -> Bool
<= :: PnCharsU -> PnCharsU -> Bool
$c<= :: PnCharsU -> PnCharsU -> Bool
< :: PnCharsU -> PnCharsU -> Bool
$c< :: PnCharsU -> PnCharsU -> Bool
compare :: PnCharsU -> PnCharsU -> Ordering
$ccompare :: PnCharsU -> PnCharsU -> Ordering
Ord, ReadPrec [PnCharsU]
ReadPrec PnCharsU
Int -> ReadS PnCharsU
ReadS [PnCharsU]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [PnCharsU]
$creadListPrec :: ReadPrec [PnCharsU]
readPrec :: ReadPrec PnCharsU
$creadPrec :: ReadPrec PnCharsU
readList :: ReadS [PnCharsU]
$creadList :: ReadS [PnCharsU]
readsPrec :: Int -> ReadS PnCharsU
$creadsPrec :: Int -> ReadS PnCharsU
Read, Int -> PnCharsU -> ShowS
[PnCharsU] -> ShowS
PnCharsU -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PnCharsU] -> ShowS
$cshowList :: [PnCharsU] -> ShowS
show :: PnCharsU -> String
$cshow :: PnCharsU -> String
showsPrec :: Int -> PnCharsU -> ShowS
$cshowsPrec :: Int -> PnCharsU -> ShowS
Show)

_PnCharsU :: Name
_PnCharsU = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.PnCharsU")

_PnCharsU_pnCharsBase :: FieldName
_PnCharsU_pnCharsBase = (String -> FieldName
Core.FieldName String
"pnCharsBase")

_PnCharsU_lowbar :: FieldName
_PnCharsU_lowbar = (String -> FieldName
Core.FieldName String
"lowbar")

data PnChars = 
  PnCharsPnCharsU PnCharsU |
  PnCharsMinus  |
  PnCharsRegex String
  deriving (PnChars -> PnChars -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PnChars -> PnChars -> Bool
$c/= :: PnChars -> PnChars -> Bool
== :: PnChars -> PnChars -> Bool
$c== :: PnChars -> PnChars -> Bool
Eq, Eq PnChars
PnChars -> PnChars -> Bool
PnChars -> PnChars -> Ordering
PnChars -> PnChars -> PnChars
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
min :: PnChars -> PnChars -> PnChars
$cmin :: PnChars -> PnChars -> PnChars
max :: PnChars -> PnChars -> PnChars
$cmax :: PnChars -> PnChars -> PnChars
>= :: PnChars -> PnChars -> Bool
$c>= :: PnChars -> PnChars -> Bool
> :: PnChars -> PnChars -> Bool
$c> :: PnChars -> PnChars -> Bool
<= :: PnChars -> PnChars -> Bool
$c<= :: PnChars -> PnChars -> Bool
< :: PnChars -> PnChars -> Bool
$c< :: PnChars -> PnChars -> Bool
compare :: PnChars -> PnChars -> Ordering
$ccompare :: PnChars -> PnChars -> Ordering
Ord, ReadPrec [PnChars]
ReadPrec PnChars
Int -> ReadS PnChars
ReadS [PnChars]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [PnChars]
$creadListPrec :: ReadPrec [PnChars]
readPrec :: ReadPrec PnChars
$creadPrec :: ReadPrec PnChars
readList :: ReadS [PnChars]
$creadList :: ReadS [PnChars]
readsPrec :: Int -> ReadS PnChars
$creadsPrec :: Int -> ReadS PnChars
Read, Int -> PnChars -> ShowS
[PnChars] -> ShowS
PnChars -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PnChars] -> ShowS
$cshowList :: [PnChars] -> ShowS
show :: PnChars -> String
$cshow :: PnChars -> String
showsPrec :: Int -> PnChars -> ShowS
$cshowsPrec :: Int -> PnChars -> ShowS
Show)

_PnChars :: Name
_PnChars = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.PnChars")

_PnChars_pnCharsU :: FieldName
_PnChars_pnCharsU = (String -> FieldName
Core.FieldName String
"pnCharsU")

_PnChars_minus :: FieldName
_PnChars_minus = (String -> FieldName
Core.FieldName String
"minus")

_PnChars_regex :: FieldName
_PnChars_regex = (String -> FieldName
Core.FieldName String
"regex")

data PnPrefix = 
  PnPrefix {
    PnPrefix -> PnCharsBase
pnPrefixPnCharsBase :: PnCharsBase,
    PnPrefix -> Maybe PnPrefix_Sequence_Option
pnPrefixSequence :: (Maybe PnPrefix_Sequence_Option)}
  deriving (PnPrefix -> PnPrefix -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PnPrefix -> PnPrefix -> Bool
$c/= :: PnPrefix -> PnPrefix -> Bool
== :: PnPrefix -> PnPrefix -> Bool
$c== :: PnPrefix -> PnPrefix -> Bool
Eq, Eq PnPrefix
PnPrefix -> PnPrefix -> Bool
PnPrefix -> PnPrefix -> Ordering
PnPrefix -> PnPrefix -> PnPrefix
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
min :: PnPrefix -> PnPrefix -> PnPrefix
$cmin :: PnPrefix -> PnPrefix -> PnPrefix
max :: PnPrefix -> PnPrefix -> PnPrefix
$cmax :: PnPrefix -> PnPrefix -> PnPrefix
>= :: PnPrefix -> PnPrefix -> Bool
$c>= :: PnPrefix -> PnPrefix -> Bool
> :: PnPrefix -> PnPrefix -> Bool
$c> :: PnPrefix -> PnPrefix -> Bool
<= :: PnPrefix -> PnPrefix -> Bool
$c<= :: PnPrefix -> PnPrefix -> Bool
< :: PnPrefix -> PnPrefix -> Bool
$c< :: PnPrefix -> PnPrefix -> Bool
compare :: PnPrefix -> PnPrefix -> Ordering
$ccompare :: PnPrefix -> PnPrefix -> Ordering
Ord, ReadPrec [PnPrefix]
ReadPrec PnPrefix
Int -> ReadS PnPrefix
ReadS [PnPrefix]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [PnPrefix]
$creadListPrec :: ReadPrec [PnPrefix]
readPrec :: ReadPrec PnPrefix
$creadPrec :: ReadPrec PnPrefix
readList :: ReadS [PnPrefix]
$creadList :: ReadS [PnPrefix]
readsPrec :: Int -> ReadS PnPrefix
$creadsPrec :: Int -> ReadS PnPrefix
Read, Int -> PnPrefix -> ShowS
[PnPrefix] -> ShowS
PnPrefix -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PnPrefix] -> ShowS
$cshowList :: [PnPrefix] -> ShowS
show :: PnPrefix -> String
$cshow :: PnPrefix -> String
showsPrec :: Int -> PnPrefix -> ShowS
$cshowsPrec :: Int -> PnPrefix -> ShowS
Show)

_PnPrefix :: Name
_PnPrefix = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.PnPrefix")

_PnPrefix_pnCharsBase :: FieldName
_PnPrefix_pnCharsBase = (String -> FieldName
Core.FieldName String
"pnCharsBase")

_PnPrefix_sequence :: FieldName
_PnPrefix_sequence = (String -> FieldName
Core.FieldName String
"sequence")

data PnPrefix_Sequence_Option = 
  PnPrefix_Sequence_Option {
    PnPrefix_Sequence_Option -> PnPrefix_Sequence_Option_Alts
pnPrefix_Sequence_OptionAlts :: PnPrefix_Sequence_Option_Alts,
    PnPrefix_Sequence_Option -> PnChars
pnPrefix_Sequence_OptionPnChars :: PnChars}
  deriving (PnPrefix_Sequence_Option -> PnPrefix_Sequence_Option -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PnPrefix_Sequence_Option -> PnPrefix_Sequence_Option -> Bool
$c/= :: PnPrefix_Sequence_Option -> PnPrefix_Sequence_Option -> Bool
== :: PnPrefix_Sequence_Option -> PnPrefix_Sequence_Option -> Bool
$c== :: PnPrefix_Sequence_Option -> PnPrefix_Sequence_Option -> Bool
Eq, Eq PnPrefix_Sequence_Option
PnPrefix_Sequence_Option -> PnPrefix_Sequence_Option -> Bool
PnPrefix_Sequence_Option -> PnPrefix_Sequence_Option -> Ordering
PnPrefix_Sequence_Option
-> PnPrefix_Sequence_Option -> PnPrefix_Sequence_Option
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
min :: PnPrefix_Sequence_Option
-> PnPrefix_Sequence_Option -> PnPrefix_Sequence_Option
$cmin :: PnPrefix_Sequence_Option
-> PnPrefix_Sequence_Option -> PnPrefix_Sequence_Option
max :: PnPrefix_Sequence_Option
-> PnPrefix_Sequence_Option -> PnPrefix_Sequence_Option
$cmax :: PnPrefix_Sequence_Option
-> PnPrefix_Sequence_Option -> PnPrefix_Sequence_Option
>= :: PnPrefix_Sequence_Option -> PnPrefix_Sequence_Option -> Bool
$c>= :: PnPrefix_Sequence_Option -> PnPrefix_Sequence_Option -> Bool
> :: PnPrefix_Sequence_Option -> PnPrefix_Sequence_Option -> Bool
$c> :: PnPrefix_Sequence_Option -> PnPrefix_Sequence_Option -> Bool
<= :: PnPrefix_Sequence_Option -> PnPrefix_Sequence_Option -> Bool
$c<= :: PnPrefix_Sequence_Option -> PnPrefix_Sequence_Option -> Bool
< :: PnPrefix_Sequence_Option -> PnPrefix_Sequence_Option -> Bool
$c< :: PnPrefix_Sequence_Option -> PnPrefix_Sequence_Option -> Bool
compare :: PnPrefix_Sequence_Option -> PnPrefix_Sequence_Option -> Ordering
$ccompare :: PnPrefix_Sequence_Option -> PnPrefix_Sequence_Option -> Ordering
Ord, ReadPrec [PnPrefix_Sequence_Option]
ReadPrec PnPrefix_Sequence_Option
Int -> ReadS PnPrefix_Sequence_Option
ReadS [PnPrefix_Sequence_Option]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [PnPrefix_Sequence_Option]
$creadListPrec :: ReadPrec [PnPrefix_Sequence_Option]
readPrec :: ReadPrec PnPrefix_Sequence_Option
$creadPrec :: ReadPrec PnPrefix_Sequence_Option
readList :: ReadS [PnPrefix_Sequence_Option]
$creadList :: ReadS [PnPrefix_Sequence_Option]
readsPrec :: Int -> ReadS PnPrefix_Sequence_Option
$creadsPrec :: Int -> ReadS PnPrefix_Sequence_Option
Read, Int -> PnPrefix_Sequence_Option -> ShowS
[PnPrefix_Sequence_Option] -> ShowS
PnPrefix_Sequence_Option -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PnPrefix_Sequence_Option] -> ShowS
$cshowList :: [PnPrefix_Sequence_Option] -> ShowS
show :: PnPrefix_Sequence_Option -> String
$cshow :: PnPrefix_Sequence_Option -> String
showsPrec :: Int -> PnPrefix_Sequence_Option -> ShowS
$cshowsPrec :: Int -> PnPrefix_Sequence_Option -> ShowS
Show)

_PnPrefix_Sequence_Option :: Name
_PnPrefix_Sequence_Option = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.PnPrefix.Sequence.Option")

_PnPrefix_Sequence_Option_alts :: FieldName
_PnPrefix_Sequence_Option_alts = (String -> FieldName
Core.FieldName String
"alts")

_PnPrefix_Sequence_Option_pnChars :: FieldName
_PnPrefix_Sequence_Option_pnChars = (String -> FieldName
Core.FieldName String
"pnChars")

data PnPrefix_Sequence_Option_Alts = 
  PnPrefix_Sequence_Option_AltsPnChars PnChars |
  PnPrefix_Sequence_Option_AltsPeriod 
  deriving (PnPrefix_Sequence_Option_Alts
-> PnPrefix_Sequence_Option_Alts -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PnPrefix_Sequence_Option_Alts
-> PnPrefix_Sequence_Option_Alts -> Bool
$c/= :: PnPrefix_Sequence_Option_Alts
-> PnPrefix_Sequence_Option_Alts -> Bool
== :: PnPrefix_Sequence_Option_Alts
-> PnPrefix_Sequence_Option_Alts -> Bool
$c== :: PnPrefix_Sequence_Option_Alts
-> PnPrefix_Sequence_Option_Alts -> Bool
Eq, Eq PnPrefix_Sequence_Option_Alts
PnPrefix_Sequence_Option_Alts
-> PnPrefix_Sequence_Option_Alts -> Bool
PnPrefix_Sequence_Option_Alts
-> PnPrefix_Sequence_Option_Alts -> Ordering
PnPrefix_Sequence_Option_Alts
-> PnPrefix_Sequence_Option_Alts -> PnPrefix_Sequence_Option_Alts
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
min :: PnPrefix_Sequence_Option_Alts
-> PnPrefix_Sequence_Option_Alts -> PnPrefix_Sequence_Option_Alts
$cmin :: PnPrefix_Sequence_Option_Alts
-> PnPrefix_Sequence_Option_Alts -> PnPrefix_Sequence_Option_Alts
max :: PnPrefix_Sequence_Option_Alts
-> PnPrefix_Sequence_Option_Alts -> PnPrefix_Sequence_Option_Alts
$cmax :: PnPrefix_Sequence_Option_Alts
-> PnPrefix_Sequence_Option_Alts -> PnPrefix_Sequence_Option_Alts
>= :: PnPrefix_Sequence_Option_Alts
-> PnPrefix_Sequence_Option_Alts -> Bool
$c>= :: PnPrefix_Sequence_Option_Alts
-> PnPrefix_Sequence_Option_Alts -> Bool
> :: PnPrefix_Sequence_Option_Alts
-> PnPrefix_Sequence_Option_Alts -> Bool
$c> :: PnPrefix_Sequence_Option_Alts
-> PnPrefix_Sequence_Option_Alts -> Bool
<= :: PnPrefix_Sequence_Option_Alts
-> PnPrefix_Sequence_Option_Alts -> Bool
$c<= :: PnPrefix_Sequence_Option_Alts
-> PnPrefix_Sequence_Option_Alts -> Bool
< :: PnPrefix_Sequence_Option_Alts
-> PnPrefix_Sequence_Option_Alts -> Bool
$c< :: PnPrefix_Sequence_Option_Alts
-> PnPrefix_Sequence_Option_Alts -> Bool
compare :: PnPrefix_Sequence_Option_Alts
-> PnPrefix_Sequence_Option_Alts -> Ordering
$ccompare :: PnPrefix_Sequence_Option_Alts
-> PnPrefix_Sequence_Option_Alts -> Ordering
Ord, ReadPrec [PnPrefix_Sequence_Option_Alts]
ReadPrec PnPrefix_Sequence_Option_Alts
Int -> ReadS PnPrefix_Sequence_Option_Alts
ReadS [PnPrefix_Sequence_Option_Alts]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [PnPrefix_Sequence_Option_Alts]
$creadListPrec :: ReadPrec [PnPrefix_Sequence_Option_Alts]
readPrec :: ReadPrec PnPrefix_Sequence_Option_Alts
$creadPrec :: ReadPrec PnPrefix_Sequence_Option_Alts
readList :: ReadS [PnPrefix_Sequence_Option_Alts]
$creadList :: ReadS [PnPrefix_Sequence_Option_Alts]
readsPrec :: Int -> ReadS PnPrefix_Sequence_Option_Alts
$creadsPrec :: Int -> ReadS PnPrefix_Sequence_Option_Alts
Read, Int -> PnPrefix_Sequence_Option_Alts -> ShowS
[PnPrefix_Sequence_Option_Alts] -> ShowS
PnPrefix_Sequence_Option_Alts -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PnPrefix_Sequence_Option_Alts] -> ShowS
$cshowList :: [PnPrefix_Sequence_Option_Alts] -> ShowS
show :: PnPrefix_Sequence_Option_Alts -> String
$cshow :: PnPrefix_Sequence_Option_Alts -> String
showsPrec :: Int -> PnPrefix_Sequence_Option_Alts -> ShowS
$cshowsPrec :: Int -> PnPrefix_Sequence_Option_Alts -> ShowS
Show)

_PnPrefix_Sequence_Option_Alts :: Name
_PnPrefix_Sequence_Option_Alts = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.PnPrefix.Sequence.Option.Alts")

_PnPrefix_Sequence_Option_Alts_pnChars :: FieldName
_PnPrefix_Sequence_Option_Alts_pnChars = (String -> FieldName
Core.FieldName String
"pnChars")

_PnPrefix_Sequence_Option_Alts_period :: FieldName
_PnPrefix_Sequence_Option_Alts_period = (String -> FieldName
Core.FieldName String
"period")

data PnLocal = 
  PnLocal {
    PnLocal -> PnLocal_Alts
pnLocalAlts :: PnLocal_Alts,
    PnLocal -> Maybe PnLocal_Sequence_Option
pnLocalSequence :: (Maybe PnLocal_Sequence_Option)}
  deriving (PnLocal -> PnLocal -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PnLocal -> PnLocal -> Bool
$c/= :: PnLocal -> PnLocal -> Bool
== :: PnLocal -> PnLocal -> Bool
$c== :: PnLocal -> PnLocal -> Bool
Eq, Eq PnLocal
PnLocal -> PnLocal -> Bool
PnLocal -> PnLocal -> Ordering
PnLocal -> PnLocal -> PnLocal
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
min :: PnLocal -> PnLocal -> PnLocal
$cmin :: PnLocal -> PnLocal -> PnLocal
max :: PnLocal -> PnLocal -> PnLocal
$cmax :: PnLocal -> PnLocal -> PnLocal
>= :: PnLocal -> PnLocal -> Bool
$c>= :: PnLocal -> PnLocal -> Bool
> :: PnLocal -> PnLocal -> Bool
$c> :: PnLocal -> PnLocal -> Bool
<= :: PnLocal -> PnLocal -> Bool
$c<= :: PnLocal -> PnLocal -> Bool
< :: PnLocal -> PnLocal -> Bool
$c< :: PnLocal -> PnLocal -> Bool
compare :: PnLocal -> PnLocal -> Ordering
$ccompare :: PnLocal -> PnLocal -> Ordering
Ord, ReadPrec [PnLocal]
ReadPrec PnLocal
Int -> ReadS PnLocal
ReadS [PnLocal]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [PnLocal]
$creadListPrec :: ReadPrec [PnLocal]
readPrec :: ReadPrec PnLocal
$creadPrec :: ReadPrec PnLocal
readList :: ReadS [PnLocal]
$creadList :: ReadS [PnLocal]
readsPrec :: Int -> ReadS PnLocal
$creadsPrec :: Int -> ReadS PnLocal
Read, Int -> PnLocal -> ShowS
[PnLocal] -> ShowS
PnLocal -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PnLocal] -> ShowS
$cshowList :: [PnLocal] -> ShowS
show :: PnLocal -> String
$cshow :: PnLocal -> String
showsPrec :: Int -> PnLocal -> ShowS
$cshowsPrec :: Int -> PnLocal -> ShowS
Show)

_PnLocal :: Name
_PnLocal = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.PnLocal")

_PnLocal_alts :: FieldName
_PnLocal_alts = (String -> FieldName
Core.FieldName String
"alts")

_PnLocal_sequence :: FieldName
_PnLocal_sequence = (String -> FieldName
Core.FieldName String
"sequence")

data PnLocal_Alts = 
  PnLocal_AltsPnCharsU PnCharsU |
  PnLocal_AltsColon  |
  PnLocal_AltsRegex String |
  PnLocal_AltsPlx Plx
  deriving (PnLocal_Alts -> PnLocal_Alts -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PnLocal_Alts -> PnLocal_Alts -> Bool
$c/= :: PnLocal_Alts -> PnLocal_Alts -> Bool
== :: PnLocal_Alts -> PnLocal_Alts -> Bool
$c== :: PnLocal_Alts -> PnLocal_Alts -> Bool
Eq, Eq PnLocal_Alts
PnLocal_Alts -> PnLocal_Alts -> Bool
PnLocal_Alts -> PnLocal_Alts -> Ordering
PnLocal_Alts -> PnLocal_Alts -> PnLocal_Alts
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
min :: PnLocal_Alts -> PnLocal_Alts -> PnLocal_Alts
$cmin :: PnLocal_Alts -> PnLocal_Alts -> PnLocal_Alts
max :: PnLocal_Alts -> PnLocal_Alts -> PnLocal_Alts
$cmax :: PnLocal_Alts -> PnLocal_Alts -> PnLocal_Alts
>= :: PnLocal_Alts -> PnLocal_Alts -> Bool
$c>= :: PnLocal_Alts -> PnLocal_Alts -> Bool
> :: PnLocal_Alts -> PnLocal_Alts -> Bool
$c> :: PnLocal_Alts -> PnLocal_Alts -> Bool
<= :: PnLocal_Alts -> PnLocal_Alts -> Bool
$c<= :: PnLocal_Alts -> PnLocal_Alts -> Bool
< :: PnLocal_Alts -> PnLocal_Alts -> Bool
$c< :: PnLocal_Alts -> PnLocal_Alts -> Bool
compare :: PnLocal_Alts -> PnLocal_Alts -> Ordering
$ccompare :: PnLocal_Alts -> PnLocal_Alts -> Ordering
Ord, ReadPrec [PnLocal_Alts]
ReadPrec PnLocal_Alts
Int -> ReadS PnLocal_Alts
ReadS [PnLocal_Alts]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [PnLocal_Alts]
$creadListPrec :: ReadPrec [PnLocal_Alts]
readPrec :: ReadPrec PnLocal_Alts
$creadPrec :: ReadPrec PnLocal_Alts
readList :: ReadS [PnLocal_Alts]
$creadList :: ReadS [PnLocal_Alts]
readsPrec :: Int -> ReadS PnLocal_Alts
$creadsPrec :: Int -> ReadS PnLocal_Alts
Read, Int -> PnLocal_Alts -> ShowS
[PnLocal_Alts] -> ShowS
PnLocal_Alts -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PnLocal_Alts] -> ShowS
$cshowList :: [PnLocal_Alts] -> ShowS
show :: PnLocal_Alts -> String
$cshow :: PnLocal_Alts -> String
showsPrec :: Int -> PnLocal_Alts -> ShowS
$cshowsPrec :: Int -> PnLocal_Alts -> ShowS
Show)

_PnLocal_Alts :: Name
_PnLocal_Alts = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.PnLocal.Alts")

_PnLocal_Alts_pnCharsU :: FieldName
_PnLocal_Alts_pnCharsU = (String -> FieldName
Core.FieldName String
"pnCharsU")

_PnLocal_Alts_colon :: FieldName
_PnLocal_Alts_colon = (String -> FieldName
Core.FieldName String
"colon")

_PnLocal_Alts_regex :: FieldName
_PnLocal_Alts_regex = (String -> FieldName
Core.FieldName String
"regex")

_PnLocal_Alts_plx :: FieldName
_PnLocal_Alts_plx = (String -> FieldName
Core.FieldName String
"plx")

data PnLocal_Sequence_Option = 
  PnLocal_Sequence_Option {
    PnLocal_Sequence_Option
-> [PnLocal_Sequence_Option_ListOfAlts_Elmt]
pnLocal_Sequence_OptionListOfAlts :: [PnLocal_Sequence_Option_ListOfAlts_Elmt],
    PnLocal_Sequence_Option -> PnLocal_Sequence_Option_Alts
pnLocal_Sequence_OptionAlts :: PnLocal_Sequence_Option_Alts}
  deriving (PnLocal_Sequence_Option -> PnLocal_Sequence_Option -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PnLocal_Sequence_Option -> PnLocal_Sequence_Option -> Bool
$c/= :: PnLocal_Sequence_Option -> PnLocal_Sequence_Option -> Bool
== :: PnLocal_Sequence_Option -> PnLocal_Sequence_Option -> Bool
$c== :: PnLocal_Sequence_Option -> PnLocal_Sequence_Option -> Bool
Eq, Eq PnLocal_Sequence_Option
PnLocal_Sequence_Option -> PnLocal_Sequence_Option -> Bool
PnLocal_Sequence_Option -> PnLocal_Sequence_Option -> Ordering
PnLocal_Sequence_Option
-> PnLocal_Sequence_Option -> PnLocal_Sequence_Option
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
min :: PnLocal_Sequence_Option
-> PnLocal_Sequence_Option -> PnLocal_Sequence_Option
$cmin :: PnLocal_Sequence_Option
-> PnLocal_Sequence_Option -> PnLocal_Sequence_Option
max :: PnLocal_Sequence_Option
-> PnLocal_Sequence_Option -> PnLocal_Sequence_Option
$cmax :: PnLocal_Sequence_Option
-> PnLocal_Sequence_Option -> PnLocal_Sequence_Option
>= :: PnLocal_Sequence_Option -> PnLocal_Sequence_Option -> Bool
$c>= :: PnLocal_Sequence_Option -> PnLocal_Sequence_Option -> Bool
> :: PnLocal_Sequence_Option -> PnLocal_Sequence_Option -> Bool
$c> :: PnLocal_Sequence_Option -> PnLocal_Sequence_Option -> Bool
<= :: PnLocal_Sequence_Option -> PnLocal_Sequence_Option -> Bool
$c<= :: PnLocal_Sequence_Option -> PnLocal_Sequence_Option -> Bool
< :: PnLocal_Sequence_Option -> PnLocal_Sequence_Option -> Bool
$c< :: PnLocal_Sequence_Option -> PnLocal_Sequence_Option -> Bool
compare :: PnLocal_Sequence_Option -> PnLocal_Sequence_Option -> Ordering
$ccompare :: PnLocal_Sequence_Option -> PnLocal_Sequence_Option -> Ordering
Ord, ReadPrec [PnLocal_Sequence_Option]
ReadPrec PnLocal_Sequence_Option
Int -> ReadS PnLocal_Sequence_Option
ReadS [PnLocal_Sequence_Option]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [PnLocal_Sequence_Option]
$creadListPrec :: ReadPrec [PnLocal_Sequence_Option]
readPrec :: ReadPrec PnLocal_Sequence_Option
$creadPrec :: ReadPrec PnLocal_Sequence_Option
readList :: ReadS [PnLocal_Sequence_Option]
$creadList :: ReadS [PnLocal_Sequence_Option]
readsPrec :: Int -> ReadS PnLocal_Sequence_Option
$creadsPrec :: Int -> ReadS PnLocal_Sequence_Option
Read, Int -> PnLocal_Sequence_Option -> ShowS
[PnLocal_Sequence_Option] -> ShowS
PnLocal_Sequence_Option -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PnLocal_Sequence_Option] -> ShowS
$cshowList :: [PnLocal_Sequence_Option] -> ShowS
show :: PnLocal_Sequence_Option -> String
$cshow :: PnLocal_Sequence_Option -> String
showsPrec :: Int -> PnLocal_Sequence_Option -> ShowS
$cshowsPrec :: Int -> PnLocal_Sequence_Option -> ShowS
Show)

_PnLocal_Sequence_Option :: Name
_PnLocal_Sequence_Option = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.PnLocal.Sequence.Option")

_PnLocal_Sequence_Option_listOfAlts :: FieldName
_PnLocal_Sequence_Option_listOfAlts = (String -> FieldName
Core.FieldName String
"listOfAlts")

_PnLocal_Sequence_Option_alts :: FieldName
_PnLocal_Sequence_Option_alts = (String -> FieldName
Core.FieldName String
"alts")

data PnLocal_Sequence_Option_ListOfAlts_Elmt = 
  PnLocal_Sequence_Option_ListOfAlts_ElmtPnChars PnChars |
  PnLocal_Sequence_Option_ListOfAlts_ElmtPeriod  |
  PnLocal_Sequence_Option_ListOfAlts_ElmtColon  |
  PnLocal_Sequence_Option_ListOfAlts_ElmtPlx Plx
  deriving (PnLocal_Sequence_Option_ListOfAlts_Elmt
-> PnLocal_Sequence_Option_ListOfAlts_Elmt -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PnLocal_Sequence_Option_ListOfAlts_Elmt
-> PnLocal_Sequence_Option_ListOfAlts_Elmt -> Bool
$c/= :: PnLocal_Sequence_Option_ListOfAlts_Elmt
-> PnLocal_Sequence_Option_ListOfAlts_Elmt -> Bool
== :: PnLocal_Sequence_Option_ListOfAlts_Elmt
-> PnLocal_Sequence_Option_ListOfAlts_Elmt -> Bool
$c== :: PnLocal_Sequence_Option_ListOfAlts_Elmt
-> PnLocal_Sequence_Option_ListOfAlts_Elmt -> Bool
Eq, Eq PnLocal_Sequence_Option_ListOfAlts_Elmt
PnLocal_Sequence_Option_ListOfAlts_Elmt
-> PnLocal_Sequence_Option_ListOfAlts_Elmt -> Bool
PnLocal_Sequence_Option_ListOfAlts_Elmt
-> PnLocal_Sequence_Option_ListOfAlts_Elmt -> Ordering
PnLocal_Sequence_Option_ListOfAlts_Elmt
-> PnLocal_Sequence_Option_ListOfAlts_Elmt
-> PnLocal_Sequence_Option_ListOfAlts_Elmt
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
min :: PnLocal_Sequence_Option_ListOfAlts_Elmt
-> PnLocal_Sequence_Option_ListOfAlts_Elmt
-> PnLocal_Sequence_Option_ListOfAlts_Elmt
$cmin :: PnLocal_Sequence_Option_ListOfAlts_Elmt
-> PnLocal_Sequence_Option_ListOfAlts_Elmt
-> PnLocal_Sequence_Option_ListOfAlts_Elmt
max :: PnLocal_Sequence_Option_ListOfAlts_Elmt
-> PnLocal_Sequence_Option_ListOfAlts_Elmt
-> PnLocal_Sequence_Option_ListOfAlts_Elmt
$cmax :: PnLocal_Sequence_Option_ListOfAlts_Elmt
-> PnLocal_Sequence_Option_ListOfAlts_Elmt
-> PnLocal_Sequence_Option_ListOfAlts_Elmt
>= :: PnLocal_Sequence_Option_ListOfAlts_Elmt
-> PnLocal_Sequence_Option_ListOfAlts_Elmt -> Bool
$c>= :: PnLocal_Sequence_Option_ListOfAlts_Elmt
-> PnLocal_Sequence_Option_ListOfAlts_Elmt -> Bool
> :: PnLocal_Sequence_Option_ListOfAlts_Elmt
-> PnLocal_Sequence_Option_ListOfAlts_Elmt -> Bool
$c> :: PnLocal_Sequence_Option_ListOfAlts_Elmt
-> PnLocal_Sequence_Option_ListOfAlts_Elmt -> Bool
<= :: PnLocal_Sequence_Option_ListOfAlts_Elmt
-> PnLocal_Sequence_Option_ListOfAlts_Elmt -> Bool
$c<= :: PnLocal_Sequence_Option_ListOfAlts_Elmt
-> PnLocal_Sequence_Option_ListOfAlts_Elmt -> Bool
< :: PnLocal_Sequence_Option_ListOfAlts_Elmt
-> PnLocal_Sequence_Option_ListOfAlts_Elmt -> Bool
$c< :: PnLocal_Sequence_Option_ListOfAlts_Elmt
-> PnLocal_Sequence_Option_ListOfAlts_Elmt -> Bool
compare :: PnLocal_Sequence_Option_ListOfAlts_Elmt
-> PnLocal_Sequence_Option_ListOfAlts_Elmt -> Ordering
$ccompare :: PnLocal_Sequence_Option_ListOfAlts_Elmt
-> PnLocal_Sequence_Option_ListOfAlts_Elmt -> Ordering
Ord, ReadPrec [PnLocal_Sequence_Option_ListOfAlts_Elmt]
ReadPrec PnLocal_Sequence_Option_ListOfAlts_Elmt
Int -> ReadS PnLocal_Sequence_Option_ListOfAlts_Elmt
ReadS [PnLocal_Sequence_Option_ListOfAlts_Elmt]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [PnLocal_Sequence_Option_ListOfAlts_Elmt]
$creadListPrec :: ReadPrec [PnLocal_Sequence_Option_ListOfAlts_Elmt]
readPrec :: ReadPrec PnLocal_Sequence_Option_ListOfAlts_Elmt
$creadPrec :: ReadPrec PnLocal_Sequence_Option_ListOfAlts_Elmt
readList :: ReadS [PnLocal_Sequence_Option_ListOfAlts_Elmt]
$creadList :: ReadS [PnLocal_Sequence_Option_ListOfAlts_Elmt]
readsPrec :: Int -> ReadS PnLocal_Sequence_Option_ListOfAlts_Elmt
$creadsPrec :: Int -> ReadS PnLocal_Sequence_Option_ListOfAlts_Elmt
Read, Int -> PnLocal_Sequence_Option_ListOfAlts_Elmt -> ShowS
[PnLocal_Sequence_Option_ListOfAlts_Elmt] -> ShowS
PnLocal_Sequence_Option_ListOfAlts_Elmt -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PnLocal_Sequence_Option_ListOfAlts_Elmt] -> ShowS
$cshowList :: [PnLocal_Sequence_Option_ListOfAlts_Elmt] -> ShowS
show :: PnLocal_Sequence_Option_ListOfAlts_Elmt -> String
$cshow :: PnLocal_Sequence_Option_ListOfAlts_Elmt -> String
showsPrec :: Int -> PnLocal_Sequence_Option_ListOfAlts_Elmt -> ShowS
$cshowsPrec :: Int -> PnLocal_Sequence_Option_ListOfAlts_Elmt -> ShowS
Show)

_PnLocal_Sequence_Option_ListOfAlts_Elmt :: Name
_PnLocal_Sequence_Option_ListOfAlts_Elmt = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.PnLocal.Sequence.Option.ListOfAlts.Elmt")

_PnLocal_Sequence_Option_ListOfAlts_Elmt_pnChars :: FieldName
_PnLocal_Sequence_Option_ListOfAlts_Elmt_pnChars = (String -> FieldName
Core.FieldName String
"pnChars")

_PnLocal_Sequence_Option_ListOfAlts_Elmt_period :: FieldName
_PnLocal_Sequence_Option_ListOfAlts_Elmt_period = (String -> FieldName
Core.FieldName String
"period")

_PnLocal_Sequence_Option_ListOfAlts_Elmt_colon :: FieldName
_PnLocal_Sequence_Option_ListOfAlts_Elmt_colon = (String -> FieldName
Core.FieldName String
"colon")

_PnLocal_Sequence_Option_ListOfAlts_Elmt_plx :: FieldName
_PnLocal_Sequence_Option_ListOfAlts_Elmt_plx = (String -> FieldName
Core.FieldName String
"plx")

data PnLocal_Sequence_Option_Alts = 
  PnLocal_Sequence_Option_AltsPnChars PnChars |
  PnLocal_Sequence_Option_AltsColon  |
  PnLocal_Sequence_Option_AltsPlx Plx
  deriving (PnLocal_Sequence_Option_Alts
-> PnLocal_Sequence_Option_Alts -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PnLocal_Sequence_Option_Alts
-> PnLocal_Sequence_Option_Alts -> Bool
$c/= :: PnLocal_Sequence_Option_Alts
-> PnLocal_Sequence_Option_Alts -> Bool
== :: PnLocal_Sequence_Option_Alts
-> PnLocal_Sequence_Option_Alts -> Bool
$c== :: PnLocal_Sequence_Option_Alts
-> PnLocal_Sequence_Option_Alts -> Bool
Eq, Eq PnLocal_Sequence_Option_Alts
PnLocal_Sequence_Option_Alts
-> PnLocal_Sequence_Option_Alts -> Bool
PnLocal_Sequence_Option_Alts
-> PnLocal_Sequence_Option_Alts -> Ordering
PnLocal_Sequence_Option_Alts
-> PnLocal_Sequence_Option_Alts -> PnLocal_Sequence_Option_Alts
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
min :: PnLocal_Sequence_Option_Alts
-> PnLocal_Sequence_Option_Alts -> PnLocal_Sequence_Option_Alts
$cmin :: PnLocal_Sequence_Option_Alts
-> PnLocal_Sequence_Option_Alts -> PnLocal_Sequence_Option_Alts
max :: PnLocal_Sequence_Option_Alts
-> PnLocal_Sequence_Option_Alts -> PnLocal_Sequence_Option_Alts
$cmax :: PnLocal_Sequence_Option_Alts
-> PnLocal_Sequence_Option_Alts -> PnLocal_Sequence_Option_Alts
>= :: PnLocal_Sequence_Option_Alts
-> PnLocal_Sequence_Option_Alts -> Bool
$c>= :: PnLocal_Sequence_Option_Alts
-> PnLocal_Sequence_Option_Alts -> Bool
> :: PnLocal_Sequence_Option_Alts
-> PnLocal_Sequence_Option_Alts -> Bool
$c> :: PnLocal_Sequence_Option_Alts
-> PnLocal_Sequence_Option_Alts -> Bool
<= :: PnLocal_Sequence_Option_Alts
-> PnLocal_Sequence_Option_Alts -> Bool
$c<= :: PnLocal_Sequence_Option_Alts
-> PnLocal_Sequence_Option_Alts -> Bool
< :: PnLocal_Sequence_Option_Alts
-> PnLocal_Sequence_Option_Alts -> Bool
$c< :: PnLocal_Sequence_Option_Alts
-> PnLocal_Sequence_Option_Alts -> Bool
compare :: PnLocal_Sequence_Option_Alts
-> PnLocal_Sequence_Option_Alts -> Ordering
$ccompare :: PnLocal_Sequence_Option_Alts
-> PnLocal_Sequence_Option_Alts -> Ordering
Ord, ReadPrec [PnLocal_Sequence_Option_Alts]
ReadPrec PnLocal_Sequence_Option_Alts
Int -> ReadS PnLocal_Sequence_Option_Alts
ReadS [PnLocal_Sequence_Option_Alts]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [PnLocal_Sequence_Option_Alts]
$creadListPrec :: ReadPrec [PnLocal_Sequence_Option_Alts]
readPrec :: ReadPrec PnLocal_Sequence_Option_Alts
$creadPrec :: ReadPrec PnLocal_Sequence_Option_Alts
readList :: ReadS [PnLocal_Sequence_Option_Alts]
$creadList :: ReadS [PnLocal_Sequence_Option_Alts]
readsPrec :: Int -> ReadS PnLocal_Sequence_Option_Alts
$creadsPrec :: Int -> ReadS PnLocal_Sequence_Option_Alts
Read, Int -> PnLocal_Sequence_Option_Alts -> ShowS
[PnLocal_Sequence_Option_Alts] -> ShowS
PnLocal_Sequence_Option_Alts -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PnLocal_Sequence_Option_Alts] -> ShowS
$cshowList :: [PnLocal_Sequence_Option_Alts] -> ShowS
show :: PnLocal_Sequence_Option_Alts -> String
$cshow :: PnLocal_Sequence_Option_Alts -> String
showsPrec :: Int -> PnLocal_Sequence_Option_Alts -> ShowS
$cshowsPrec :: Int -> PnLocal_Sequence_Option_Alts -> ShowS
Show)

_PnLocal_Sequence_Option_Alts :: Name
_PnLocal_Sequence_Option_Alts = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.PnLocal.Sequence.Option.Alts")

_PnLocal_Sequence_Option_Alts_pnChars :: FieldName
_PnLocal_Sequence_Option_Alts_pnChars = (String -> FieldName
Core.FieldName String
"pnChars")

_PnLocal_Sequence_Option_Alts_colon :: FieldName
_PnLocal_Sequence_Option_Alts_colon = (String -> FieldName
Core.FieldName String
"colon")

_PnLocal_Sequence_Option_Alts_plx :: FieldName
_PnLocal_Sequence_Option_Alts_plx = (String -> FieldName
Core.FieldName String
"plx")

data Plx = 
  PlxPercent Percent |
  PlxPnLocalEsc PnLocalEsc
  deriving (Plx -> Plx -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Plx -> Plx -> Bool
$c/= :: Plx -> Plx -> Bool
== :: Plx -> Plx -> Bool
$c== :: Plx -> Plx -> Bool
Eq, Eq Plx
Plx -> Plx -> Bool
Plx -> Plx -> Ordering
Plx -> Plx -> Plx
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
min :: Plx -> Plx -> Plx
$cmin :: Plx -> Plx -> Plx
max :: Plx -> Plx -> Plx
$cmax :: Plx -> Plx -> Plx
>= :: Plx -> Plx -> Bool
$c>= :: Plx -> Plx -> Bool
> :: Plx -> Plx -> Bool
$c> :: Plx -> Plx -> Bool
<= :: Plx -> Plx -> Bool
$c<= :: Plx -> Plx -> Bool
< :: Plx -> Plx -> Bool
$c< :: Plx -> Plx -> Bool
compare :: Plx -> Plx -> Ordering
$ccompare :: Plx -> Plx -> Ordering
Ord, ReadPrec [Plx]
ReadPrec Plx
Int -> ReadS Plx
ReadS [Plx]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Plx]
$creadListPrec :: ReadPrec [Plx]
readPrec :: ReadPrec Plx
$creadPrec :: ReadPrec Plx
readList :: ReadS [Plx]
$creadList :: ReadS [Plx]
readsPrec :: Int -> ReadS Plx
$creadsPrec :: Int -> ReadS Plx
Read, Int -> Plx -> ShowS
[Plx] -> ShowS
Plx -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Plx] -> ShowS
$cshowList :: [Plx] -> ShowS
show :: Plx -> String
$cshow :: Plx -> String
showsPrec :: Int -> Plx -> ShowS
$cshowsPrec :: Int -> Plx -> ShowS
Show)

_Plx :: Name
_Plx = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.Plx")

_Plx_percent :: FieldName
_Plx_percent = (String -> FieldName
Core.FieldName String
"percent")

_Plx_pnLocalEsc :: FieldName
_Plx_pnLocalEsc = (String -> FieldName
Core.FieldName String
"pnLocalEsc")

data Percent = 
  Percent {
    Percent -> Hex
percentHex :: Hex,
    Percent -> Hex
percentHex2 :: Hex}
  deriving (Percent -> Percent -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Percent -> Percent -> Bool
$c/= :: Percent -> Percent -> Bool
== :: Percent -> Percent -> Bool
$c== :: Percent -> Percent -> Bool
Eq, Eq Percent
Percent -> Percent -> Bool
Percent -> Percent -> Ordering
Percent -> Percent -> Percent
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
min :: Percent -> Percent -> Percent
$cmin :: Percent -> Percent -> Percent
max :: Percent -> Percent -> Percent
$cmax :: Percent -> Percent -> Percent
>= :: Percent -> Percent -> Bool
$c>= :: Percent -> Percent -> Bool
> :: Percent -> Percent -> Bool
$c> :: Percent -> Percent -> Bool
<= :: Percent -> Percent -> Bool
$c<= :: Percent -> Percent -> Bool
< :: Percent -> Percent -> Bool
$c< :: Percent -> Percent -> Bool
compare :: Percent -> Percent -> Ordering
$ccompare :: Percent -> Percent -> Ordering
Ord, ReadPrec [Percent]
ReadPrec Percent
Int -> ReadS Percent
ReadS [Percent]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Percent]
$creadListPrec :: ReadPrec [Percent]
readPrec :: ReadPrec Percent
$creadPrec :: ReadPrec Percent
readList :: ReadS [Percent]
$creadList :: ReadS [Percent]
readsPrec :: Int -> ReadS Percent
$creadsPrec :: Int -> ReadS Percent
Read, Int -> Percent -> ShowS
[Percent] -> ShowS
Percent -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Percent] -> ShowS
$cshowList :: [Percent] -> ShowS
show :: Percent -> String
$cshow :: Percent -> String
showsPrec :: Int -> Percent -> ShowS
$cshowsPrec :: Int -> Percent -> ShowS
Show)

_Percent :: Name
_Percent = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.Percent")

_Percent_hex :: FieldName
_Percent_hex = (String -> FieldName
Core.FieldName String
"hex")

_Percent_hex2 :: FieldName
_Percent_hex2 = (String -> FieldName
Core.FieldName String
"hex2")

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

_Hex :: Name
_Hex = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.Hex")

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

_PnLocalEsc :: Name
_PnLocalEsc = (String -> Name
Core.Name String
"hydra/ext/shex/syntax.PnLocalEsc")

_PnLocalEsc_regex :: FieldName
_PnLocalEsc_regex = (String -> FieldName
Core.FieldName String
"regex")