-- | An RDF 1.1 syntax model

module Hydra.Langs.Rdf.Syntax where

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

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

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

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

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

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

_Dataset :: Name
_Dataset = (String -> Name
Core.Name String
"hydra/langs/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
(Description -> Description -> Bool)
-> (Description -> Description -> Bool) -> Eq Description
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Description -> Description -> Bool
== :: Description -> Description -> Bool
$c/= :: Description -> Description -> Bool
/= :: Description -> Description -> Bool
Eq, Eq Description
Eq Description =>
(Description -> Description -> Ordering)
-> (Description -> Description -> Bool)
-> (Description -> Description -> Bool)
-> (Description -> Description -> Bool)
-> (Description -> Description -> Bool)
-> (Description -> Description -> Description)
-> (Description -> Description -> Description)
-> Ord 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
$ccompare :: Description -> Description -> Ordering
compare :: Description -> Description -> Ordering
$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
>= :: Description -> Description -> Bool
$cmax :: Description -> Description -> Description
max :: Description -> Description -> Description
$cmin :: Description -> Description -> Description
min :: Description -> Description -> Description
Ord, ReadPrec [Description]
ReadPrec Description
Int -> ReadS Description
ReadS [Description]
(Int -> ReadS Description)
-> ReadS [Description]
-> ReadPrec Description
-> ReadPrec [Description]
-> Read Description
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Description
readsPrec :: Int -> ReadS Description
$creadList :: ReadS [Description]
readList :: ReadS [Description]
$creadPrec :: ReadPrec Description
readPrec :: ReadPrec Description
$creadListPrec :: ReadPrec [Description]
readListPrec :: ReadPrec [Description]
Read, Int -> Description -> String -> String
[Description] -> String -> String
Description -> String
(Int -> Description -> String -> String)
-> (Description -> String)
-> ([Description] -> String -> String)
-> Show Description
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Description -> String -> String
showsPrec :: Int -> Description -> String -> String
$cshow :: Description -> String
show :: Description -> String
$cshowList :: [Description] -> String -> String
showList :: [Description] -> String -> String
Show)

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

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

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

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

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

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

_Iri :: Name
_Iri = (String -> Name
Core.Name String
"hydra/langs/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
(IriOrLiteral -> IriOrLiteral -> Bool)
-> (IriOrLiteral -> IriOrLiteral -> Bool) -> Eq IriOrLiteral
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: IriOrLiteral -> IriOrLiteral -> Bool
== :: IriOrLiteral -> IriOrLiteral -> Bool
$c/= :: IriOrLiteral -> IriOrLiteral -> Bool
/= :: IriOrLiteral -> IriOrLiteral -> Bool
Eq, Eq IriOrLiteral
Eq IriOrLiteral =>
(IriOrLiteral -> IriOrLiteral -> Ordering)
-> (IriOrLiteral -> IriOrLiteral -> Bool)
-> (IriOrLiteral -> IriOrLiteral -> Bool)
-> (IriOrLiteral -> IriOrLiteral -> Bool)
-> (IriOrLiteral -> IriOrLiteral -> Bool)
-> (IriOrLiteral -> IriOrLiteral -> IriOrLiteral)
-> (IriOrLiteral -> IriOrLiteral -> IriOrLiteral)
-> Ord 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
$ccompare :: IriOrLiteral -> IriOrLiteral -> Ordering
compare :: IriOrLiteral -> IriOrLiteral -> Ordering
$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
>= :: IriOrLiteral -> IriOrLiteral -> Bool
$cmax :: IriOrLiteral -> IriOrLiteral -> IriOrLiteral
max :: IriOrLiteral -> IriOrLiteral -> IriOrLiteral
$cmin :: IriOrLiteral -> IriOrLiteral -> IriOrLiteral
min :: IriOrLiteral -> IriOrLiteral -> IriOrLiteral
Ord, ReadPrec [IriOrLiteral]
ReadPrec IriOrLiteral
Int -> ReadS IriOrLiteral
ReadS [IriOrLiteral]
(Int -> ReadS IriOrLiteral)
-> ReadS [IriOrLiteral]
-> ReadPrec IriOrLiteral
-> ReadPrec [IriOrLiteral]
-> Read IriOrLiteral
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS IriOrLiteral
readsPrec :: Int -> ReadS IriOrLiteral
$creadList :: ReadS [IriOrLiteral]
readList :: ReadS [IriOrLiteral]
$creadPrec :: ReadPrec IriOrLiteral
readPrec :: ReadPrec IriOrLiteral
$creadListPrec :: ReadPrec [IriOrLiteral]
readListPrec :: ReadPrec [IriOrLiteral]
Read, Int -> IriOrLiteral -> String -> String
[IriOrLiteral] -> String -> String
IriOrLiteral -> String
(Int -> IriOrLiteral -> String -> String)
-> (IriOrLiteral -> String)
-> ([IriOrLiteral] -> String -> String)
-> Show IriOrLiteral
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> IriOrLiteral -> String -> String
showsPrec :: Int -> IriOrLiteral -> String -> String
$cshow :: IriOrLiteral -> String
show :: IriOrLiteral -> String
$cshowList :: [IriOrLiteral] -> String -> String
showList :: [IriOrLiteral] -> String -> String
Show)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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