-- | An OWL 2 syntax model. See https://www.w3.org/TR/owl2-syntax

module Hydra.Ext.Owl.Syntax where

import qualified Hydra.Core as Core
import qualified Hydra.Ext.Rdf.Syntax as Syntax
import qualified Hydra.Ext.Xml.Schema as Schema
import Data.List
import Data.Map
import Data.Set

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

_Ontology :: Name
_Ontology = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.Ontology")

_Ontology_directImports :: FieldName
_Ontology_directImports = (String -> FieldName
Core.FieldName String
"directImports")

_Ontology_annotations :: FieldName
_Ontology_annotations = (String -> FieldName
Core.FieldName String
"annotations")

_Ontology_axioms :: FieldName
_Ontology_axioms = (String -> FieldName
Core.FieldName String
"axioms")

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

_Declaration :: Name
_Declaration = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.Declaration")

_Declaration_annotations :: FieldName
_Declaration_annotations = (String -> FieldName
Core.FieldName String
"annotations")

_Declaration_entity :: FieldName
_Declaration_entity = (String -> FieldName
Core.FieldName String
"entity")

data Entity = 
  EntityAnnotationProperty AnnotationProperty |
  EntityClass Class |
  EntityDataProperty DataProperty |
  EntityDatatype Datatype |
  EntityNamedIndividual NamedIndividual |
  EntityObjectProperty ObjectProperty
  deriving (Entity -> Entity -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Entity -> Entity -> Bool
$c/= :: Entity -> Entity -> Bool
== :: Entity -> Entity -> Bool
$c== :: Entity -> Entity -> Bool
Eq, Eq Entity
Entity -> Entity -> Bool
Entity -> Entity -> Ordering
Entity -> Entity -> Entity
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Entity -> Entity -> Entity
$cmin :: Entity -> Entity -> Entity
max :: Entity -> Entity -> Entity
$cmax :: Entity -> Entity -> Entity
>= :: Entity -> Entity -> Bool
$c>= :: Entity -> Entity -> Bool
> :: Entity -> Entity -> Bool
$c> :: Entity -> Entity -> Bool
<= :: Entity -> Entity -> Bool
$c<= :: Entity -> Entity -> Bool
< :: Entity -> Entity -> Bool
$c< :: Entity -> Entity -> Bool
compare :: Entity -> Entity -> Ordering
$ccompare :: Entity -> Entity -> Ordering
Ord, ReadPrec [Entity]
ReadPrec Entity
Int -> ReadS Entity
ReadS [Entity]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Entity]
$creadListPrec :: ReadPrec [Entity]
readPrec :: ReadPrec Entity
$creadPrec :: ReadPrec Entity
readList :: ReadS [Entity]
$creadList :: ReadS [Entity]
readsPrec :: Int -> ReadS Entity
$creadsPrec :: Int -> ReadS Entity
Read, Int -> Entity -> ShowS
[Entity] -> ShowS
Entity -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Entity] -> ShowS
$cshowList :: [Entity] -> ShowS
show :: Entity -> String
$cshow :: Entity -> String
showsPrec :: Int -> Entity -> ShowS
$cshowsPrec :: Int -> Entity -> ShowS
Show)

_Entity :: Name
_Entity = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.Entity")

_Entity_annotationProperty :: FieldName
_Entity_annotationProperty = (String -> FieldName
Core.FieldName String
"annotationProperty")

_Entity_class :: FieldName
_Entity_class = (String -> FieldName
Core.FieldName String
"class")

_Entity_dataProperty :: FieldName
_Entity_dataProperty = (String -> FieldName
Core.FieldName String
"dataProperty")

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

_Entity_namedIndividual :: FieldName
_Entity_namedIndividual = (String -> FieldName
Core.FieldName String
"namedIndividual")

_Entity_objectProperty :: FieldName
_Entity_objectProperty = (String -> FieldName
Core.FieldName String
"objectProperty")

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

_AnnotationSubject :: Name
_AnnotationSubject = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.AnnotationSubject")

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

_AnnotationSubject_anonymousIndividual :: FieldName
_AnnotationSubject_anonymousIndividual = (String -> FieldName
Core.FieldName String
"anonymousIndividual")

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

_AnnotationValue :: Name
_AnnotationValue = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.AnnotationValue")

_AnnotationValue_anonymousIndividual :: FieldName
_AnnotationValue_anonymousIndividual = (String -> FieldName
Core.FieldName String
"anonymousIndividual")

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

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

data Annotation = 
  Annotation {
    Annotation -> [Annotation]
annotationAnnotations :: [Annotation],
    Annotation -> AnnotationProperty
annotationProperty :: AnnotationProperty,
    Annotation -> AnnotationValue
annotationValue :: AnnotationValue}
  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/owl/syntax.Annotation")

_Annotation_annotations :: FieldName
_Annotation_annotations = (String -> FieldName
Core.FieldName String
"annotations")

_Annotation_property :: FieldName
_Annotation_property = (String -> FieldName
Core.FieldName String
"property")

_Annotation_value :: FieldName
_Annotation_value = (String -> FieldName
Core.FieldName String
"value")

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

_AnnotationAxiom :: Name
_AnnotationAxiom = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.AnnotationAxiom")

_AnnotationAxiom_annotationAssertion :: FieldName
_AnnotationAxiom_annotationAssertion = (String -> FieldName
Core.FieldName String
"annotationAssertion")

_AnnotationAxiom_annotationPropertyDomain :: FieldName
_AnnotationAxiom_annotationPropertyDomain = (String -> FieldName
Core.FieldName String
"annotationPropertyDomain")

_AnnotationAxiom_annotationPropertyRange :: FieldName
_AnnotationAxiom_annotationPropertyRange = (String -> FieldName
Core.FieldName String
"annotationPropertyRange")

_AnnotationAxiom_subAnnotationPropertyOf :: FieldName
_AnnotationAxiom_subAnnotationPropertyOf = (String -> FieldName
Core.FieldName String
"subAnnotationPropertyOf")

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

_AnnotationAssertion :: Name
_AnnotationAssertion = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.AnnotationAssertion")

_AnnotationAssertion_annotations :: FieldName
_AnnotationAssertion_annotations = (String -> FieldName
Core.FieldName String
"annotations")

_AnnotationAssertion_property :: FieldName
_AnnotationAssertion_property = (String -> FieldName
Core.FieldName String
"property")

_AnnotationAssertion_subject :: FieldName
_AnnotationAssertion_subject = (String -> FieldName
Core.FieldName String
"subject")

_AnnotationAssertion_value :: FieldName
_AnnotationAssertion_value = (String -> FieldName
Core.FieldName String
"value")

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

_SubAnnotationPropertyOf :: Name
_SubAnnotationPropertyOf = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.SubAnnotationPropertyOf")

_SubAnnotationPropertyOf_annotations :: FieldName
_SubAnnotationPropertyOf_annotations = (String -> FieldName
Core.FieldName String
"annotations")

_SubAnnotationPropertyOf_subProperty :: FieldName
_SubAnnotationPropertyOf_subProperty = (String -> FieldName
Core.FieldName String
"subProperty")

_SubAnnotationPropertyOf_superProperty :: FieldName
_SubAnnotationPropertyOf_superProperty = (String -> FieldName
Core.FieldName String
"superProperty")

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

_AnnotationPropertyDomain :: Name
_AnnotationPropertyDomain = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.AnnotationPropertyDomain")

_AnnotationPropertyDomain_annotations :: FieldName
_AnnotationPropertyDomain_annotations = (String -> FieldName
Core.FieldName String
"annotations")

_AnnotationPropertyDomain_property :: FieldName
_AnnotationPropertyDomain_property = (String -> FieldName
Core.FieldName String
"property")

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

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

_AnnotationPropertyRange :: Name
_AnnotationPropertyRange = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.AnnotationPropertyRange")

_AnnotationPropertyRange_annotations :: FieldName
_AnnotationPropertyRange_annotations = (String -> FieldName
Core.FieldName String
"annotations")

_AnnotationPropertyRange_property :: FieldName
_AnnotationPropertyRange_property = (String -> FieldName
Core.FieldName String
"property")

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

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

_Class :: Name
_Class = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.Class")

-- | See https://www.w3.org/TR/owl2-syntax/#Datatypes
data Datatype = 
  -- | Note: XML Schema datatypes are treated as a special case in this model (not in the OWL 2 specification itself) because they are particularly common
  DatatypeXmlSchema Schema.Datatype |
  DatatypeOther Syntax.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/owl/syntax.Datatype")

_Datatype_xmlSchema :: FieldName
_Datatype_xmlSchema = (String -> FieldName
Core.FieldName String
"xmlSchema")

_Datatype_other :: FieldName
_Datatype_other = (String -> FieldName
Core.FieldName String
"other")

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

_ObjectProperty :: Name
_ObjectProperty = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.ObjectProperty")

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

_DataProperty :: Name
_DataProperty = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.DataProperty")

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

_AnnotationProperty :: Name
_AnnotationProperty = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.AnnotationProperty")

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

_Individual :: Name
_Individual = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.Individual")

_Individual_named :: FieldName
_Individual_named = (String -> FieldName
Core.FieldName String
"named")

_Individual_anonymous :: FieldName
_Individual_anonymous = (String -> FieldName
Core.FieldName String
"anonymous")

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

_NamedIndividual :: Name
_NamedIndividual = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.NamedIndividual")

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

_AnonymousIndividual :: Name
_AnonymousIndividual = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.AnonymousIndividual")

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

_ObjectPropertyExpression :: Name
_ObjectPropertyExpression = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.ObjectPropertyExpression")

_ObjectPropertyExpression_object :: FieldName
_ObjectPropertyExpression_object = (String -> FieldName
Core.FieldName String
"object")

_ObjectPropertyExpression_inverseObject :: FieldName
_ObjectPropertyExpression_inverseObject = (String -> FieldName
Core.FieldName String
"inverseObject")

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

_InverseObjectProperty :: Name
_InverseObjectProperty = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.InverseObjectProperty")

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

_DataPropertyExpression :: Name
_DataPropertyExpression = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.DataPropertyExpression")

-- | See https://www.w3.org/TR/owl2-syntax/#Data_Ranges
data DataRange = 
  DataRangeDataComplementOf DataComplementOf |
  DataRangeDataIntersectionOf DataIntersectionOf |
  DataRangeDataOneOf DataOneOf |
  DataRangeDataUnionOf DataUnionOf |
  DataRangeDatatype Datatype |
  DataRangeDatatypeRestriction DatatypeRestriction
  deriving (DataRange -> DataRange -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DataRange -> DataRange -> Bool
$c/= :: DataRange -> DataRange -> Bool
== :: DataRange -> DataRange -> Bool
$c== :: DataRange -> DataRange -> Bool
Eq, Eq DataRange
DataRange -> DataRange -> Bool
DataRange -> DataRange -> Ordering
DataRange -> DataRange -> DataRange
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 :: DataRange -> DataRange -> DataRange
$cmin :: DataRange -> DataRange -> DataRange
max :: DataRange -> DataRange -> DataRange
$cmax :: DataRange -> DataRange -> DataRange
>= :: DataRange -> DataRange -> Bool
$c>= :: DataRange -> DataRange -> Bool
> :: DataRange -> DataRange -> Bool
$c> :: DataRange -> DataRange -> Bool
<= :: DataRange -> DataRange -> Bool
$c<= :: DataRange -> DataRange -> Bool
< :: DataRange -> DataRange -> Bool
$c< :: DataRange -> DataRange -> Bool
compare :: DataRange -> DataRange -> Ordering
$ccompare :: DataRange -> DataRange -> Ordering
Ord, ReadPrec [DataRange]
ReadPrec DataRange
Int -> ReadS DataRange
ReadS [DataRange]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DataRange]
$creadListPrec :: ReadPrec [DataRange]
readPrec :: ReadPrec DataRange
$creadPrec :: ReadPrec DataRange
readList :: ReadS [DataRange]
$creadList :: ReadS [DataRange]
readsPrec :: Int -> ReadS DataRange
$creadsPrec :: Int -> ReadS DataRange
Read, Int -> DataRange -> ShowS
[DataRange] -> ShowS
DataRange -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DataRange] -> ShowS
$cshowList :: [DataRange] -> ShowS
show :: DataRange -> String
$cshow :: DataRange -> String
showsPrec :: Int -> DataRange -> ShowS
$cshowsPrec :: Int -> DataRange -> ShowS
Show)

_DataRange :: Name
_DataRange = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.DataRange")

_DataRange_dataComplementOf :: FieldName
_DataRange_dataComplementOf = (String -> FieldName
Core.FieldName String
"dataComplementOf")

_DataRange_dataIntersectionOf :: FieldName
_DataRange_dataIntersectionOf = (String -> FieldName
Core.FieldName String
"dataIntersectionOf")

_DataRange_dataOneOf :: FieldName
_DataRange_dataOneOf = (String -> FieldName
Core.FieldName String
"dataOneOf")

_DataRange_dataUnionOf :: FieldName
_DataRange_dataUnionOf = (String -> FieldName
Core.FieldName String
"dataUnionOf")

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

_DataRange_datatypeRestriction :: FieldName
_DataRange_datatypeRestriction = (String -> FieldName
Core.FieldName String
"datatypeRestriction")

