-- | An RDF 1.1 syntax model

module Hydra.Ext.Rdf.Syntax where

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

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

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

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

_RdfsClass :: Name
_RdfsClass = (String -> Name
Core.Name String
"hydra/ext/rdf/syntax.RdfsClass")

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

_Dataset :: Name
_Dataset = (String -> Name
Core.Name String
"hydra/ext/rdf/syntax.Dataset")

-- | A graph of RDF statements together with a distinguished subject and/or object node
data Description = 
  Description {
    Description -> Node
descriptionSubject :: Node,
    Description -> Graph
descriptionGraph :: Graph}
  deriving (Description -> Description -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Description -> Description -> Bool
$c/= :: Description -> Description -> Bool
== :: Description -> Description -> Bool
$c== :: Description -> Description -> Bool
Eq, Eq Description
Description -> Description -> Bool
Description -> Description -> Ordering
Description -> Description -> Description
forall a.
Eq 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 :: Description -> Description -> Description
$cmin :: Description -> Description -> Description
max :: Description -> Description -> Description
$cmax :: Description -> Description -> Description
>= :: Description -> Description -> Bool
$c>= :: Description -> Description -> Bool
> :: Description -> Description -> Bool
$c> :: Description -> Description -> Bool
<= :: Description -> Description -> Bool
$c<= :: Description -> Description -> Bool
< :: Description -> Description -> Bool
$c< :: Description -> Description -> Bool
compare :: Description -> Description -> Ordering
$ccompare :: Description -> Description -> Ordering
Ord, ReadPrec [Description]
ReadPrec Description
Int -> ReadS Description
ReadS [Description]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Description]
$creadListPrec :: ReadPrec [Description]
readPrec :: ReadPrec Description
$creadPrec :: ReadPrec Description
readList :: ReadS [Description]
$creadList :: ReadS [Description]
readsPrec :: Int -> ReadS Description
$creadsPrec :: Int -> ReadS Description
Read, Int -> Description -> String -> String
[Description] -> String -> String
Description -> String
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Description] -> String -> String
$cshowList :: [Description] -> String -> String
show :: Description -> String
$cshow :: Description -> String
showsPrec :: Int -> Description -> String -> String
$cshowsPrec :: Int -> Description -> String -> String
Show)

_Description :: Name
_Description = (String -> Name
Core.Name String
"hydra/ext/rdf/syntax.Description")

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

_Description_graph :: FieldName
_Description_graph = (String -> FieldName
Core.FieldName String
"graph")

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

_Graph :: Name
_Graph = (String -> Name
Core.Name String
"hydra/ext/rdf/syntax.Graph")

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

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

-- | An IRI or a literal; this type is a convenience for downstream models like SHACL which may exclude blank nodes
data IriOrLiteral = 
  IriOrLiteralIri Iri |
  IriOrLiteralLiteral Literal
  deriving (IriOrLiteral -> IriOrLiteral -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: IriOrLiteral -> IriOrLiteral -> Bool
$c/= :: IriOrLiteral -> IriOrLiteral -> Bool
== :: IriOrLiteral -> IriOrLiteral -> Bool
$c== :: IriOrLiteral -> IriOrLiteral -> Bool
Eq, Eq IriOrLiteral
IriOrLiteral -> IriOrLiteral -> Bool
IriOrLiteral -> IriOrLiteral -> Ordering
IriOrLiteral -> IriOrLiteral -> IriOrLiteral
forall a.
Eq 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 :: IriOrLiteral -> IriOrLiteral -> IriOrLiteral
$cmin :: IriOrLiteral -> IriOrLiteral -> IriOrLiteral
max :: IriOrLiteral -> IriOrLiteral -> IriOrLiteral
$cmax :: IriOrLiteral -> IriOrLiteral -> IriOrLiteral
>= :: IriOrLiteral -> IriOrLiteral -> Bool
$c>= :: IriOrLiteral -> IriOrLiteral -> Bool
> :: IriOrLiteral -> IriOrLiteral -> Bool
$c> :: IriOrLiteral -> IriOrLiteral -> Bool
<= :: IriOrLiteral -> IriOrLiteral -> Bool
$c<= :: IriOrLiteral -> IriOrLiteral -> Bool
< :: IriOrLiteral -> IriOrLiteral -> Bool
$c< :: IriOrLiteral -> IriOrLiteral -> Bool
compare :: IriOrLiteral -> IriOrLiteral -> Ordering
$ccompare :: IriOrLiteral -> IriOrLiteral -> Ordering
Ord, ReadPrec [IriOrLiteral]
ReadPrec IriOrLiteral
Int -> ReadS IriOrLiteral
ReadS [IriOrLiteral]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [IriOrLiteral]
$creadListPrec :: ReadPrec [IriOrLiteral]
readPrec :: ReadPrec IriOrLiteral
$creadPrec :: ReadPrec IriOrLiteral
readList :: ReadS [IriOrLiteral]
$creadList :: ReadS [IriOrLiteral]
readsPrec :: Int -> ReadS IriOrLiteral
$creadsPrec :: Int -> ReadS IriOrLiteral
Read, Int -> IriOrLiteral -> String -> String
[IriOrLiteral] -> String -> String
IriOrLiteral -> String
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [IriOrLiteral] -> String -> String
$cshowList :: [IriOrLiteral] -> String -> String
show :: IriOrLiteral -> String
$cshow :: IriOrLiteral -> String
showsPrec :: Int -> IriOrLiteral -> String -> String
$cshowsPrec :: Int -> IriOrLiteral -> String -> String
Show)