-- | See https://www.w3.org/TR/owl2-syntax/#Intersection_of_Data_Ranges
newtype DataIntersectionOf = 
  DataIntersectionOf {
    -- | See https://www.w3.org/TR/owl2-syntax/#Intersection_of_Data_Ranges
    DataIntersectionOf -> [DataRange]
unDataIntersectionOf :: [DataRange]}
  deriving (DataIntersectionOf -> DataIntersectionOf -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DataIntersectionOf -> DataIntersectionOf -> Bool
$c/= :: DataIntersectionOf -> DataIntersectionOf -> Bool
== :: DataIntersectionOf -> DataIntersectionOf -> Bool
$c== :: DataIntersectionOf -> DataIntersectionOf -> Bool
Eq, Eq DataIntersectionOf
DataIntersectionOf -> DataIntersectionOf -> Bool
DataIntersectionOf -> DataIntersectionOf -> Ordering
DataIntersectionOf -> DataIntersectionOf -> DataIntersectionOf
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 :: DataIntersectionOf -> DataIntersectionOf -> DataIntersectionOf
$cmin :: DataIntersectionOf -> DataIntersectionOf -> DataIntersectionOf
max :: DataIntersectionOf -> DataIntersectionOf -> DataIntersectionOf
$cmax :: DataIntersectionOf -> DataIntersectionOf -> DataIntersectionOf
>= :: DataIntersectionOf -> DataIntersectionOf -> Bool
$c>= :: DataIntersectionOf -> DataIntersectionOf -> Bool
> :: DataIntersectionOf -> DataIntersectionOf -> Bool
$c> :: DataIntersectionOf -> DataIntersectionOf -> Bool
<= :: DataIntersectionOf -> DataIntersectionOf -> Bool
$c<= :: DataIntersectionOf -> DataIntersectionOf -> Bool
< :: DataIntersectionOf -> DataIntersectionOf -> Bool
$c< :: DataIntersectionOf -> DataIntersectionOf -> Bool
compare :: DataIntersectionOf -> DataIntersectionOf -> Ordering
$ccompare :: DataIntersectionOf -> DataIntersectionOf -> Ordering
Ord, ReadPrec [DataIntersectionOf]
ReadPrec DataIntersectionOf
Int -> ReadS DataIntersectionOf
ReadS [DataIntersectionOf]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DataIntersectionOf]
$creadListPrec :: ReadPrec [DataIntersectionOf]
readPrec :: ReadPrec DataIntersectionOf
$creadPrec :: ReadPrec DataIntersectionOf
readList :: ReadS [DataIntersectionOf]
$creadList :: ReadS [DataIntersectionOf]
readsPrec :: Int -> ReadS DataIntersectionOf
$creadsPrec :: Int -> ReadS DataIntersectionOf
Read, Int -> DataIntersectionOf -> ShowS
[DataIntersectionOf] -> ShowS
DataIntersectionOf -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DataIntersectionOf] -> ShowS
$cshowList :: [DataIntersectionOf] -> ShowS
show :: DataIntersectionOf -> String
$cshow :: DataIntersectionOf -> String
showsPrec :: Int -> DataIntersectionOf -> ShowS
$cshowsPrec :: Int -> DataIntersectionOf -> ShowS
Show)

_DataIntersectionOf :: Name
_DataIntersectionOf = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.DataIntersectionOf")

-- | See https://www.w3.org/TR/owl2-syntax/#Union_of_Data_Ranges
newtype DataUnionOf = 
  DataUnionOf {
    -- | See https://www.w3.org/TR/owl2-syntax/#Union_of_Data_Ranges
    DataUnionOf -> [DataRange]
unDataUnionOf :: [DataRange]}
  deriving (DataUnionOf -> DataUnionOf -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DataUnionOf -> DataUnionOf -> Bool
$c/= :: DataUnionOf -> DataUnionOf -> Bool
== :: DataUnionOf -> DataUnionOf -> Bool
$c== :: DataUnionOf -> DataUnionOf -> Bool
Eq, Eq DataUnionOf
DataUnionOf -> DataUnionOf -> Bool
DataUnionOf -> DataUnionOf -> Ordering
DataUnionOf -> DataUnionOf -> DataUnionOf
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 :: DataUnionOf -> DataUnionOf -> DataUnionOf
$cmin :: DataUnionOf -> DataUnionOf -> DataUnionOf
max :: DataUnionOf -> DataUnionOf -> DataUnionOf
$cmax :: DataUnionOf -> DataUnionOf -> DataUnionOf
>= :: DataUnionOf -> DataUnionOf -> Bool
$c>= :: DataUnionOf -> DataUnionOf -> Bool
> :: DataUnionOf -> DataUnionOf -> Bool
$c> :: DataUnionOf -> DataUnionOf -> Bool
<= :: DataUnionOf -> DataUnionOf -> Bool
$c<= :: DataUnionOf -> DataUnionOf -> Bool
< :: DataUnionOf -> DataUnionOf -> Bool
$c< :: DataUnionOf -> DataUnionOf -> Bool
compare :: DataUnionOf -> DataUnionOf -> Ordering
$ccompare :: DataUnionOf -> DataUnionOf -> Ordering
Ord, ReadPrec [DataUnionOf]
ReadPrec DataUnionOf
Int -> ReadS DataUnionOf
ReadS [DataUnionOf]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DataUnionOf]
$creadListPrec :: ReadPrec [DataUnionOf]
readPrec :: ReadPrec DataUnionOf
$creadPrec :: ReadPrec DataUnionOf
readList :: ReadS [DataUnionOf]
$creadList :: ReadS [DataUnionOf]
readsPrec :: Int -> ReadS DataUnionOf
$creadsPrec :: Int -> ReadS DataUnionOf
Read, Int -> DataUnionOf -> ShowS
[DataUnionOf] -> ShowS
DataUnionOf -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DataUnionOf] -> ShowS
$cshowList :: [DataUnionOf] -> ShowS
show :: DataUnionOf -> String
$cshow :: DataUnionOf -> String
showsPrec :: Int -> DataUnionOf -> ShowS
$cshowsPrec :: Int -> DataUnionOf -> ShowS
Show)

_DataUnionOf :: Name
_DataUnionOf = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.DataUnionOf")

-- | See https://www.w3.org/TR/owl2-syntax/#Complement_of_Data_Ranges
newtype DataComplementOf = 
  DataComplementOf {
    -- | See https://www.w3.org/TR/owl2-syntax/#Complement_of_Data_Ranges
    DataComplementOf -> DataRange
unDataComplementOf :: DataRange}
  deriving (DataComplementOf -> DataComplementOf -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DataComplementOf -> DataComplementOf -> Bool
$c/= :: DataComplementOf -> DataComplementOf -> Bool
== :: DataComplementOf -> DataComplementOf -> Bool
$c== :: DataComplementOf -> DataComplementOf -> Bool
Eq, Eq DataComplementOf
DataComplementOf -> DataComplementOf -> Bool
DataComplementOf -> DataComplementOf -> Ordering
DataComplementOf -> DataComplementOf -> DataComplementOf
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 :: DataComplementOf -> DataComplementOf -> DataComplementOf
$cmin :: DataComplementOf -> DataComplementOf -> DataComplementOf
max :: DataComplementOf -> DataComplementOf -> DataComplementOf
$cmax :: DataComplementOf -> DataComplementOf -> DataComplementOf
>= :: DataComplementOf -> DataComplementOf -> Bool
$c>= :: DataComplementOf -> DataComplementOf -> Bool
> :: DataComplementOf -> DataComplementOf -> Bool
$c> :: DataComplementOf -> DataComplementOf -> Bool
<= :: DataComplementOf -> DataComplementOf -> Bool
$c<= :: DataComplementOf -> DataComplementOf -> Bool
< :: DataComplementOf -> DataComplementOf -> Bool
$c< :: DataComplementOf -> DataComplementOf -> Bool
compare :: DataComplementOf -> DataComplementOf -> Ordering
$ccompare :: DataComplementOf -> DataComplementOf -> Ordering
Ord, ReadPrec [DataComplementOf]
ReadPrec DataComplementOf
Int -> ReadS DataComplementOf
ReadS [DataComplementOf]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DataComplementOf]
$creadListPrec :: ReadPrec [DataComplementOf]
readPrec :: ReadPrec DataComplementOf
$creadPrec :: ReadPrec DataComplementOf
readList :: ReadS [DataComplementOf]
$creadList :: ReadS [DataComplementOf]
readsPrec :: Int -> ReadS DataComplementOf
$creadsPrec :: Int -> ReadS DataComplementOf
Read, Int -> DataComplementOf -> ShowS
[DataComplementOf] -> ShowS
DataComplementOf -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DataComplementOf] -> ShowS
$cshowList :: [DataComplementOf] -> ShowS
show :: DataComplementOf -> String
$cshow :: DataComplementOf -> String
showsPrec :: Int -> DataComplementOf -> ShowS
$cshowsPrec :: Int -> DataComplementOf -> ShowS
Show)

_DataComplementOf :: Name
_DataComplementOf = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.DataComplementOf")

-- | See https://www.w3.org/TR/owl2-syntax/#Enumeration_of_Literals
newtype DataOneOf = 
  DataOneOf {
    -- | See https://www.w3.org/TR/owl2-syntax/#Enumeration_of_Literals
    DataOneOf -> [Literal]
unDataOneOf :: [Syntax.Literal]}
  deriving (DataOneOf -> DataOneOf -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DataOneOf -> DataOneOf -> Bool
$c/= :: DataOneOf -> DataOneOf -> Bool
== :: DataOneOf -> DataOneOf -> Bool
$c== :: DataOneOf -> DataOneOf -> Bool
Eq, Eq DataOneOf
DataOneOf -> DataOneOf -> Bool
DataOneOf -> DataOneOf -> Ordering
DataOneOf -> DataOneOf -> DataOneOf
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 :: DataOneOf -> DataOneOf -> DataOneOf
$cmin :: DataOneOf -> DataOneOf -> DataOneOf
max :: DataOneOf -> DataOneOf -> DataOneOf
$cmax :: DataOneOf -> DataOneOf -> DataOneOf
>= :: DataOneOf -> DataOneOf -> Bool
$c>= :: DataOneOf -> DataOneOf -> Bool
> :: DataOneOf -> DataOneOf -> Bool
$c> :: DataOneOf -> DataOneOf -> Bool
<= :: DataOneOf -> DataOneOf -> Bool
$c<= :: DataOneOf -> DataOneOf -> Bool
< :: DataOneOf -> DataOneOf -> Bool
$c< :: DataOneOf -> DataOneOf -> Bool
compare :: DataOneOf -> DataOneOf -> Ordering
$ccompare :: DataOneOf -> DataOneOf -> Ordering
Ord, ReadPrec [DataOneOf]
ReadPrec DataOneOf
Int -> ReadS DataOneOf
ReadS [DataOneOf]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DataOneOf]
$creadListPrec :: ReadPrec [DataOneOf]
readPrec :: ReadPrec DataOneOf
$creadPrec :: ReadPrec DataOneOf
readList :: ReadS [DataOneOf]
$creadList :: ReadS [DataOneOf]
readsPrec :: Int -> ReadS DataOneOf
$creadsPrec :: Int -> ReadS DataOneOf
Read, Int -> DataOneOf -> ShowS
[DataOneOf] -> ShowS
DataOneOf -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DataOneOf] -> ShowS
$cshowList :: [DataOneOf] -> ShowS
show :: DataOneOf -> String
$cshow :: DataOneOf -> String
showsPrec :: Int -> DataOneOf -> ShowS
$cshowsPrec :: Int -> DataOneOf -> ShowS
Show)

_DataOneOf :: Name
_DataOneOf = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.DataOneOf")

-- | See https://www.w3.org/TR/owl2-syntax/#Datatype_Restrictions
data DatatypeRestriction = 
  DatatypeRestriction {
    DatatypeRestriction -> Datatype
datatypeRestrictionDatatype :: Datatype,
    DatatypeRestriction -> [DatatypeRestriction_Constraint]
datatypeRestrictionConstraints :: [DatatypeRestriction_Constraint]}
  deriving (DatatypeRestriction -> DatatypeRestriction -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DatatypeRestriction -> DatatypeRestriction -> Bool
$c/= :: DatatypeRestriction -> DatatypeRestriction -> Bool
== :: DatatypeRestriction -> DatatypeRestriction -> Bool
$c== :: DatatypeRestriction -> DatatypeRestriction -> Bool
Eq, Eq DatatypeRestriction
DatatypeRestriction -> DatatypeRestriction -> Bool
DatatypeRestriction -> DatatypeRestriction -> Ordering
DatatypeRestriction -> DatatypeRestriction -> DatatypeRestriction
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 :: DatatypeRestriction -> DatatypeRestriction -> DatatypeRestriction
$cmin :: DatatypeRestriction -> DatatypeRestriction -> DatatypeRestriction
max :: DatatypeRestriction -> DatatypeRestriction -> DatatypeRestriction
$cmax :: DatatypeRestriction -> DatatypeRestriction -> DatatypeRestriction
>= :: DatatypeRestriction -> DatatypeRestriction -> Bool
$c>= :: DatatypeRestriction -> DatatypeRestriction -> Bool
> :: DatatypeRestriction -> DatatypeRestriction -> Bool
$c> :: DatatypeRestriction -> DatatypeRestriction -> Bool
<= :: DatatypeRestriction -> DatatypeRestriction -> Bool
$c<= :: DatatypeRestriction -> DatatypeRestriction -> Bool
< :: DatatypeRestriction -> DatatypeRestriction -> Bool
$c< :: DatatypeRestriction -> DatatypeRestriction -> Bool
compare :: DatatypeRestriction -> DatatypeRestriction -> Ordering
$ccompare :: DatatypeRestriction -> DatatypeRestriction -> Ordering
Ord, ReadPrec [DatatypeRestriction]
ReadPrec DatatypeRestriction
Int -> ReadS DatatypeRestriction
ReadS [DatatypeRestriction]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DatatypeRestriction]
$creadListPrec :: ReadPrec [DatatypeRestriction]
readPrec :: ReadPrec DatatypeRestriction
$creadPrec :: ReadPrec DatatypeRestriction
readList :: ReadS [DatatypeRestriction]
$creadList :: ReadS [DatatypeRestriction]
readsPrec :: Int -> ReadS DatatypeRestriction
$creadsPrec :: Int -> ReadS DatatypeRestriction
Read, Int -> DatatypeRestriction -> ShowS
[DatatypeRestriction] -> ShowS
DatatypeRestriction -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DatatypeRestriction] -> ShowS
$cshowList :: [DatatypeRestriction] -> ShowS
show :: DatatypeRestriction -> String
$cshow :: DatatypeRestriction -> String
showsPrec :: Int -> DatatypeRestriction -> ShowS
$cshowsPrec :: Int -> DatatypeRestriction -> ShowS
Show)

_DatatypeRestriction :: Name
_DatatypeRestriction = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.DatatypeRestriction")

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

_DatatypeRestriction_constraints :: FieldName
_DatatypeRestriction_constraints = (String -> FieldName
Core.FieldName String
"constraints")

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

_DatatypeRestriction_Constraint :: Name
_DatatypeRestriction_Constraint = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.DatatypeRestriction.Constraint")

_DatatypeRestriction_Constraint_constrainingFacet :: FieldName
_DatatypeRestriction_Constraint_constrainingFacet = (String -> FieldName
Core.FieldName String
"constrainingFacet")

_DatatypeRestriction_Constraint_restrictionValue :: FieldName
_DatatypeRestriction_Constraint_restrictionValue = (String -> FieldName
Core.FieldName String
"restrictionValue")

data DatatypeRestriction_ConstrainingFacet = 
  -- | Note: XML Schema constraining facets are treated as a special case in this model (not in the OWL 2 specification itself) because they are particularly common
  DatatypeRestriction_ConstrainingFacetXmlSchema Schema.ConstrainingFacet |
  DatatypeRestriction_ConstrainingFacetOther Syntax.Iri
  deriving (DatatypeRestriction_ConstrainingFacet
-> DatatypeRestriction_ConstrainingFacet -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DatatypeRestriction_ConstrainingFacet
-> DatatypeRestriction_ConstrainingFacet -> Bool
$c/= :: DatatypeRestriction_ConstrainingFacet
-> DatatypeRestriction_ConstrainingFacet -> Bool
== :: DatatypeRestriction_ConstrainingFacet
-> DatatypeRestriction_ConstrainingFacet -> Bool
$c== :: DatatypeRestriction_ConstrainingFacet
-> DatatypeRestriction_ConstrainingFacet -> Bool
Eq, Eq DatatypeRestriction_ConstrainingFacet
DatatypeRestriction_ConstrainingFacet
-> DatatypeRestriction_ConstrainingFacet -> Bool
DatatypeRestriction_ConstrainingFacet
-> DatatypeRestriction_ConstrainingFacet -> Ordering
DatatypeRestriction_ConstrainingFacet
-> DatatypeRestriction_ConstrainingFacet
-> DatatypeRestriction_ConstrainingFacet
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: DatatypeRestriction_ConstrainingFacet
-> DatatypeRestriction_ConstrainingFacet
-> DatatypeRestriction_ConstrainingFacet
$cmin :: DatatypeRestriction_ConstrainingFacet
-> DatatypeRestriction_ConstrainingFacet
-> DatatypeRestriction_ConstrainingFacet
max :: DatatypeRestriction_ConstrainingFacet
-> DatatypeRestriction_ConstrainingFacet
-> DatatypeRestriction_ConstrainingFacet
$cmax :: DatatypeRestriction_ConstrainingFacet
-> DatatypeRestriction_ConstrainingFacet
-> DatatypeRestriction_ConstrainingFacet
>= :: DatatypeRestriction_ConstrainingFacet
-> DatatypeRestriction_ConstrainingFacet -> Bool
$c>= :: DatatypeRestriction_ConstrainingFacet
-> DatatypeRestriction_ConstrainingFacet -> Bool
> :: DatatypeRestriction_ConstrainingFacet
-> DatatypeRestriction_ConstrainingFacet -> Bool
$c> :: DatatypeRestriction_ConstrainingFacet
-> DatatypeRestriction_ConstrainingFacet -> Bool
<= :: DatatypeRestriction_ConstrainingFacet
-> DatatypeRestriction_ConstrainingFacet -> Bool
$c<= :: DatatypeRestriction_ConstrainingFacet
-> DatatypeRestriction_ConstrainingFacet -> Bool
< :: DatatypeRestriction_ConstrainingFacet
-> DatatypeRestriction_ConstrainingFacet -> Bool
$c< :: DatatypeRestriction_ConstrainingFacet
-> DatatypeRestriction_ConstrainingFacet -> Bool
compare :: DatatypeRestriction_ConstrainingFacet
-> DatatypeRestriction_ConstrainingFacet -> Ordering
$ccompare :: DatatypeRestriction_ConstrainingFacet
-> DatatypeRestriction_ConstrainingFacet -> Ordering
Ord, ReadPrec [DatatypeRestriction_ConstrainingFacet]
ReadPrec DatatypeRestriction_ConstrainingFacet
Int -> ReadS DatatypeRestriction_ConstrainingFacet
ReadS [DatatypeRestriction_ConstrainingFacet]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DatatypeRestriction_ConstrainingFacet]
$creadListPrec :: ReadPrec [DatatypeRestriction_ConstrainingFacet]
readPrec :: ReadPrec DatatypeRestriction_ConstrainingFacet
$creadPrec :: ReadPrec DatatypeRestriction_ConstrainingFacet
readList :: ReadS [DatatypeRestriction_ConstrainingFacet]
$creadList :: ReadS [DatatypeRestriction_ConstrainingFacet]
readsPrec :: Int -> ReadS DatatypeRestriction_ConstrainingFacet
$creadsPrec :: Int -> ReadS DatatypeRestriction_ConstrainingFacet
Read, Int -> DatatypeRestriction_ConstrainingFacet -> ShowS
[DatatypeRestriction_ConstrainingFacet] -> ShowS
DatatypeRestriction_ConstrainingFacet -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DatatypeRestriction_ConstrainingFacet] -> ShowS
$cshowList :: [DatatypeRestriction_ConstrainingFacet] -> ShowS
show :: DatatypeRestriction_ConstrainingFacet -> String
$cshow :: DatatypeRestriction_ConstrainingFacet -> String
showsPrec :: Int -> DatatypeRestriction_ConstrainingFacet -> ShowS
$cshowsPrec :: Int -> DatatypeRestriction_ConstrainingFacet -> ShowS
Show)

_DatatypeRestriction_ConstrainingFacet :: Name
_DatatypeRestriction_ConstrainingFacet = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.DatatypeRestriction.ConstrainingFacet")

_DatatypeRestriction_ConstrainingFacet_xmlSchema :: FieldName
_DatatypeRestriction_ConstrainingFacet_xmlSchema = (String -> FieldName
Core.FieldName String
"xmlSchema")

_DatatypeRestriction_ConstrainingFacet_other :: FieldName
_DatatypeRestriction_ConstrainingFacet_other = (String -> FieldName
Core.FieldName String
"other")

data ClassExpression = 
  ClassExpressionClass Class |
  ClassExpressionDataSomeValuesFrom DataSomeValuesFrom |
  ClassExpressionDataAllValuesFrom DataAllValuesFrom |
  ClassExpressionDataHasValue DataHasValue |
  ClassExpressionDataMinCardinality DataMinCardinality |
  ClassExpressionDataMaxCardinality DataMaxCardinality |
  ClassExpressionDataExactCardinality DataExactCardinality |
  ClassExpressionObjectAllValuesFrom ObjectAllValuesFrom |
  ClassExpressionObjectExactCardinality ObjectExactCardinality |
  ClassExpressionObjectHasSelf ObjectHasSelf |
  ClassExpressionObjectHasValue ObjectHasValue |
  ClassExpressionObjectIntersectionOf ObjectIntersectionOf |
  ClassExpressionObjectMaxCardinality ObjectMaxCardinality |
  ClassExpressionObjectMinCardinality ObjectMinCardinality |
  ClassExpressionObjectOneOf ObjectOneOf |
  ClassExpressionObjectSomeValuesFrom ObjectSomeValuesFrom |
  ClassExpressionObjectUnionOf ObjectUnionOf
  deriving (ClassExpression -> ClassExpression -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ClassExpression -> ClassExpression -> Bool
$c/= :: ClassExpression -> ClassExpression -> Bool
== :: ClassExpression -> ClassExpression -> Bool
$c== :: ClassExpression -> ClassExpression -> Bool
Eq, Eq ClassExpression
ClassExpression -> ClassExpression -> Bool
ClassExpression -> ClassExpression -> Ordering
ClassExpression -> ClassExpression -> ClassExpression
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 :: ClassExpression -> ClassExpression -> ClassExpression
$cmin :: ClassExpression -> ClassExpression -> ClassExpression
max :: ClassExpression -> ClassExpression -> ClassExpression
$cmax :: ClassExpression -> ClassExpression -> ClassExpression
>= :: ClassExpression -> ClassExpression -> Bool
$c>= :: ClassExpression -> ClassExpression -> Bool
> :: ClassExpression -> ClassExpression -> Bool
$c> :: ClassExpression -> ClassExpression -> Bool
<= :: ClassExpression -> ClassExpression -> Bool
$c<= :: ClassExpression -> ClassExpression -> Bool
< :: ClassExpression -> ClassExpression -> Bool
$c< :: ClassExpression -> ClassExpression -> Bool
compare :: ClassExpression -> ClassExpression -> Ordering
$ccompare :: ClassExpression -> ClassExpression -> Ordering
Ord, ReadPrec [ClassExpression]
ReadPrec ClassExpression
Int -> ReadS ClassExpression
ReadS [ClassExpression]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ClassExpression]
$creadListPrec :: ReadPrec [ClassExpression]
readPrec :: ReadPrec ClassExpression
$creadPrec :: ReadPrec ClassExpression
readList :: ReadS [ClassExpression]
$creadList :: ReadS [ClassExpression]
readsPrec :: Int -> ReadS ClassExpression
$creadsPrec :: Int -> ReadS ClassExpression
Read, Int -> ClassExpression -> ShowS
[ClassExpression] -> ShowS
ClassExpression -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ClassExpression] -> ShowS
$cshowList :: [ClassExpression] -> ShowS
show :: ClassExpression -> String
$cshow :: ClassExpression -> String
showsPrec :: Int -> ClassExpression -> ShowS
$cshowsPrec :: Int -> ClassExpression -> ShowS
Show)

_ClassExpression :: Name
_ClassExpression = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.ClassExpression")

_ClassExpression_class :: FieldName
_ClassExpression_class = (String -> FieldName
Core.FieldName String
"class")

_ClassExpression_dataSomeValuesFrom :: FieldName
_ClassExpression_dataSomeValuesFrom = (String -> FieldName
Core.FieldName String
"dataSomeValuesFrom")

_ClassExpression_dataAllValuesFrom :: FieldName
_ClassExpression_dataAllValuesFrom = (String -> FieldName
Core.FieldName String
"dataAllValuesFrom")

_ClassExpression_dataHasValue :: FieldName
_ClassExpression_dataHasValue = (String -> FieldName
Core.FieldName String
"dataHasValue")

_ClassExpression_dataMinCardinality :: FieldName
_ClassExpression_dataMinCardinality = (String -> FieldName
Core.FieldName String
"dataMinCardinality")

_ClassExpression_dataMaxCardinality :: FieldName
_ClassExpression_dataMaxCardinality = (String -> FieldName
Core.FieldName String
"dataMaxCardinality")

_ClassExpression_dataExactCardinality :: FieldName
_ClassExpression_dataExactCardinality = (String -> FieldName
Core.FieldName String
"dataExactCardinality")

_ClassExpression_objectAllValuesFrom :: FieldName
_ClassExpression_objectAllValuesFrom = (String -> FieldName
Core.FieldName String
"objectAllValuesFrom")

_ClassExpression_objectExactCardinality :: FieldName
_ClassExpression_objectExactCardinality = (String -> FieldName
Core.FieldName String
"objectExactCardinality")

_ClassExpression_objectHasSelf :: FieldName
_ClassExpression_objectHasSelf = (String -> FieldName
Core.FieldName String
"objectHasSelf")