_IriOrLiteral :: Name
_IriOrLiteral = (String -> Name
Core.Name String
"hydra/ext/rdf/syntax.IriOrLiteral")

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

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

-- | A convenience type which provides at most one string value per language, and optionally a value without a language
newtype LangStrings = 
  LangStrings {
    -- | A convenience type which provides at most one string value per language, and optionally a value without a language
    LangStrings -> Map (Maybe LanguageTag) String
unLangStrings :: (Map (Maybe LanguageTag) String)}
  deriving (LangStrings -> LangStrings -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: LangStrings -> LangStrings -> Bool
$c/= :: LangStrings -> LangStrings -> Bool
== :: LangStrings -> LangStrings -> Bool
$c== :: LangStrings -> LangStrings -> Bool
Eq, Eq LangStrings
LangStrings -> LangStrings -> Bool
LangStrings -> LangStrings -> Ordering
LangStrings -> LangStrings -> LangStrings
forall a.
Eq 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 :: LangStrings -> LangStrings -> LangStrings
$cmin :: LangStrings -> LangStrings -> LangStrings
max :: LangStrings -> LangStrings -> LangStrings
$cmax :: LangStrings -> LangStrings -> LangStrings
>= :: LangStrings -> LangStrings -> Bool
$c>= :: LangStrings -> LangStrings -> Bool
> :: LangStrings -> LangStrings -> Bool
$c> :: LangStrings -> LangStrings -> Bool
<= :: LangStrings -> LangStrings -> Bool
$c<= :: LangStrings -> LangStrings -> Bool
< :: LangStrings -> LangStrings -> Bool
$c< :: LangStrings -> LangStrings -> Bool
compare :: LangStrings -> LangStrings -> Ordering
$ccompare :: LangStrings -> LangStrings -> Ordering
Ord, ReadPrec [LangStrings]
ReadPrec LangStrings
Int -> ReadS LangStrings
ReadS [LangStrings]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [LangStrings]
$creadListPrec :: ReadPrec [LangStrings]
readPrec :: ReadPrec LangStrings
$creadPrec :: ReadPrec LangStrings
readList :: ReadS [LangStrings]
$creadList :: ReadS [LangStrings]
readsPrec :: Int -> ReadS LangStrings
$creadsPrec :: Int -> ReadS LangStrings
Read, Int -> LangStrings -> String -> String
[LangStrings] -> String -> String
LangStrings -> String
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [LangStrings] -> String -> String
$cshowList :: [LangStrings] -> String -> String
show :: LangStrings -> String
$cshow :: LangStrings -> String
showsPrec :: Int -> LangStrings -> String -> String
$cshowsPrec :: Int -> LangStrings -> String -> String
Show)

_LangStrings :: Name
_LangStrings = (String -> Name
Core.Name String
"hydra/ext/rdf/syntax.LangStrings")

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

_LanguageTag :: Name
_LanguageTag = (String -> Name
Core.Name String
"hydra/ext/rdf/syntax.LanguageTag")