_ClassExpression_objectHasValue :: FieldName
_ClassExpression_objectHasValue = (String -> FieldName
Core.FieldName String
"objectHasValue")

_ClassExpression_objectIntersectionOf :: FieldName
_ClassExpression_objectIntersectionOf = (String -> FieldName
Core.FieldName String
"objectIntersectionOf")

_ClassExpression_objectMaxCardinality :: FieldName
_ClassExpression_objectMaxCardinality = (String -> FieldName
Core.FieldName String
"objectMaxCardinality")

_ClassExpression_objectMinCardinality :: FieldName
_ClassExpression_objectMinCardinality = (String -> FieldName
Core.FieldName String
"objectMinCardinality")

_ClassExpression_objectOneOf :: FieldName
_ClassExpression_objectOneOf = (String -> FieldName
Core.FieldName String
"objectOneOf")

_ClassExpression_objectSomeValuesFrom :: FieldName
_ClassExpression_objectSomeValuesFrom = (String -> FieldName
Core.FieldName String
"objectSomeValuesFrom")

_ClassExpression_objectUnionOf :: FieldName
_ClassExpression_objectUnionOf = (String -> FieldName
Core.FieldName String
"objectUnionOf")

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

_ObjectIntersectionOf :: Name
_ObjectIntersectionOf = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.ObjectIntersectionOf")

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

_ObjectUnionOf :: Name
_ObjectUnionOf = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.ObjectUnionOf")

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

_ObjectComplementOf :: Name
_ObjectComplementOf = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.ObjectComplementOf")

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

_ObjectOneOf :: Name
_ObjectOneOf = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.ObjectOneOf")

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

_ObjectSomeValuesFrom :: Name
_ObjectSomeValuesFrom = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.ObjectSomeValuesFrom")

_ObjectSomeValuesFrom_property :: FieldName
_ObjectSomeValuesFrom_property = (String -> FieldName
Core.FieldName String
"property")

_ObjectSomeValuesFrom_class :: FieldName
_ObjectSomeValuesFrom_class = (String -> FieldName
Core.FieldName String
"class")

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

_ObjectAllValuesFrom :: Name
_ObjectAllValuesFrom = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.ObjectAllValuesFrom")

_ObjectAllValuesFrom_property :: FieldName
_ObjectAllValuesFrom_property = (String -> FieldName
Core.FieldName String
"property")

_ObjectAllValuesFrom_class :: FieldName
_ObjectAllValuesFrom_class = (String -> FieldName
Core.FieldName String
"class")

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

_ObjectHasValue :: Name
_ObjectHasValue = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.ObjectHasValue")

_ObjectHasValue_property :: FieldName
_ObjectHasValue_property = (String -> FieldName
Core.FieldName String
"property")

_ObjectHasValue_individual :: FieldName
_ObjectHasValue_individual = (String -> FieldName
Core.FieldName String
"individual")

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

_ObjectHasSelf :: Name
_ObjectHasSelf = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.ObjectHasSelf")

-- | See https://www.w3.org/TR/owl2-syntax/#Minimum_Cardinality
data ObjectMinCardinality = 
  ObjectMinCardinality {
    ObjectMinCardinality -> Integer
objectMinCardinalityBound :: Integer,
    ObjectMinCardinality -> ObjectPropertyExpression
objectMinCardinalityProperty :: ObjectPropertyExpression,
    ObjectMinCardinality -> [ClassExpression]
objectMinCardinalityClass :: [ClassExpression]}
  deriving (ObjectMinCardinality -> ObjectMinCardinality -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ObjectMinCardinality -> ObjectMinCardinality -> Bool
$c/= :: ObjectMinCardinality -> ObjectMinCardinality -> Bool
== :: ObjectMinCardinality -> ObjectMinCardinality -> Bool
$c== :: ObjectMinCardinality -> ObjectMinCardinality -> Bool
Eq, Eq ObjectMinCardinality
ObjectMinCardinality -> ObjectMinCardinality -> Bool
ObjectMinCardinality -> ObjectMinCardinality -> Ordering
ObjectMinCardinality
-> ObjectMinCardinality -> ObjectMinCardinality
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 :: ObjectMinCardinality
-> ObjectMinCardinality -> ObjectMinCardinality
$cmin :: ObjectMinCardinality
-> ObjectMinCardinality -> ObjectMinCardinality
max :: ObjectMinCardinality
-> ObjectMinCardinality -> ObjectMinCardinality
$cmax :: ObjectMinCardinality
-> ObjectMinCardinality -> ObjectMinCardinality
>= :: ObjectMinCardinality -> ObjectMinCardinality -> Bool
$c>= :: ObjectMinCardinality -> ObjectMinCardinality -> Bool
> :: ObjectMinCardinality -> ObjectMinCardinality -> Bool
$c> :: ObjectMinCardinality -> ObjectMinCardinality -> Bool
<= :: ObjectMinCardinality -> ObjectMinCardinality -> Bool
$c<= :: ObjectMinCardinality -> ObjectMinCardinality -> Bool
< :: ObjectMinCardinality -> ObjectMinCardinality -> Bool
$c< :: ObjectMinCardinality -> ObjectMinCardinality -> Bool
compare :: ObjectMinCardinality -> ObjectMinCardinality -> Ordering
$ccompare :: ObjectMinCardinality -> ObjectMinCardinality -> Ordering
Ord, ReadPrec [ObjectMinCardinality]
ReadPrec ObjectMinCardinality
Int -> ReadS ObjectMinCardinality
ReadS [ObjectMinCardinality]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ObjectMinCardinality]
$creadListPrec :: ReadPrec [ObjectMinCardinality]
readPrec :: ReadPrec ObjectMinCardinality
$creadPrec :: ReadPrec ObjectMinCardinality
readList :: ReadS [ObjectMinCardinality]
$creadList :: ReadS [ObjectMinCardinality]
readsPrec :: Int -> ReadS ObjectMinCardinality
$creadsPrec :: Int -> ReadS ObjectMinCardinality
Read, Int -> ObjectMinCardinality -> ShowS
[ObjectMinCardinality] -> ShowS
ObjectMinCardinality -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ObjectMinCardinality] -> ShowS
$cshowList :: [ObjectMinCardinality] -> ShowS
show :: ObjectMinCardinality -> String
$cshow :: ObjectMinCardinality -> String
showsPrec :: Int -> ObjectMinCardinality -> ShowS
$cshowsPrec :: Int -> ObjectMinCardinality -> ShowS
Show)

_ObjectMinCardinality :: Name
_ObjectMinCardinality = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.ObjectMinCardinality")

_ObjectMinCardinality_bound :: FieldName
_ObjectMinCardinality_bound = (String -> FieldName
Core.FieldName String
"bound")

_ObjectMinCardinality_property :: FieldName
_ObjectMinCardinality_property = (String -> FieldName
Core.FieldName String
"property")

_ObjectMinCardinality_class :: FieldName
_ObjectMinCardinality_class = (String -> FieldName
Core.FieldName String
"class")

-- | See https://www.w3.org/TR/owl2-syntax/#Maximum_Cardinality
data ObjectMaxCardinality = 
  ObjectMaxCardinality {
    ObjectMaxCardinality -> Integer
objectMaxCardinalityBound :: Integer,
    ObjectMaxCardinality -> ObjectPropertyExpression
objectMaxCardinalityProperty :: ObjectPropertyExpression,
    ObjectMaxCardinality -> [ClassExpression]
objectMaxCardinalityClass :: [ClassExpression]}
  deriving (ObjectMaxCardinality -> ObjectMaxCardinality -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ObjectMaxCardinality -> ObjectMaxCardinality -> Bool
$c/= :: ObjectMaxCardinality -> ObjectMaxCardinality -> Bool
== :: ObjectMaxCardinality -> ObjectMaxCardinality -> Bool
$c== :: ObjectMaxCardinality -> ObjectMaxCardinality -> Bool
Eq, Eq ObjectMaxCardinality
ObjectMaxCardinality -> ObjectMaxCardinality -> Bool
ObjectMaxCardinality -> ObjectMaxCardinality -> Ordering
ObjectMaxCardinality
-> ObjectMaxCardinality -> ObjectMaxCardinality
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 :: ObjectMaxCardinality
-> ObjectMaxCardinality -> ObjectMaxCardinality
$cmin :: ObjectMaxCardinality
-> ObjectMaxCardinality -> ObjectMaxCardinality
max :: ObjectMaxCardinality
-> ObjectMaxCardinality -> ObjectMaxCardinality
$cmax :: ObjectMaxCardinality
-> ObjectMaxCardinality -> ObjectMaxCardinality
>= :: ObjectMaxCardinality -> ObjectMaxCardinality -> Bool
$c>= :: ObjectMaxCardinality -> ObjectMaxCardinality -> Bool
> :: ObjectMaxCardinality -> ObjectMaxCardinality -> Bool
$c> :: ObjectMaxCardinality -> ObjectMaxCardinality -> Bool
<= :: ObjectMaxCardinality -> ObjectMaxCardinality -> Bool
$c<= :: ObjectMaxCardinality -> ObjectMaxCardinality -> Bool
< :: ObjectMaxCardinality -> ObjectMaxCardinality -> Bool
$c< :: ObjectMaxCardinality -> ObjectMaxCardinality -> Bool
compare :: ObjectMaxCardinality -> ObjectMaxCardinality -> Ordering
$ccompare :: ObjectMaxCardinality -> ObjectMaxCardinality -> Ordering
Ord, ReadPrec [ObjectMaxCardinality]
ReadPrec ObjectMaxCardinality
Int -> ReadS ObjectMaxCardinality
ReadS [ObjectMaxCardinality]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ObjectMaxCardinality]
$creadListPrec :: ReadPrec [ObjectMaxCardinality]
readPrec :: ReadPrec ObjectMaxCardinality
$creadPrec :: ReadPrec ObjectMaxCardinality
readList :: ReadS [ObjectMaxCardinality]
$creadList :: ReadS [ObjectMaxCardinality]
readsPrec :: Int -> ReadS ObjectMaxCardinality
$creadsPrec :: Int -> ReadS ObjectMaxCardinality
Read, Int -> ObjectMaxCardinality -> ShowS
[ObjectMaxCardinality] -> ShowS
ObjectMaxCardinality -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ObjectMaxCardinality] -> ShowS
$cshowList :: [ObjectMaxCardinality] -> ShowS
show :: ObjectMaxCardinality -> String
$cshow :: ObjectMaxCardinality -> String
showsPrec :: Int -> ObjectMaxCardinality -> ShowS
$cshowsPrec :: Int -> ObjectMaxCardinality -> ShowS
Show)

_ObjectMaxCardinality :: Name
_ObjectMaxCardinality = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.ObjectMaxCardinality")

_ObjectMaxCardinality_bound :: FieldName
_ObjectMaxCardinality_bound = (String -> FieldName
Core.FieldName String
"bound")

_ObjectMaxCardinality_property :: FieldName
_ObjectMaxCardinality_property = (String -> FieldName
Core.FieldName String
"property")

_ObjectMaxCardinality_class :: FieldName
_ObjectMaxCardinality_class = (String -> FieldName
Core.FieldName String
"class")

-- | See https://www.w3.org/TR/owl2-syntax/#Exact_Cardinality
data ObjectExactCardinality = 
  ObjectExactCardinality {
    ObjectExactCardinality -> Integer
objectExactCardinalityBound :: Integer,
    ObjectExactCardinality -> ObjectPropertyExpression
objectExactCardinalityProperty :: ObjectPropertyExpression,
    ObjectExactCardinality -> [ClassExpression]
objectExactCardinalityClass :: [ClassExpression]}
  deriving (ObjectExactCardinality -> ObjectExactCardinality -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ObjectExactCardinality -> ObjectExactCardinality -> Bool
$c/= :: ObjectExactCardinality -> ObjectExactCardinality -> Bool
== :: ObjectExactCardinality -> ObjectExactCardinality -> Bool
$c== :: ObjectExactCardinality -> ObjectExactCardinality -> Bool
Eq, Eq ObjectExactCardinality
ObjectExactCardinality -> ObjectExactCardinality -> Bool
ObjectExactCardinality -> ObjectExactCardinality -> Ordering
ObjectExactCardinality
-> ObjectExactCardinality -> ObjectExactCardinality
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 :: ObjectExactCardinality
-> ObjectExactCardinality -> ObjectExactCardinality
$cmin :: ObjectExactCardinality
-> ObjectExactCardinality -> ObjectExactCardinality
max :: ObjectExactCardinality
-> ObjectExactCardinality -> ObjectExactCardinality
$cmax :: ObjectExactCardinality
-> ObjectExactCardinality -> ObjectExactCardinality
>= :: ObjectExactCardinality -> ObjectExactCardinality -> Bool
$c>= :: ObjectExactCardinality -> ObjectExactCardinality -> Bool
> :: ObjectExactCardinality -> ObjectExactCardinality -> Bool
$c> :: ObjectExactCardinality -> ObjectExactCardinality -> Bool
<= :: ObjectExactCardinality -> ObjectExactCardinality -> Bool
$c<= :: ObjectExactCardinality -> ObjectExactCardinality -> Bool
< :: ObjectExactCardinality -> ObjectExactCardinality -> Bool
$c< :: ObjectExactCardinality -> ObjectExactCardinality -> Bool
compare :: ObjectExactCardinality -> ObjectExactCardinality -> Ordering
$ccompare :: ObjectExactCardinality -> ObjectExactCardinality -> Ordering
Ord, ReadPrec [ObjectExactCardinality]
ReadPrec ObjectExactCardinality
Int -> ReadS ObjectExactCardinality
ReadS [ObjectExactCardinality]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ObjectExactCardinality]
$creadListPrec :: ReadPrec [ObjectExactCardinality]
readPrec :: ReadPrec ObjectExactCardinality
$creadPrec :: ReadPrec ObjectExactCardinality
readList :: ReadS [ObjectExactCardinality]
$creadList :: ReadS [ObjectExactCardinality]
readsPrec :: Int -> ReadS ObjectExactCardinality
$creadsPrec :: Int -> ReadS ObjectExactCardinality
Read, Int -> ObjectExactCardinality -> ShowS
[ObjectExactCardinality] -> ShowS
ObjectExactCardinality -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ObjectExactCardinality] -> ShowS
$cshowList :: [ObjectExactCardinality] -> ShowS
show :: ObjectExactCardinality -> String
$cshow :: ObjectExactCardinality -> String
showsPrec :: Int -> ObjectExactCardinality -> ShowS
$cshowsPrec :: Int -> ObjectExactCardinality -> ShowS
Show)