-- | A value such as a string, number, or date
data Literal = 
  Literal {
    -- | a Unicode string, which should be in Normal Form C
    Literal -> String
literalLexicalForm :: String,
    -- | an IRI identifying a datatype that determines how the lexical form maps to a literal value
    Literal -> Iri
literalDatatypeIri :: Iri,
    -- | An optional language tag, present if and only if the datatype IRI is http://www.w3.org/1999/02/22-rdf-syntax-ns#langString
    Literal -> Maybe LanguageTag
literalLanguageTag :: (Maybe LanguageTag)}
  deriving (Literal -> Literal -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Literal -> Literal -> Bool
$c/= :: Literal -> Literal -> Bool
== :: Literal -> Literal -> Bool
$c== :: Literal -> Literal -> Bool
Eq, Eq Literal
Literal -> Literal -> Bool
Literal -> Literal -> Ordering
Literal -> Literal -> Literal
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Literal -> Literal -> Literal
$cmin :: Literal -> Literal -> Literal
max :: Literal -> Literal -> Literal
$cmax :: Literal -> Literal -> Literal
>= :: Literal -> Literal -> Bool
$c>= :: Literal -> Literal -> Bool
> :: Literal -> Literal -> Bool
$c> :: Literal -> Literal -> Bool
<= :: Literal -> Literal -> Bool
$c<= :: Literal -> Literal -> Bool
< :: Literal -> Literal -> Bool
$c< :: Literal -> Literal -> Bool
compare :: Literal -> Literal -> Ordering
$ccompare :: Literal -> Literal -> Ordering
Ord, ReadPrec [Literal]
ReadPrec Literal
Int -> ReadS Literal
ReadS [Literal]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Literal]
$creadListPrec :: ReadPrec [Literal]
readPrec :: ReadPrec Literal
$creadPrec :: ReadPrec Literal
readList :: ReadS [Literal]
$creadList :: ReadS [Literal]
readsPrec :: Int -> ReadS Literal
$creadsPrec :: Int -> ReadS Literal
Read, Int -> Literal -> String -> String
[Literal] -> String -> String
Literal -> String
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Literal] -> String -> String
$cshowList :: [Literal] -> String -> String
show :: Literal -> String
$cshow :: Literal -> String
showsPrec :: Int -> Literal -> String -> String
$cshowsPrec :: Int -> Literal -> String -> String
Show)

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

_Literal_lexicalForm :: FieldName
_Literal_lexicalForm = (String -> FieldName
Core.FieldName String
"lexicalForm")

_Literal_datatypeIri :: FieldName
_Literal_datatypeIri = (String -> FieldName
Core.FieldName String
"datatypeIri")

_Literal_languageTag :: FieldName
_Literal_languageTag = (String -> FieldName
Core.FieldName String
"languageTag")

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

_Node :: Name
_Node = (String -> Name
Core.Name String
"hydra/ext/rdf/syntax.Node")

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

_Node_bnode :: FieldName
_Node_bnode = (String -> FieldName
Core.FieldName String
"bnode")

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

-- | A type representing an RDF property, and encapsulating its domain, range, and subclass relationships
data Property = 
  Property {
    -- | State that any resource that has a given property is an instance of one or more classes
    Property -> Set RdfsClass
propertyDomain :: (Set RdfsClass),
    -- | States that the values of a property are instances of one or more classes
    Property -> Set RdfsClass
propertyRange :: (Set RdfsClass),
    Property -> Set Property
propertySubPropertyOf :: (Set Property)}
  deriving (Property -> Property -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Property -> Property -> Bool
$c/= :: Property -> Property -> Bool
== :: Property -> Property -> Bool
$c== :: Property -> Property -> Bool
Eq, Eq Property
Property -> Property -> Bool
Property -> Property -> Ordering
Property -> Property -> Property
forall a.
Eq 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 :: Property -> Property -> Property
$cmin :: Property -> Property -> Property
max :: Property -> Property -> Property
$cmax :: Property -> Property -> Property
>= :: Property -> Property -> Bool
$c>= :: Property -> Property -> Bool
> :: Property -> Property -> Bool
$c> :: Property -> Property -> Bool
<= :: Property -> Property -> Bool
$c<= :: Property -> Property -> Bool
< :: Property -> Property -> Bool
$c< :: Property -> Property -> Bool
compare :: Property -> Property -> Ordering
$ccompare :: Property -> Property -> Ordering
Ord, ReadPrec [Property]
ReadPrec Property
Int -> ReadS Property
ReadS [Property]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Property]
$creadListPrec :: ReadPrec [Property]
readPrec :: ReadPrec Property
$creadPrec :: ReadPrec Property
readList :: ReadS [Property]
$creadList :: ReadS [Property]
readsPrec :: Int -> ReadS Property
$creadsPrec :: Int -> ReadS Property
Read, Int -> Property -> String -> String
[Property] -> String -> String
Property -> String
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Property] -> String -> String
$cshowList :: [Property] -> String -> String
show :: Property -> String
$cshow :: Property -> String
showsPrec :: Int -> Property -> String -> String
$cshowsPrec :: Int -> Property -> String -> String
Show)

_Property :: Name
_Property = (String -> Name
Core.Name String
"hydra/ext/rdf/syntax.Property")

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

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

_Property_subPropertyOf :: FieldName
_Property_subPropertyOf = (String -> FieldName
Core.FieldName String
"subPropertyOf")