_ObjectExactCardinality :: Name
_ObjectExactCardinality = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.ObjectExactCardinality")

_ObjectExactCardinality_bound :: FieldName
_ObjectExactCardinality_bound = (String -> FieldName
Core.FieldName String
"bound")

_ObjectExactCardinality_property :: FieldName
_ObjectExactCardinality_property = (String -> FieldName
Core.FieldName String
"property")

_ObjectExactCardinality_class :: FieldName
_ObjectExactCardinality_class = (String -> FieldName
Core.FieldName String
"class")

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

_DataSomeValuesFrom :: Name
_DataSomeValuesFrom = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.DataSomeValuesFrom")

_DataSomeValuesFrom_property :: FieldName
_DataSomeValuesFrom_property = (String -> FieldName
Core.FieldName String
"property")

_DataSomeValuesFrom_range :: FieldName
_DataSomeValuesFrom_range = (String -> FieldName
Core.FieldName String
"range")

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

_DataAllValuesFrom :: Name
_DataAllValuesFrom = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.DataAllValuesFrom")

_DataAllValuesFrom_property :: FieldName
_DataAllValuesFrom_property = (String -> FieldName
Core.FieldName String
"property")

_DataAllValuesFrom_range :: FieldName
_DataAllValuesFrom_range = (String -> FieldName
Core.FieldName String
"range")

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

_DataHasValue :: Name
_DataHasValue = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.DataHasValue")

_DataHasValue_property :: FieldName
_DataHasValue_property = (String -> FieldName
Core.FieldName String
"property")

_DataHasValue_value :: FieldName
_DataHasValue_value = (String -> FieldName
Core.FieldName String
"value")

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

_DataMinCardinality :: Name
_DataMinCardinality = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.DataMinCardinality")

_DataMinCardinality_bound :: FieldName
_DataMinCardinality_bound = (String -> FieldName
Core.FieldName String
"bound")

_DataMinCardinality_property :: FieldName
_DataMinCardinality_property = (String -> FieldName
Core.FieldName String
"property")

_DataMinCardinality_range :: FieldName
_DataMinCardinality_range = (String -> FieldName
Core.FieldName String
"range")

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

_DataMaxCardinality :: Name
_DataMaxCardinality = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.DataMaxCardinality")

_DataMaxCardinality_bound :: FieldName
_DataMaxCardinality_bound = (String -> FieldName
Core.FieldName String
"bound")

_DataMaxCardinality_property :: FieldName
_DataMaxCardinality_property = (String -> FieldName
Core.FieldName String
"property")

_DataMaxCardinality_range :: FieldName
_DataMaxCardinality_range = (String -> FieldName
Core.FieldName String
"range")

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

_DataExactCardinality :: Name
_DataExactCardinality = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.DataExactCardinality")

_DataExactCardinality_bound :: FieldName
_DataExactCardinality_bound = (String -> FieldName
Core.FieldName String
"bound")

_DataExactCardinality_property :: FieldName
_DataExactCardinality_property = (String -> FieldName
Core.FieldName String
"property")

_DataExactCardinality_range :: FieldName
_DataExactCardinality_range = (String -> FieldName
Core.FieldName String
"range")

-- | See https://www.w3.org/TR/owl2-syntax/#Axioms
data Axiom = 
  AxiomAnnotationAxiom AnnotationAxiom |
  AxiomAssertion Assertion |
  AxiomClassAxiom ClassAxiom |
  AxiomDataPropertyAxiom DataPropertyAxiom |
  AxiomDatatypeDefinition DatatypeDefinition |
  AxiomDeclaration Declaration |
  AxiomHasKey HasKey |
  AxiomObjectPropertyAxiom ObjectPropertyAxiom
  deriving (Axiom -> Axiom -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Axiom -> Axiom -> Bool
$c/= :: Axiom -> Axiom -> Bool
== :: Axiom -> Axiom -> Bool
$c== :: Axiom -> Axiom -> Bool
Eq, Eq Axiom
Axiom -> Axiom -> Bool
Axiom -> Axiom -> Ordering
Axiom -> Axiom -> Axiom
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 :: Axiom -> Axiom -> Axiom
$cmin :: Axiom -> Axiom -> Axiom
max :: Axiom -> Axiom -> Axiom
$cmax :: Axiom -> Axiom -> Axiom
>= :: Axiom -> Axiom -> Bool
$c>= :: Axiom -> Axiom -> Bool
> :: Axiom -> Axiom -> Bool
$c> :: Axiom -> Axiom -> Bool
<= :: Axiom -> Axiom -> Bool
$c<= :: Axiom -> Axiom -> Bool
< :: Axiom -> Axiom -> Bool
$c< :: Axiom -> Axiom -> Bool
compare :: Axiom -> Axiom -> Ordering
$ccompare :: Axiom -> Axiom -> Ordering
Ord, ReadPrec [Axiom]
ReadPrec Axiom
Int -> ReadS Axiom
ReadS [Axiom]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Axiom]
$creadListPrec :: ReadPrec [Axiom]
readPrec :: ReadPrec Axiom
$creadPrec :: ReadPrec Axiom
readList :: ReadS [Axiom]
$creadList :: ReadS [Axiom]
readsPrec :: Int -> ReadS Axiom
$creadsPrec :: Int -> ReadS Axiom
Read, Int -> Axiom -> ShowS
[Axiom] -> ShowS
Axiom -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Axiom] -> ShowS
$cshowList :: [Axiom] -> ShowS
show :: Axiom -> String
$cshow :: Axiom -> String
showsPrec :: Int -> Axiom -> ShowS
$cshowsPrec :: Int -> Axiom -> ShowS
Show)

_Axiom :: Name
_Axiom = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.Axiom")

_Axiom_annotationAxiom :: FieldName
_Axiom_annotationAxiom = (String -> FieldName
Core.FieldName String
"annotationAxiom")

_Axiom_assertion :: FieldName
_Axiom_assertion = (String -> FieldName
Core.FieldName String
"assertion")

_Axiom_classAxiom :: FieldName
_Axiom_classAxiom = (String -> FieldName
Core.FieldName String
"classAxiom")

_Axiom_dataPropertyAxiom :: FieldName
_Axiom_dataPropertyAxiom = (String -> FieldName
Core.FieldName String
"dataPropertyAxiom")

_Axiom_datatypeDefinition :: FieldName
_Axiom_datatypeDefinition = (String -> FieldName
Core.FieldName String
"datatypeDefinition")

_Axiom_declaration :: FieldName
_Axiom_declaration = (String -> FieldName
Core.FieldName String
"declaration")

_Axiom_hasKey :: FieldName
_Axiom_hasKey = (String -> FieldName
Core.FieldName String
"hasKey")

_Axiom_objectPropertyAxiom :: FieldName
_Axiom_objectPropertyAxiom = (String -> FieldName
Core.FieldName String
"objectPropertyAxiom")

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

_ClassAxiom :: Name
_ClassAxiom = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.ClassAxiom")

_ClassAxiom_disjointClasses :: FieldName
_ClassAxiom_disjointClasses = (String -> FieldName
Core.FieldName String
"disjointClasses")

_ClassAxiom_disjointUnion :: FieldName
_ClassAxiom_disjointUnion = (String -> FieldName
Core.FieldName String
"disjointUnion")

_ClassAxiom_equivalentClasses :: FieldName
_ClassAxiom_equivalentClasses = (String -> FieldName
Core.FieldName String
"equivalentClasses")

_ClassAxiom_subClassOf :: FieldName
_ClassAxiom_subClassOf = (String -> FieldName
Core.FieldName String
"subClassOf")

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

_SubClassOf :: Name
_SubClassOf = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.SubClassOf")

_SubClassOf_annotations :: FieldName
_SubClassOf_annotations = (String -> FieldName
Core.FieldName String
"annotations")

_SubClassOf_subClass :: FieldName
_SubClassOf_subClass = (String -> FieldName
Core.FieldName String
"subClass")

_SubClassOf_superClass :: FieldName
_SubClassOf_superClass = (String -> FieldName
Core.FieldName String
"superClass")

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

_EquivalentClasses :: Name
_EquivalentClasses = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.EquivalentClasses")

_EquivalentClasses_annotations :: FieldName
_EquivalentClasses_annotations = (String -> FieldName
Core.FieldName String
"annotations")

_EquivalentClasses_classes :: FieldName
_EquivalentClasses_classes = (String -> FieldName
Core.FieldName String
"classes")

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

_DisjointClasses :: Name
_DisjointClasses = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.DisjointClasses")

_DisjointClasses_annotations :: FieldName
_DisjointClasses_annotations = (String -> FieldName
Core.FieldName String
"annotations")

_DisjointClasses_classes :: FieldName
_DisjointClasses_classes = (String -> FieldName
Core.FieldName String
"classes")

-- | See https://www.w3.org/TR/owl2-syntax/#Disjoint_Union_of_Class_Expressions
data DisjointUnion = 
  DisjointUnion {
    DisjointUnion -> [Annotation]
disjointUnionAnnotations :: [Annotation],
    DisjointUnion -> Class
disjointUnionClass :: Class,
    DisjointUnion -> [ClassExpression]
disjointUnionClasses :: [ClassExpression]}
  deriving (DisjointUnion -> DisjointUnion -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DisjointUnion -> DisjointUnion -> Bool
$c/= :: DisjointUnion -> DisjointUnion -> Bool
== :: DisjointUnion -> DisjointUnion -> Bool
$c== :: DisjointUnion -> DisjointUnion -> Bool
Eq, Eq DisjointUnion
DisjointUnion -> DisjointUnion -> Bool
DisjointUnion -> DisjointUnion -> Ordering
DisjointUnion -> DisjointUnion -> DisjointUnion
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 :: DisjointUnion -> DisjointUnion -> DisjointUnion
$cmin :: DisjointUnion -> DisjointUnion -> DisjointUnion
max :: DisjointUnion -> DisjointUnion -> DisjointUnion
$cmax :: DisjointUnion -> DisjointUnion -> DisjointUnion
>= :: DisjointUnion -> DisjointUnion -> Bool
$c>= :: DisjointUnion -> DisjointUnion -> Bool
> :: DisjointUnion -> DisjointUnion -> Bool
$c> :: DisjointUnion -> DisjointUnion -> Bool
<= :: DisjointUnion -> DisjointUnion -> Bool
$c<= :: DisjointUnion -> DisjointUnion -> Bool
< :: DisjointUnion -> DisjointUnion -> Bool
$c< :: DisjointUnion -> DisjointUnion -> Bool
compare :: DisjointUnion -> DisjointUnion -> Ordering
$ccompare :: DisjointUnion -> DisjointUnion -> Ordering
Ord, ReadPrec [DisjointUnion]
ReadPrec DisjointUnion
Int -> ReadS DisjointUnion
ReadS [DisjointUnion]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DisjointUnion]
$creadListPrec :: ReadPrec [DisjointUnion]
readPrec :: ReadPrec DisjointUnion
$creadPrec :: ReadPrec DisjointUnion
readList :: ReadS [DisjointUnion]
$creadList :: ReadS [DisjointUnion]
readsPrec :: Int -> ReadS DisjointUnion
$creadsPrec :: Int -> ReadS DisjointUnion
Read, Int -> DisjointUnion -> ShowS
[DisjointUnion] -> ShowS
DisjointUnion -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DisjointUnion] -> ShowS
$cshowList :: [DisjointUnion] -> ShowS
show :: DisjointUnion -> String
$cshow :: DisjointUnion -> String
showsPrec :: Int -> DisjointUnion -> ShowS
$cshowsPrec :: Int -> DisjointUnion -> ShowS
Show)

_DisjointUnion :: Name
_DisjointUnion = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.DisjointUnion")

_DisjointUnion_annotations :: FieldName
_DisjointUnion_annotations = (String -> FieldName
Core.FieldName String
"annotations")

_DisjointUnion_class :: FieldName
_DisjointUnion_class = (String -> FieldName
Core.FieldName String
"class")

_DisjointUnion_classes :: FieldName
_DisjointUnion_classes = (String -> FieldName
Core.FieldName String
"classes")

data ObjectPropertyAxiom = 
  ObjectPropertyAxiomAsymmetricObjectProperty AsymmetricObjectProperty |
  ObjectPropertyAxiomDisjointObjectProperties DisjointObjectProperties |
  ObjectPropertyAxiomEquivalentObjectProperties EquivalentObjectProperties |
  ObjectPropertyAxiomFunctionalObjectProperty FunctionalObjectProperty |
  ObjectPropertyAxiomInverseFunctionalObjectProperty InverseFunctionalObjectProperty |
  ObjectPropertyAxiomInverseObjectProperties InverseObjectProperties |
  ObjectPropertyAxiomIrreflexiveObjectProperty IrreflexiveObjectProperty |
  ObjectPropertyAxiomObjectPropertyDomain ObjectPropertyDomain |
  ObjectPropertyAxiomObjectPropertyRange ObjectPropertyRange |
  ObjectPropertyAxiomReflexiveObjectProperty ReflexiveObjectProperty |
  ObjectPropertyAxiomSubObjectPropertyOf SubObjectPropertyOf |
  ObjectPropertyAxiomSymmetricObjectProperty SymmetricObjectProperty |
  ObjectPropertyAxiomTransitiveObjectProperty TransitiveObjectProperty
  deriving (ObjectPropertyAxiom -> ObjectPropertyAxiom -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ObjectPropertyAxiom -> ObjectPropertyAxiom -> Bool
$c/= :: ObjectPropertyAxiom -> ObjectPropertyAxiom -> Bool
== :: ObjectPropertyAxiom -> ObjectPropertyAxiom -> Bool
$c== :: ObjectPropertyAxiom -> ObjectPropertyAxiom -> Bool
Eq, Eq ObjectPropertyAxiom
ObjectPropertyAxiom -> ObjectPropertyAxiom -> Bool
ObjectPropertyAxiom -> ObjectPropertyAxiom -> Ordering
ObjectPropertyAxiom -> ObjectPropertyAxiom -> ObjectPropertyAxiom
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 :: ObjectPropertyAxiom -> ObjectPropertyAxiom -> ObjectPropertyAxiom
$cmin :: ObjectPropertyAxiom -> ObjectPropertyAxiom -> ObjectPropertyAxiom
max :: ObjectPropertyAxiom -> ObjectPropertyAxiom -> ObjectPropertyAxiom
$cmax :: ObjectPropertyAxiom -> ObjectPropertyAxiom -> ObjectPropertyAxiom
>= :: ObjectPropertyAxiom -> ObjectPropertyAxiom -> Bool
$c>= :: ObjectPropertyAxiom -> ObjectPropertyAxiom -> Bool
> :: ObjectPropertyAxiom -> ObjectPropertyAxiom -> Bool
$c> :: ObjectPropertyAxiom -> ObjectPropertyAxiom -> Bool
<= :: ObjectPropertyAxiom -> ObjectPropertyAxiom -> Bool
$c<= :: ObjectPropertyAxiom -> ObjectPropertyAxiom -> Bool
< :: ObjectPropertyAxiom -> ObjectPropertyAxiom -> Bool
$c< :: ObjectPropertyAxiom -> ObjectPropertyAxiom -> Bool
compare :: ObjectPropertyAxiom -> ObjectPropertyAxiom -> Ordering
$ccompare :: ObjectPropertyAxiom -> ObjectPropertyAxiom -> Ordering
Ord, ReadPrec [ObjectPropertyAxiom]
ReadPrec ObjectPropertyAxiom
Int -> ReadS ObjectPropertyAxiom
ReadS [ObjectPropertyAxiom]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ObjectPropertyAxiom]
$creadListPrec :: ReadPrec [ObjectPropertyAxiom]
readPrec :: ReadPrec ObjectPropertyAxiom
$creadPrec :: ReadPrec ObjectPropertyAxiom
readList :: ReadS [ObjectPropertyAxiom]
$creadList :: ReadS [ObjectPropertyAxiom]
readsPrec :: Int -> ReadS ObjectPropertyAxiom
$creadsPrec :: Int -> ReadS ObjectPropertyAxiom
Read, Int -> ObjectPropertyAxiom -> ShowS
[ObjectPropertyAxiom] -> ShowS
ObjectPropertyAxiom -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ObjectPropertyAxiom] -> ShowS
$cshowList :: [ObjectPropertyAxiom] -> ShowS
show :: ObjectPropertyAxiom -> String
$cshow :: ObjectPropertyAxiom -> String
showsPrec :: Int -> ObjectPropertyAxiom -> ShowS
$cshowsPrec :: Int -> ObjectPropertyAxiom -> ShowS
Show)

_ObjectPropertyAxiom :: Name
_ObjectPropertyAxiom = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.ObjectPropertyAxiom")

_ObjectPropertyAxiom_asymmetricObjectProperty :: FieldName
_ObjectPropertyAxiom_asymmetricObjectProperty = (String -> FieldName
Core.FieldName String
"asymmetricObjectProperty")

_ObjectPropertyAxiom_disjointObjectProperties :: FieldName
_ObjectPropertyAxiom_disjointObjectProperties = (String -> FieldName
Core.FieldName String
"disjointObjectProperties")

_ObjectPropertyAxiom_equivalentObjectProperties :: FieldName
_ObjectPropertyAxiom_equivalentObjectProperties = (String -> FieldName
Core.FieldName String
"equivalentObjectProperties")

_ObjectPropertyAxiom_functionalObjectProperty :: FieldName
_ObjectPropertyAxiom_functionalObjectProperty = (String -> FieldName
Core.FieldName String
"functionalObjectProperty")

_ObjectPropertyAxiom_inverseFunctionalObjectProperty :: FieldName
_ObjectPropertyAxiom_inverseFunctionalObjectProperty = (String -> FieldName
Core.FieldName String
"inverseFunctionalObjectProperty")

_ObjectPropertyAxiom_inverseObjectProperties :: FieldName
_ObjectPropertyAxiom_inverseObjectProperties = (String -> FieldName
Core.FieldName String
"inverseObjectProperties")

_ObjectPropertyAxiom_irreflexiveObjectProperty :: FieldName
_ObjectPropertyAxiom_irreflexiveObjectProperty = (String -> FieldName
Core.FieldName String
"irreflexiveObjectProperty")

_ObjectPropertyAxiom_objectPropertyDomain :: FieldName
_ObjectPropertyAxiom_objectPropertyDomain = (String -> FieldName
Core.FieldName String
"objectPropertyDomain")

_ObjectPropertyAxiom_objectPropertyRange :: FieldName
_ObjectPropertyAxiom_objectPropertyRange = (String -> FieldName
Core.FieldName String
"objectPropertyRange")

_ObjectPropertyAxiom_reflexiveObjectProperty :: FieldName
_ObjectPropertyAxiom_reflexiveObjectProperty = (String -> FieldName
Core.FieldName String
"reflexiveObjectProperty")

_ObjectPropertyAxiom_subObjectPropertyOf :: FieldName
_ObjectPropertyAxiom_subObjectPropertyOf = (String -> FieldName
Core.FieldName String
"subObjectPropertyOf")

_ObjectPropertyAxiom_symmetricObjectProperty :: FieldName
_ObjectPropertyAxiom_symmetricObjectProperty = (String -> FieldName
Core.FieldName String
"symmetricObjectProperty")

_ObjectPropertyAxiom_transitiveObjectProperty :: FieldName
_ObjectPropertyAxiom_transitiveObjectProperty = (String -> FieldName
Core.FieldName String
"transitiveObjectProperty")

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

_SubObjectPropertyOf :: Name
_SubObjectPropertyOf = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.SubObjectPropertyOf")

_SubObjectPropertyOf_annotations :: FieldName
_SubObjectPropertyOf_annotations = (String -> FieldName
Core.FieldName String
"annotations")

_SubObjectPropertyOf_subProperty :: FieldName
_SubObjectPropertyOf_subProperty = (String -> FieldName
Core.FieldName String
"subProperty")

_SubObjectPropertyOf_superProperty :: FieldName
_SubObjectPropertyOf_superProperty = (String -> FieldName
Core.FieldName String
"superProperty")

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

_EquivalentObjectProperties :: Name
_EquivalentObjectProperties = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.EquivalentObjectProperties")

_EquivalentObjectProperties_annotations :: FieldName
_EquivalentObjectProperties_annotations = (String -> FieldName
Core.FieldName String
"annotations")

_EquivalentObjectProperties_properties :: FieldName
_EquivalentObjectProperties_properties = (String -> FieldName
Core.FieldName String
"properties")

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

_DisjointObjectProperties :: Name
_DisjointObjectProperties = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.DisjointObjectProperties")

_DisjointObjectProperties_annotations :: FieldName
_DisjointObjectProperties_annotations = (String -> FieldName
Core.FieldName String
"annotations")

_DisjointObjectProperties_properties :: FieldName
_DisjointObjectProperties_properties = (String -> FieldName
Core.FieldName String
"properties")

-- | See https://www.w3.org/TR/owl2-syntax/#Object_Property_Domain
data ObjectPropertyDomain = 
  ObjectPropertyDomain {
    ObjectPropertyDomain -> [Annotation]
objectPropertyDomainAnnotations :: [Annotation],
    ObjectPropertyDomain -> ObjectPropertyExpression
objectPropertyDomainProperty :: ObjectPropertyExpression,
    ObjectPropertyDomain -> ClassExpression
objectPropertyDomainDomain :: ClassExpression}
  deriving (ObjectPropertyDomain -> ObjectPropertyDomain -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ObjectPropertyDomain -> ObjectPropertyDomain -> Bool
$c/= :: ObjectPropertyDomain -> ObjectPropertyDomain -> Bool
== :: ObjectPropertyDomain -> ObjectPropertyDomain -> Bool
$c== :: ObjectPropertyDomain -> ObjectPropertyDomain -> Bool
Eq, Eq ObjectPropertyDomain
ObjectPropertyDomain -> ObjectPropertyDomain -> Bool
ObjectPropertyDomain -> ObjectPropertyDomain -> Ordering
ObjectPropertyDomain
-> ObjectPropertyDomain -> ObjectPropertyDomain
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 :: ObjectPropertyDomain
-> ObjectPropertyDomain -> ObjectPropertyDomain
$cmin :: ObjectPropertyDomain
-> ObjectPropertyDomain -> ObjectPropertyDomain
max :: ObjectPropertyDomain
-> ObjectPropertyDomain -> ObjectPropertyDomain
$cmax :: ObjectPropertyDomain
-> ObjectPropertyDomain -> ObjectPropertyDomain
>= :: ObjectPropertyDomain -> ObjectPropertyDomain -> Bool
$c>= :: ObjectPropertyDomain -> ObjectPropertyDomain -> Bool
> :: ObjectPropertyDomain -> ObjectPropertyDomain -> Bool
$c> :: ObjectPropertyDomain -> ObjectPropertyDomain -> Bool
<= :: ObjectPropertyDomain -> ObjectPropertyDomain -> Bool
$c<= :: ObjectPropertyDomain -> ObjectPropertyDomain -> Bool
< :: ObjectPropertyDomain -> ObjectPropertyDomain -> Bool
$c< :: ObjectPropertyDomain -> ObjectPropertyDomain -> Bool
compare :: ObjectPropertyDomain -> ObjectPropertyDomain -> Ordering
$ccompare :: ObjectPropertyDomain -> ObjectPropertyDomain -> Ordering
Ord, ReadPrec [ObjectPropertyDomain]
ReadPrec ObjectPropertyDomain
Int -> ReadS ObjectPropertyDomain
ReadS [ObjectPropertyDomain]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ObjectPropertyDomain]
$creadListPrec :: ReadPrec [ObjectPropertyDomain]
readPrec :: ReadPrec ObjectPropertyDomain
$creadPrec :: ReadPrec ObjectPropertyDomain
readList :: ReadS [ObjectPropertyDomain]
$creadList :: ReadS [ObjectPropertyDomain]
readsPrec :: Int -> ReadS ObjectPropertyDomain
$creadsPrec :: Int -> ReadS ObjectPropertyDomain
Read, Int -> ObjectPropertyDomain -> ShowS
[ObjectPropertyDomain] -> ShowS
ObjectPropertyDomain -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ObjectPropertyDomain] -> ShowS
$cshowList :: [ObjectPropertyDomain] -> ShowS
show :: ObjectPropertyDomain -> String
$cshow :: ObjectPropertyDomain -> String
showsPrec :: Int -> ObjectPropertyDomain -> ShowS
$cshowsPrec :: Int -> ObjectPropertyDomain -> ShowS
Show)

_ObjectPropertyDomain :: Name
_ObjectPropertyDomain = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.ObjectPropertyDomain")

_ObjectPropertyDomain_annotations :: FieldName
_ObjectPropertyDomain_annotations = (String -> FieldName
Core.FieldName String
"annotations")

_ObjectPropertyDomain_property :: FieldName
_ObjectPropertyDomain_property = (String -> FieldName
Core.FieldName String
"property")

_ObjectPropertyDomain_domain :: FieldName
_ObjectPropertyDomain_domain = (String -> FieldName
Core.FieldName String
"domain")