-- | An RDF triple with an optional named graph component
data Quad = 
  Quad {
    Quad -> Resource
quadSubject :: Resource,
    Quad -> Iri
quadPredicate :: Iri,
    Quad -> Node
quadObject :: Node,
    Quad -> Maybe Iri
quadGraph :: (Maybe Iri)}
  deriving (Quad -> Quad -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Quad -> Quad -> Bool
$c/= :: Quad -> Quad -> Bool
== :: Quad -> Quad -> Bool
$c== :: Quad -> Quad -> Bool
Eq, Eq Quad
Quad -> Quad -> Bool
Quad -> Quad -> Ordering
Quad -> Quad -> Quad
forall a.
Eq 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 :: Quad -> Quad -> Quad
$cmin :: Quad -> Quad -> Quad
max :: Quad -> Quad -> Quad
$cmax :: Quad -> Quad -> Quad
>= :: Quad -> Quad -> Bool
$c>= :: Quad -> Quad -> Bool
> :: Quad -> Quad -> Bool
$c> :: Quad -> Quad -> Bool
<= :: Quad -> Quad -> Bool
$c<= :: Quad -> Quad -> Bool
< :: Quad -> Quad -> Bool
$c< :: Quad -> Quad -> Bool
compare :: Quad -> Quad -> Ordering
$ccompare :: Quad -> Quad -> Ordering
Ord, ReadPrec [Quad]
ReadPrec Quad
Int -> ReadS Quad
ReadS [Quad]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Quad]
$creadListPrec :: ReadPrec [Quad]
readPrec :: ReadPrec Quad
$creadPrec :: ReadPrec Quad
readList :: ReadS [Quad]
$creadList :: ReadS [Quad]
readsPrec :: Int -> ReadS Quad
$creadsPrec :: Int -> ReadS Quad
Read, Int -> Quad -> String -> String
[Quad] -> String -> String
Quad -> String
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Quad] -> String -> String
$cshowList :: [Quad] -> String -> String
show :: Quad -> String
$cshow :: Quad -> String
showsPrec :: Int -> Quad -> String -> String
$cshowsPrec :: Int -> Quad -> String -> String
Show)

_Quad :: Name
_Quad = (String -> Name
Core.Name String
"hydra/ext/rdf/syntax.Quad")

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

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

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

_Quad_graph :: FieldName
_Quad_graph = (String -> FieldName
Core.FieldName String
"graph")

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

_Resource :: Name
_Resource = (String -> Name
Core.Name String
"hydra/ext/rdf/syntax.Resource")

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

_Resource_bnode :: FieldName
_Resource_bnode = (String -> FieldName
Core.FieldName String
"bnode")

-- | An RDF triple defined by a subject, predicate, and object
data Triple = 
  Triple {
    Triple -> Resource
tripleSubject :: Resource,
    Triple -> Iri
triplePredicate :: Iri,
    Triple -> Node
tripleObject :: Node}
  deriving (Triple -> Triple -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Triple -> Triple -> Bool
$c/= :: Triple -> Triple -> Bool
== :: Triple -> Triple -> Bool
$c== :: Triple -> Triple -> Bool
Eq, Eq Triple
Triple -> Triple -> Bool
Triple -> Triple -> Ordering
Triple -> Triple -> Triple
forall a.
Eq 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 :: Triple -> Triple -> Triple
$cmin :: Triple -> Triple -> Triple
max :: Triple -> Triple -> Triple
$cmax :: Triple -> Triple -> Triple
>= :: Triple -> Triple -> Bool
$c>= :: Triple -> Triple -> Bool
> :: Triple -> Triple -> Bool
$c> :: Triple -> Triple -> Bool
<= :: Triple -> Triple -> Bool
$c<= :: Triple -> Triple -> Bool
< :: Triple -> Triple -> Bool
$c< :: Triple -> Triple -> Bool
compare :: Triple -> Triple -> Ordering
$ccompare :: Triple -> Triple -> Ordering
Ord, ReadPrec [Triple]
ReadPrec Triple
Int -> ReadS Triple
ReadS [Triple]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Triple]
$creadListPrec :: ReadPrec [Triple]
readPrec :: ReadPrec Triple
$creadPrec :: ReadPrec Triple
readList :: ReadS [Triple]
$creadList :: ReadS [Triple]
readsPrec :: Int -> ReadS Triple
$creadsPrec :: Int -> ReadS Triple
Read, Int -> Triple -> String -> String
[Triple] -> String -> String
Triple -> String
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Triple] -> String -> String
$cshowList :: [Triple] -> String -> String
show :: Triple -> String
$cshow :: Triple -> String
showsPrec :: Int -> Triple -> String -> String
$cshowsPrec :: Int -> Triple -> String -> String
Show)

_Triple :: Name
_Triple = (String -> Name
Core.Name String
"hydra/ext/rdf/syntax.Triple")

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

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

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