-- | See https://www.w3.org/TR/owl2-syntax/#Object_Property_Range
data ObjectPropertyRange = 
  ObjectPropertyRange {
    ObjectPropertyRange -> [Annotation]
objectPropertyRangeAnnotations :: [Annotation],
    ObjectPropertyRange -> ObjectPropertyExpression
objectPropertyRangeProperty :: ObjectPropertyExpression,
    ObjectPropertyRange -> ClassExpression
objectPropertyRangeRange :: ClassExpression}
  deriving (ObjectPropertyRange -> ObjectPropertyRange -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ObjectPropertyRange -> ObjectPropertyRange -> Bool
$c/= :: ObjectPropertyRange -> ObjectPropertyRange -> Bool
== :: ObjectPropertyRange -> ObjectPropertyRange -> Bool
$c== :: ObjectPropertyRange -> ObjectPropertyRange -> Bool
Eq, Eq ObjectPropertyRange
ObjectPropertyRange -> ObjectPropertyRange -> Bool
ObjectPropertyRange -> ObjectPropertyRange -> Ordering
ObjectPropertyRange -> ObjectPropertyRange -> ObjectPropertyRange
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 :: ObjectPropertyRange -> ObjectPropertyRange -> ObjectPropertyRange
$cmin :: ObjectPropertyRange -> ObjectPropertyRange -> ObjectPropertyRange
max :: ObjectPropertyRange -> ObjectPropertyRange -> ObjectPropertyRange
$cmax :: ObjectPropertyRange -> ObjectPropertyRange -> ObjectPropertyRange
>= :: ObjectPropertyRange -> ObjectPropertyRange -> Bool
$c>= :: ObjectPropertyRange -> ObjectPropertyRange -> Bool
> :: ObjectPropertyRange -> ObjectPropertyRange -> Bool
$c> :: ObjectPropertyRange -> ObjectPropertyRange -> Bool
<= :: ObjectPropertyRange -> ObjectPropertyRange -> Bool
$c<= :: ObjectPropertyRange -> ObjectPropertyRange -> Bool
< :: ObjectPropertyRange -> ObjectPropertyRange -> Bool
$c< :: ObjectPropertyRange -> ObjectPropertyRange -> Bool
compare :: ObjectPropertyRange -> ObjectPropertyRange -> Ordering
$ccompare :: ObjectPropertyRange -> ObjectPropertyRange -> Ordering
Ord, ReadPrec [ObjectPropertyRange]
ReadPrec ObjectPropertyRange
Int -> ReadS ObjectPropertyRange
ReadS [ObjectPropertyRange]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ObjectPropertyRange]
$creadListPrec :: ReadPrec [ObjectPropertyRange]
readPrec :: ReadPrec ObjectPropertyRange
$creadPrec :: ReadPrec ObjectPropertyRange
readList :: ReadS [ObjectPropertyRange]
$creadList :: ReadS [ObjectPropertyRange]
readsPrec :: Int -> ReadS ObjectPropertyRange
$creadsPrec :: Int -> ReadS ObjectPropertyRange
Read, Int -> ObjectPropertyRange -> ShowS
[ObjectPropertyRange] -> ShowS
ObjectPropertyRange -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ObjectPropertyRange] -> ShowS
$cshowList :: [ObjectPropertyRange] -> ShowS
show :: ObjectPropertyRange -> String
$cshow :: ObjectPropertyRange -> String
showsPrec :: Int -> ObjectPropertyRange -> ShowS
$cshowsPrec :: Int -> ObjectPropertyRange -> ShowS
Show)

_ObjectPropertyRange :: Name
_ObjectPropertyRange = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.ObjectPropertyRange")

_ObjectPropertyRange_annotations :: FieldName
_ObjectPropertyRange_annotations = (String -> FieldName
Core.FieldName String
"annotations")

_ObjectPropertyRange_property :: FieldName
_ObjectPropertyRange_property = (String -> FieldName
Core.FieldName String
"property")

_ObjectPropertyRange_range :: FieldName
_ObjectPropertyRange_range = (String -> FieldName
Core.FieldName String
"range")

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

_InverseObjectProperties :: Name
_InverseObjectProperties = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.InverseObjectProperties")

_InverseObjectProperties_annotations :: FieldName
_InverseObjectProperties_annotations = (String -> FieldName
Core.FieldName String
"annotations")

_InverseObjectProperties_property1 :: FieldName
_InverseObjectProperties_property1 = (String -> FieldName
Core.FieldName String
"property1")

_InverseObjectProperties_property2 :: FieldName
_InverseObjectProperties_property2 = (String -> FieldName
Core.FieldName String
"property2")

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

_FunctionalObjectProperty :: Name
_FunctionalObjectProperty = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.FunctionalObjectProperty")

_FunctionalObjectProperty_annotations :: FieldName
_FunctionalObjectProperty_annotations = (String -> FieldName
Core.FieldName String
"annotations")

_FunctionalObjectProperty_property :: FieldName
_FunctionalObjectProperty_property = (String -> FieldName
Core.FieldName String
"property")

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

_InverseFunctionalObjectProperty :: Name
_InverseFunctionalObjectProperty = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.InverseFunctionalObjectProperty")

_InverseFunctionalObjectProperty_annotations :: FieldName
_InverseFunctionalObjectProperty_annotations = (String -> FieldName
Core.FieldName String
"annotations")

_InverseFunctionalObjectProperty_property :: FieldName
_InverseFunctionalObjectProperty_property = (String -> FieldName
Core.FieldName String
"property")

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

_ReflexiveObjectProperty :: Name
_ReflexiveObjectProperty = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.ReflexiveObjectProperty")

_ReflexiveObjectProperty_annotations :: FieldName
_ReflexiveObjectProperty_annotations = (String -> FieldName
Core.FieldName String
"annotations")

_ReflexiveObjectProperty_property :: FieldName
_ReflexiveObjectProperty_property = (String -> FieldName
Core.FieldName String
"property")

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

_IrreflexiveObjectProperty :: Name
_IrreflexiveObjectProperty = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.IrreflexiveObjectProperty")

_IrreflexiveObjectProperty_annotations :: FieldName
_IrreflexiveObjectProperty_annotations = (String -> FieldName
Core.FieldName String
"annotations")

_IrreflexiveObjectProperty_property :: FieldName
_IrreflexiveObjectProperty_property = (String -> FieldName
Core.FieldName String
"property")

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

_SymmetricObjectProperty :: Name
_SymmetricObjectProperty = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.SymmetricObjectProperty")

_SymmetricObjectProperty_annotations :: FieldName
_SymmetricObjectProperty_annotations = (String -> FieldName
Core.FieldName String
"annotations")

_SymmetricObjectProperty_property :: FieldName
_SymmetricObjectProperty_property = (String -> FieldName
Core.FieldName String
"property")

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

_AsymmetricObjectProperty :: Name
_AsymmetricObjectProperty = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.AsymmetricObjectProperty")

_AsymmetricObjectProperty_annotations :: FieldName
_AsymmetricObjectProperty_annotations = (String -> FieldName
Core.FieldName String
"annotations")

_AsymmetricObjectProperty_property :: FieldName
_AsymmetricObjectProperty_property = (String -> FieldName
Core.FieldName String
"property")

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

_TransitiveObjectProperty :: Name
_TransitiveObjectProperty = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.TransitiveObjectProperty")

_TransitiveObjectProperty_annotations :: FieldName
_TransitiveObjectProperty_annotations = (String -> FieldName
Core.FieldName String
"annotations")

_TransitiveObjectProperty_property :: FieldName
_TransitiveObjectProperty_property = (String -> FieldName
Core.FieldName String
"property")

data DataPropertyAxiom = 
  DataPropertyAxiomDataPropertyAxiom DataPropertyAxiom |
  DataPropertyAxiomDataPropertyRange DataPropertyRange |
  DataPropertyAxiomDisjointDataProperties DisjointDataProperties |
  DataPropertyAxiomEquivalentDataProperties EquivalentDataProperties |
  DataPropertyAxiomFunctionalDataProperty FunctionalDataProperty |
  DataPropertyAxiomSubDataPropertyOf SubDataPropertyOf
  deriving (DataPropertyAxiom -> DataPropertyAxiom -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DataPropertyAxiom -> DataPropertyAxiom -> Bool
$c/= :: DataPropertyAxiom -> DataPropertyAxiom -> Bool
== :: DataPropertyAxiom -> DataPropertyAxiom -> Bool
$c== :: DataPropertyAxiom -> DataPropertyAxiom -> Bool
Eq, Eq DataPropertyAxiom
DataPropertyAxiom -> DataPropertyAxiom -> Bool
DataPropertyAxiom -> DataPropertyAxiom -> Ordering
DataPropertyAxiom -> DataPropertyAxiom -> DataPropertyAxiom
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 :: DataPropertyAxiom -> DataPropertyAxiom -> DataPropertyAxiom
$cmin :: DataPropertyAxiom -> DataPropertyAxiom -> DataPropertyAxiom
max :: DataPropertyAxiom -> DataPropertyAxiom -> DataPropertyAxiom
$cmax :: DataPropertyAxiom -> DataPropertyAxiom -> DataPropertyAxiom
>= :: DataPropertyAxiom -> DataPropertyAxiom -> Bool
$c>= :: DataPropertyAxiom -> DataPropertyAxiom -> Bool
> :: DataPropertyAxiom -> DataPropertyAxiom -> Bool
$c> :: DataPropertyAxiom -> DataPropertyAxiom -> Bool
<= :: DataPropertyAxiom -> DataPropertyAxiom -> Bool
$c<= :: DataPropertyAxiom -> DataPropertyAxiom -> Bool
< :: DataPropertyAxiom -> DataPropertyAxiom -> Bool
$c< :: DataPropertyAxiom -> DataPropertyAxiom -> Bool
compare :: DataPropertyAxiom -> DataPropertyAxiom -> Ordering
$ccompare :: DataPropertyAxiom -> DataPropertyAxiom -> Ordering
Ord, ReadPrec [DataPropertyAxiom]
ReadPrec DataPropertyAxiom
Int -> ReadS DataPropertyAxiom
ReadS [DataPropertyAxiom]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DataPropertyAxiom]
$creadListPrec :: ReadPrec [DataPropertyAxiom]
readPrec :: ReadPrec DataPropertyAxiom
$creadPrec :: ReadPrec DataPropertyAxiom
readList :: ReadS [DataPropertyAxiom]
$creadList :: ReadS [DataPropertyAxiom]
readsPrec :: Int -> ReadS DataPropertyAxiom
$creadsPrec :: Int -> ReadS DataPropertyAxiom
Read, Int -> DataPropertyAxiom -> ShowS
[DataPropertyAxiom] -> ShowS
DataPropertyAxiom -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DataPropertyAxiom] -> ShowS
$cshowList :: [DataPropertyAxiom] -> ShowS
show :: DataPropertyAxiom -> String
$cshow :: DataPropertyAxiom -> String
showsPrec :: Int -> DataPropertyAxiom -> ShowS
$cshowsPrec :: Int -> DataPropertyAxiom -> ShowS
Show)

_DataPropertyAxiom :: Name
_DataPropertyAxiom = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.DataPropertyAxiom")

_DataPropertyAxiom_dataPropertyAxiom :: FieldName
_DataPropertyAxiom_dataPropertyAxiom = (String -> FieldName
Core.FieldName String
"dataPropertyAxiom")

_DataPropertyAxiom_dataPropertyRange :: FieldName
_DataPropertyAxiom_dataPropertyRange = (String -> FieldName
Core.FieldName String
"dataPropertyRange")

_DataPropertyAxiom_disjointDataProperties :: FieldName
_DataPropertyAxiom_disjointDataProperties = (String -> FieldName
Core.FieldName String
"disjointDataProperties")

_DataPropertyAxiom_equivalentDataProperties :: FieldName
_DataPropertyAxiom_equivalentDataProperties = (String -> FieldName
Core.FieldName String
"equivalentDataProperties")

_DataPropertyAxiom_functionalDataProperty :: FieldName
_DataPropertyAxiom_functionalDataProperty = (String -> FieldName
Core.FieldName String
"functionalDataProperty")

_DataPropertyAxiom_subDataPropertyOf :: FieldName
_DataPropertyAxiom_subDataPropertyOf = (String -> FieldName
Core.FieldName String
"subDataPropertyOf")

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

_SubDataPropertyOf :: Name
_SubDataPropertyOf = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.SubDataPropertyOf")

_SubDataPropertyOf_annotations :: FieldName
_SubDataPropertyOf_annotations = (String -> FieldName
Core.FieldName String
"annotations")

_SubDataPropertyOf_subProperty :: FieldName
_SubDataPropertyOf_subProperty = (String -> FieldName
Core.FieldName String
"subProperty")

_SubDataPropertyOf_superProperty :: FieldName
_SubDataPropertyOf_superProperty = (String -> FieldName
Core.FieldName String
"superProperty")

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

_EquivalentDataProperties :: Name
_EquivalentDataProperties = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.EquivalentDataProperties")

_EquivalentDataProperties_annotations :: FieldName
_EquivalentDataProperties_annotations = (String -> FieldName
Core.FieldName String
"annotations")

_EquivalentDataProperties_properties :: FieldName
_EquivalentDataProperties_properties = (String -> FieldName
Core.FieldName String
"properties")

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

_DisjointDataProperties :: Name
_DisjointDataProperties = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.DisjointDataProperties")

_DisjointDataProperties_annotations :: FieldName
_DisjointDataProperties_annotations = (String -> FieldName
Core.FieldName String
"annotations")

_DisjointDataProperties_properties :: FieldName
_DisjointDataProperties_properties = (String -> FieldName
Core.FieldName String
"properties")

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

_DataPropertyDomain :: Name
_DataPropertyDomain = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.DataPropertyDomain")

_DataPropertyDomain_annotations :: FieldName
_DataPropertyDomain_annotations = (String -> FieldName
Core.FieldName String
"annotations")

_DataPropertyDomain_property :: FieldName
_DataPropertyDomain_property = (String -> FieldName
Core.FieldName String
"property")

_DataPropertyDomain_domain :: FieldName
_DataPropertyDomain_domain = (String -> FieldName
Core.FieldName String
"domain")

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

_DataPropertyRange :: Name
_DataPropertyRange = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.DataPropertyRange")

_DataPropertyRange_annotations :: FieldName
_DataPropertyRange_annotations = (String -> FieldName
Core.FieldName String
"annotations")

_DataPropertyRange_property :: FieldName
_DataPropertyRange_property = (String -> FieldName
Core.FieldName String
"property")

_DataPropertyRange_range :: FieldName
_DataPropertyRange_range = (String -> FieldName
Core.FieldName String
"range")

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

_FunctionalDataProperty :: Name
_FunctionalDataProperty = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.FunctionalDataProperty")

_FunctionalDataProperty_annotations :: FieldName
_FunctionalDataProperty_annotations = (String -> FieldName
Core.FieldName String
"annotations")

_FunctionalDataProperty_property :: FieldName
_FunctionalDataProperty_property = (String -> FieldName
Core.FieldName String
"property")

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

_DatatypeDefinition :: Name
_DatatypeDefinition = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.DatatypeDefinition")

_DatatypeDefinition_annotations :: FieldName
_DatatypeDefinition_annotations = (String -> FieldName
Core.FieldName String
"annotations")

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

_DatatypeDefinition_range :: FieldName
_DatatypeDefinition_range = (String -> FieldName
Core.FieldName String
"range")

-- | See https://www.w3.org/TR/owl2-syntax/#Keys
data HasKey = 
  HasKey {
    HasKey -> [Annotation]
hasKeyAnnotations :: [Annotation],
    HasKey -> ClassExpression
hasKeyClass :: ClassExpression,
    HasKey -> [ObjectPropertyExpression]
hasKeyObjectProperties :: [ObjectPropertyExpression],
    HasKey -> [DataPropertyExpression]
hasKeyDataProperties :: [DataPropertyExpression]}
  deriving (HasKey -> HasKey -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: HasKey -> HasKey -> Bool
$c/= :: HasKey -> HasKey -> Bool
== :: HasKey -> HasKey -> Bool
$c== :: HasKey -> HasKey -> Bool
Eq, Eq HasKey
HasKey -> HasKey -> Bool
HasKey -> HasKey -> Ordering
HasKey -> HasKey -> HasKey
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 :: HasKey -> HasKey -> HasKey
$cmin :: HasKey -> HasKey -> HasKey
max :: HasKey -> HasKey -> HasKey
$cmax :: HasKey -> HasKey -> HasKey
>= :: HasKey -> HasKey -> Bool
$c>= :: HasKey -> HasKey -> Bool
> :: HasKey -> HasKey -> Bool
$c> :: HasKey -> HasKey -> Bool
<= :: HasKey -> HasKey -> Bool
$c<= :: HasKey -> HasKey -> Bool
< :: HasKey -> HasKey -> Bool
$c< :: HasKey -> HasKey -> Bool
compare :: HasKey -> HasKey -> Ordering
$ccompare :: HasKey -> HasKey -> Ordering
Ord, ReadPrec [HasKey]
ReadPrec HasKey
Int -> ReadS HasKey
ReadS [HasKey]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [HasKey]
$creadListPrec :: ReadPrec [HasKey]
readPrec :: ReadPrec HasKey
$creadPrec :: ReadPrec HasKey
readList :: ReadS [HasKey]
$creadList :: ReadS [HasKey]
readsPrec :: Int -> ReadS HasKey
$creadsPrec :: Int -> ReadS HasKey
Read, Int -> HasKey -> ShowS
[HasKey] -> ShowS
HasKey -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [HasKey] -> ShowS
$cshowList :: [HasKey] -> ShowS
show :: HasKey -> String
$cshow :: HasKey -> String
showsPrec :: Int -> HasKey -> ShowS
$cshowsPrec :: Int -> HasKey -> ShowS
Show)

_HasKey :: Name
_HasKey = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.HasKey")

_HasKey_annotations :: FieldName
_HasKey_annotations = (String -> FieldName
Core.FieldName String
"annotations")

_HasKey_class :: FieldName
_HasKey_class = (String -> FieldName
Core.FieldName String
"class")

_HasKey_objectProperties :: FieldName
_HasKey_objectProperties = (String -> FieldName
Core.FieldName String
"objectProperties")

_HasKey_dataProperties :: FieldName
_HasKey_dataProperties = (String -> FieldName
Core.FieldName String
"dataProperties")

data Assertion = 
  AssertionClassAssertion ClassAssertion |
  AssertionDataPropertyAssertion DataPropertyAssertion |
  AssertionDifferentIndividuals DifferentIndividuals |
  AssertionObjectPropertyAssertion ObjectPropertyAssertion |
  AssertionNegativeDataPropertyAssertion NegativeDataPropertyAssertion |
  AssertionNegativeObjectPropertyAssertion NegativeObjectPropertyAssertion |
  AssertionSameIndividual SameIndividual
  deriving (Assertion -> Assertion -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Assertion -> Assertion -> Bool
$c/= :: Assertion -> Assertion -> Bool
== :: Assertion -> Assertion -> Bool
$c== :: Assertion -> Assertion -> Bool
Eq, Eq Assertion
Assertion -> Assertion -> Bool
Assertion -> Assertion -> Ordering
Assertion -> Assertion -> Assertion
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 :: Assertion -> Assertion -> Assertion
$cmin :: Assertion -> Assertion -> Assertion
max :: Assertion -> Assertion -> Assertion
$cmax :: Assertion -> Assertion -> Assertion
>= :: Assertion -> Assertion -> Bool
$c>= :: Assertion -> Assertion -> Bool
> :: Assertion -> Assertion -> Bool
$c> :: Assertion -> Assertion -> Bool
<= :: Assertion -> Assertion -> Bool
$c<= :: Assertion -> Assertion -> Bool
< :: Assertion -> Assertion -> Bool
$c< :: Assertion -> Assertion -> Bool
compare :: Assertion -> Assertion -> Ordering
$ccompare :: Assertion -> Assertion -> Ordering
Ord, ReadPrec [Assertion]
ReadPrec Assertion
Int -> ReadS Assertion
ReadS [Assertion]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Assertion]
$creadListPrec :: ReadPrec [Assertion]
readPrec :: ReadPrec Assertion
$creadPrec :: ReadPrec Assertion
readList :: ReadS [Assertion]
$creadList :: ReadS [Assertion]
readsPrec :: Int -> ReadS Assertion
$creadsPrec :: Int -> ReadS Assertion
Read, Int -> Assertion -> ShowS
[Assertion] -> ShowS
Assertion -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Assertion] -> ShowS
$cshowList :: [Assertion] -> ShowS
show :: Assertion -> String
$cshow :: Assertion -> String
showsPrec :: Int -> Assertion -> ShowS
$cshowsPrec :: Int -> Assertion -> ShowS
Show)

_Assertion :: Name
_Assertion = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.Assertion")

_Assertion_classAssertion :: FieldName
_Assertion_classAssertion = (String -> FieldName
Core.FieldName String
"classAssertion")

_Assertion_dataPropertyAssertion :: FieldName
_Assertion_dataPropertyAssertion = (String -> FieldName
Core.FieldName String
"dataPropertyAssertion")

_Assertion_differentIndividuals :: FieldName
_Assertion_differentIndividuals = (String -> FieldName
Core.FieldName String
"differentIndividuals")

_Assertion_objectPropertyAssertion :: FieldName
_Assertion_objectPropertyAssertion = (String -> FieldName
Core.FieldName String
"objectPropertyAssertion")

_Assertion_negativeDataPropertyAssertion :: FieldName
_Assertion_negativeDataPropertyAssertion = (String -> FieldName
Core.FieldName String
"negativeDataPropertyAssertion")

_Assertion_negativeObjectPropertyAssertion :: FieldName
_Assertion_negativeObjectPropertyAssertion = (String -> FieldName
Core.FieldName String
"negativeObjectPropertyAssertion")

_Assertion_sameIndividual :: FieldName
_Assertion_sameIndividual = (String -> FieldName
Core.FieldName String
"sameIndividual")

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

_SameIndividual :: Name
_SameIndividual = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.SameIndividual")

_SameIndividual_annotations :: FieldName
_SameIndividual_annotations = (String -> FieldName
Core.FieldName String
"annotations")

_SameIndividual_individuals :: FieldName
_SameIndividual_individuals = (String -> FieldName
Core.FieldName String
"individuals")

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

_DifferentIndividuals :: Name
_DifferentIndividuals = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.DifferentIndividuals")

_DifferentIndividuals_annotations :: FieldName
_DifferentIndividuals_annotations = (String -> FieldName
Core.FieldName String
"annotations")

_DifferentIndividuals_individuals :: FieldName
_DifferentIndividuals_individuals = (String -> FieldName
Core.FieldName String
"individuals")

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

_ClassAssertion :: Name
_ClassAssertion = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.ClassAssertion")

_ClassAssertion_annotations :: FieldName
_ClassAssertion_annotations = (String -> FieldName
Core.FieldName String
"annotations")

_ClassAssertion_class :: FieldName
_ClassAssertion_class = (String -> FieldName
Core.FieldName String
"class")

_ClassAssertion_individual :: FieldName
_ClassAssertion_individual = (String -> FieldName
Core.FieldName String
"individual")

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

_ObjectPropertyAssertion :: Name
_ObjectPropertyAssertion = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.ObjectPropertyAssertion")

_ObjectPropertyAssertion_annotations :: FieldName
_ObjectPropertyAssertion_annotations = (String -> FieldName
Core.FieldName String
"annotations")

_ObjectPropertyAssertion_property :: FieldName
_ObjectPropertyAssertion_property = (String -> FieldName
Core.FieldName String
"property")

_ObjectPropertyAssertion_source :: FieldName
_ObjectPropertyAssertion_source = (String -> FieldName
Core.FieldName String
"source")

_ObjectPropertyAssertion_target :: FieldName
_ObjectPropertyAssertion_target = (String -> FieldName
Core.FieldName String
"target")

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

_NegativeObjectPropertyAssertion :: Name
_NegativeObjectPropertyAssertion = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.NegativeObjectPropertyAssertion")

_NegativeObjectPropertyAssertion_annotations :: FieldName
_NegativeObjectPropertyAssertion_annotations = (String -> FieldName
Core.FieldName String
"annotations")

_NegativeObjectPropertyAssertion_property :: FieldName
_NegativeObjectPropertyAssertion_property = (String -> FieldName
Core.FieldName String
"property")

_NegativeObjectPropertyAssertion_source :: FieldName
_NegativeObjectPropertyAssertion_source = (String -> FieldName
Core.FieldName String
"source")

_NegativeObjectPropertyAssertion_target :: FieldName
_NegativeObjectPropertyAssertion_target = (String -> FieldName
Core.FieldName String
"target")

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

_DataPropertyAssertion :: Name
_DataPropertyAssertion = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.DataPropertyAssertion")

_DataPropertyAssertion_annotations :: FieldName
_DataPropertyAssertion_annotations = (String -> FieldName
Core.FieldName String
"annotations")

_DataPropertyAssertion_property :: FieldName
_DataPropertyAssertion_property = (String -> FieldName
Core.FieldName String
"property")

_DataPropertyAssertion_source :: FieldName
_DataPropertyAssertion_source = (String -> FieldName
Core.FieldName String
"source")

_DataPropertyAssertion_target :: FieldName
_DataPropertyAssertion_target = (String -> FieldName
Core.FieldName String
"target")

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

_NegativeDataPropertyAssertion :: Name
_NegativeDataPropertyAssertion = (String -> Name
Core.Name String
"hydra/ext/owl/syntax.NegativeDataPropertyAssertion")

_NegativeDataPropertyAssertion_annotations :: FieldName
_NegativeDataPropertyAssertion_annotations = (String -> FieldName
Core.FieldName String
"annotations")

_NegativeDataPropertyAssertion_property :: FieldName
_NegativeDataPropertyAssertion_property = (String -> FieldName
Core.FieldName String
"property")

_NegativeDataPropertyAssertion_source :: FieldName
_NegativeDataPropertyAssertion_source = (String -> FieldName
Core.FieldName String
"source")

_NegativeDataPropertyAssertion_target :: FieldName
_NegativeDataPropertyAssertion_target = (String -> FieldName
Core.FieldName String
"target")