{-# LANGUAGE DeriveDataTypeable #-}
{- |
Module      :  ./RDF/AS.hs
Copyright   :  (c) Felix Gabriel Mance, Francisc-Nicolae Bungiu
License     :  GPLv2 or higher, see LICENSE.txt

Maintainer  :  Christian.Maeder@dfki.de
Stability   :  provisional
Portability :  portable

RDF abstract syntax

References:
    <http://www.w3.org/TeamSubmission/turtle/>
    <http://www.informatik.uni-bremen.de/~till/papers/ontotrans.pdf>
    <http://www.w3.org/TR/rdf-concepts/#section-Graph-syntax>
-}

module RDF.AS where

import Common.Id
import Common.IRI
import qualified OWL2.AS as AS
import OWL2.ATC_OWL2 ()

import Data.Data
import Data.List
import qualified Data.Map as Map

-- * RDF Turtle Document

type RDFPrefixMap = Map.Map String IRI

data TurtleDocument = TurtleDocument
    { TurtleDocument -> IRI
documentName :: IRI
    , TurtleDocument -> RDFPrefixMap
prefixMap :: RDFPrefixMap
    , TurtleDocument -> [Statement]
statements :: [Statement] }
    deriving (Int -> TurtleDocument -> ShowS
[TurtleDocument] -> ShowS
TurtleDocument -> String
(Int -> TurtleDocument -> ShowS)
-> (TurtleDocument -> String)
-> ([TurtleDocument] -> ShowS)
-> Show TurtleDocument
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TurtleDocument] -> ShowS
$cshowList :: [TurtleDocument] -> ShowS
show :: TurtleDocument -> String
$cshow :: TurtleDocument -> String
showsPrec :: Int -> TurtleDocument -> ShowS
$cshowsPrec :: Int -> TurtleDocument -> ShowS
Show, TurtleDocument -> TurtleDocument -> Bool
(TurtleDocument -> TurtleDocument -> Bool)
-> (TurtleDocument -> TurtleDocument -> Bool) -> Eq TurtleDocument
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TurtleDocument -> TurtleDocument -> Bool
$c/= :: TurtleDocument -> TurtleDocument -> Bool
== :: TurtleDocument -> TurtleDocument -> Bool
$c== :: TurtleDocument -> TurtleDocument -> Bool
Eq, Eq TurtleDocument
Eq TurtleDocument =>
(TurtleDocument -> TurtleDocument -> Ordering)
-> (TurtleDocument -> TurtleDocument -> Bool)
-> (TurtleDocument -> TurtleDocument -> Bool)
-> (TurtleDocument -> TurtleDocument -> Bool)
-> (TurtleDocument -> TurtleDocument -> Bool)
-> (TurtleDocument -> TurtleDocument -> TurtleDocument)
-> (TurtleDocument -> TurtleDocument -> TurtleDocument)
-> Ord TurtleDocument
TurtleDocument -> TurtleDocument -> Bool
TurtleDocument -> TurtleDocument -> Ordering
TurtleDocument -> TurtleDocument -> TurtleDocument
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: TurtleDocument -> TurtleDocument -> TurtleDocument
$cmin :: TurtleDocument -> TurtleDocument -> TurtleDocument
max :: TurtleDocument -> TurtleDocument -> TurtleDocument
$cmax :: TurtleDocument -> TurtleDocument -> TurtleDocument
>= :: TurtleDocument -> TurtleDocument -> Bool
$c>= :: TurtleDocument -> TurtleDocument -> Bool
> :: TurtleDocument -> TurtleDocument -> Bool
$c> :: TurtleDocument -> TurtleDocument -> Bool
<= :: TurtleDocument -> TurtleDocument -> Bool
$c<= :: TurtleDocument -> TurtleDocument -> Bool
< :: TurtleDocument -> TurtleDocument -> Bool
$c< :: TurtleDocument -> TurtleDocument -> Bool
compare :: TurtleDocument -> TurtleDocument -> Ordering
$ccompare :: TurtleDocument -> TurtleDocument -> Ordering
$cp1Ord :: Eq TurtleDocument
Ord, Typeable, Typeable TurtleDocument
Constr
DataType
Typeable TurtleDocument =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> TurtleDocument -> c TurtleDocument)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TurtleDocument)
-> (TurtleDocument -> Constr)
-> (TurtleDocument -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TurtleDocument))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c TurtleDocument))
-> ((forall b. Data b => b -> b)
    -> TurtleDocument -> TurtleDocument)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TurtleDocument -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TurtleDocument -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> TurtleDocument -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> TurtleDocument -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> TurtleDocument -> m TurtleDocument)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> TurtleDocument -> m TurtleDocument)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> TurtleDocument -> m TurtleDocument)
-> Data TurtleDocument
TurtleDocument -> Constr
TurtleDocument -> DataType
(forall b. Data b => b -> b) -> TurtleDocument -> TurtleDocument
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TurtleDocument -> c TurtleDocument
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TurtleDocument
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> TurtleDocument -> u
forall u. (forall d. Data d => d -> u) -> TurtleDocument -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TurtleDocument -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TurtleDocument -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> TurtleDocument -> m TurtleDocument
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> TurtleDocument -> m TurtleDocument
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TurtleDocument
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TurtleDocument -> c TurtleDocument
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TurtleDocument)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TurtleDocument)
$cTurtleDocument :: Constr
$tTurtleDocument :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> TurtleDocument -> m TurtleDocument
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> TurtleDocument -> m TurtleDocument
gmapMp :: (forall d. Data d => d -> m d)
-> TurtleDocument -> m TurtleDocument
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> TurtleDocument -> m TurtleDocument
gmapM :: (forall d. Data d => d -> m d)
-> TurtleDocument -> m TurtleDocument
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> TurtleDocument -> m TurtleDocument
gmapQi :: Int -> (forall d. Data d => d -> u) -> TurtleDocument -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> TurtleDocument -> u
gmapQ :: (forall d. Data d => d -> u) -> TurtleDocument -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> TurtleDocument -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TurtleDocument -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TurtleDocument -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TurtleDocument -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TurtleDocument -> r
gmapT :: (forall b. Data b => b -> b) -> TurtleDocument -> TurtleDocument
$cgmapT :: (forall b. Data b => b -> b) -> TurtleDocument -> TurtleDocument
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TurtleDocument)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TurtleDocument)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c TurtleDocument)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TurtleDocument)
dataTypeOf :: TurtleDocument -> DataType
$cdataTypeOf :: TurtleDocument -> DataType
toConstr :: TurtleDocument -> Constr
$ctoConstr :: TurtleDocument -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TurtleDocument
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TurtleDocument
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TurtleDocument -> c TurtleDocument
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TurtleDocument -> c TurtleDocument
$cp1Data :: Typeable TurtleDocument
Data)

emptyTurtleDocument :: TurtleDocument
emptyTurtleDocument :: TurtleDocument
emptyTurtleDocument = IRI -> RDFPrefixMap -> [Statement] -> TurtleDocument
TurtleDocument IRI
nullIRI RDFPrefixMap
forall k a. Map k a
Map.empty []

data Statement = Statement Triples | PrefixStatement Prefix | BaseStatement Base
    deriving (Int -> Statement -> ShowS
[Statement] -> ShowS
Statement -> String
(Int -> Statement -> ShowS)
-> (Statement -> String)
-> ([Statement] -> ShowS)
-> Show Statement
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Statement] -> ShowS
$cshowList :: [Statement] -> ShowS
show :: Statement -> String
$cshow :: Statement -> String
showsPrec :: Int -> Statement -> ShowS
$cshowsPrec :: Int -> Statement -> ShowS
Show, Statement -> Statement -> Bool
(Statement -> Statement -> Bool)
-> (Statement -> Statement -> Bool) -> Eq Statement
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Statement -> Statement -> Bool
$c/= :: Statement -> Statement -> Bool
== :: Statement -> Statement -> Bool
$c== :: Statement -> Statement -> Bool
Eq, Eq Statement
Eq Statement =>
(Statement -> Statement -> Ordering)
-> (Statement -> Statement -> Bool)
-> (Statement -> Statement -> Bool)
-> (Statement -> Statement -> Bool)
-> (Statement -> Statement -> Bool)
-> (Statement -> Statement -> Statement)
-> (Statement -> Statement -> Statement)
-> Ord Statement
Statement -> Statement -> Bool
Statement -> Statement -> Ordering
Statement -> Statement -> Statement
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Statement -> Statement -> Statement
$cmin :: Statement -> Statement -> Statement
max :: Statement -> Statement -> Statement
$cmax :: Statement -> Statement -> Statement
>= :: Statement -> Statement -> Bool
$c>= :: Statement -> Statement -> Bool
> :: Statement -> Statement -> Bool
$c> :: Statement -> Statement -> Bool
<= :: Statement -> Statement -> Bool
$c<= :: Statement -> Statement -> Bool
< :: Statement -> Statement -> Bool
$c< :: Statement -> Statement -> Bool
compare :: Statement -> Statement -> Ordering
$ccompare :: Statement -> Statement -> Ordering
$cp1Ord :: Eq Statement
Ord, Typeable, Typeable Statement
Constr
DataType
Typeable Statement =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Statement -> c Statement)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Statement)
-> (Statement -> Constr)
-> (Statement -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Statement))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Statement))
-> ((forall b. Data b => b -> b) -> Statement -> Statement)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Statement -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Statement -> r)
-> (forall u. (forall d. Data d => d -> u) -> Statement -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Statement -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Statement -> m Statement)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Statement -> m Statement)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Statement -> m Statement)
-> Data Statement
Statement -> Constr
Statement -> DataType
(forall b. Data b => b -> b) -> Statement -> Statement
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Statement -> c Statement
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Statement
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Statement -> u
forall u. (forall d. Data d => d -> u) -> Statement -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Statement -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Statement -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Statement -> m Statement
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Statement -> m Statement
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Statement
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Statement -> c Statement
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Statement)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Statement)
$cBaseStatement :: Constr
$cPrefixStatement :: Constr
$cStatement :: Constr
$tStatement :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Statement -> m Statement
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Statement -> m Statement
gmapMp :: (forall d. Data d => d -> m d) -> Statement -> m Statement
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Statement -> m Statement
gmapM :: (forall d. Data d => d -> m d) -> Statement -> m Statement
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Statement -> m Statement
gmapQi :: Int -> (forall d. Data d => d -> u) -> Statement -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Statement -> u
gmapQ :: (forall d. Data d => d -> u) -> Statement -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Statement -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Statement -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Statement -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Statement -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Statement -> r
gmapT :: (forall b. Data b => b -> b) -> Statement -> Statement
$cgmapT :: (forall b. Data b => b -> b) -> Statement -> Statement
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Statement)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Statement)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Statement)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Statement)
dataTypeOf :: Statement -> DataType
$cdataTypeOf :: Statement -> DataType
toConstr :: Statement -> Constr
$ctoConstr :: Statement -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Statement
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Statement
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Statement -> c Statement
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Statement -> c Statement
$cp1Data :: Typeable Statement
Data)

data Prefix = PrefixR String IRI
    deriving (Int -> Prefix -> ShowS
[Prefix] -> ShowS
Prefix -> String
(Int -> Prefix -> ShowS)
-> (Prefix -> String) -> ([Prefix] -> ShowS) -> Show Prefix
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Prefix] -> ShowS
$cshowList :: [Prefix] -> ShowS
show :: Prefix -> String
$cshow :: Prefix -> String
showsPrec :: Int -> Prefix -> ShowS
$cshowsPrec :: Int -> Prefix -> ShowS
Show, Prefix -> Prefix -> Bool
(Prefix -> Prefix -> Bool)
-> (Prefix -> Prefix -> Bool) -> Eq Prefix
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Prefix -> Prefix -> Bool
$c/= :: Prefix -> Prefix -> Bool
== :: Prefix -> Prefix -> Bool
$c== :: Prefix -> Prefix -> Bool
Eq, Eq Prefix
Eq Prefix =>
(Prefix -> Prefix -> Ordering)
-> (Prefix -> Prefix -> Bool)
-> (Prefix -> Prefix -> Bool)
-> (Prefix -> Prefix -> Bool)
-> (Prefix -> Prefix -> Bool)
-> (Prefix -> Prefix -> Prefix)
-> (Prefix -> Prefix -> Prefix)
-> Ord Prefix
Prefix -> Prefix -> Bool
Prefix -> Prefix -> Ordering
Prefix -> Prefix -> Prefix
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Prefix -> Prefix -> Prefix
$cmin :: Prefix -> Prefix -> Prefix
max :: Prefix -> Prefix -> Prefix
$cmax :: Prefix -> Prefix -> Prefix
>= :: Prefix -> Prefix -> Bool
$c>= :: Prefix -> Prefix -> Bool
> :: Prefix -> Prefix -> Bool
$c> :: Prefix -> Prefix -> Bool
<= :: Prefix -> Prefix -> Bool
$c<= :: Prefix -> Prefix -> Bool
< :: Prefix -> Prefix -> Bool
$c< :: Prefix -> Prefix -> Bool
compare :: Prefix -> Prefix -> Ordering
$ccompare :: Prefix -> Prefix -> Ordering
$cp1Ord :: Eq Prefix
Ord, Typeable, Typeable Prefix
Constr
DataType
Typeable Prefix =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Prefix -> c Prefix)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Prefix)
-> (Prefix -> Constr)
-> (Prefix -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Prefix))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Prefix))
-> ((forall b. Data b => b -> b) -> Prefix -> Prefix)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Prefix -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Prefix -> r)
-> (forall u. (forall d. Data d => d -> u) -> Prefix -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Prefix -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Prefix -> m Prefix)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Prefix -> m Prefix)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Prefix -> m Prefix)
-> Data Prefix
Prefix -> Constr
Prefix -> DataType
(forall b. Data b => b -> b) -> Prefix -> Prefix
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Prefix -> c Prefix
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Prefix
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Prefix -> u
forall u. (forall d. Data d => d -> u) -> Prefix -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Prefix -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Prefix -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Prefix -> m Prefix
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Prefix -> m Prefix
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Prefix
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Prefix -> c Prefix
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Prefix)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Prefix)
$cPrefixR :: Constr
$tPrefix :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Prefix -> m Prefix
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Prefix -> m Prefix
gmapMp :: (forall d. Data d => d -> m d) -> Prefix -> m Prefix
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Prefix -> m Prefix
gmapM :: (forall d. Data d => d -> m d) -> Prefix -> m Prefix
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Prefix -> m Prefix
gmapQi :: Int -> (forall d. Data d => d -> u) -> Prefix -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Prefix -> u
gmapQ :: (forall d. Data d => d -> u) -> Prefix -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Prefix -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Prefix -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Prefix -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Prefix -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Prefix -> r
gmapT :: (forall b. Data b => b -> b) -> Prefix -> Prefix
$cgmapT :: (forall b. Data b => b -> b) -> Prefix -> Prefix
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Prefix)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Prefix)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Prefix)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Prefix)
dataTypeOf :: Prefix -> DataType
$cdataTypeOf :: Prefix -> DataType
toConstr :: Prefix -> Constr
$ctoConstr :: Prefix -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Prefix
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Prefix
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Prefix -> c Prefix
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Prefix -> c Prefix
$cp1Data :: Typeable Prefix
Data)

data Base = Base IRI
    deriving (Int -> Base -> ShowS
[Base] -> ShowS
Base -> String
(Int -> Base -> ShowS)
-> (Base -> String) -> ([Base] -> ShowS) -> Show Base
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Base] -> ShowS
$cshowList :: [Base] -> ShowS
show :: Base -> String
$cshow :: Base -> String
showsPrec :: Int -> Base -> ShowS
$cshowsPrec :: Int -> Base -> ShowS
Show, Base -> Base -> Bool
(Base -> Base -> Bool) -> (Base -> Base -> Bool) -> Eq Base
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Base -> Base -> Bool
$c/= :: Base -> Base -> Bool
== :: Base -> Base -> Bool
$c== :: Base -> Base -> Bool
Eq, Eq Base
Eq Base =>
(Base -> Base -> Ordering)
-> (Base -> Base -> Bool)
-> (Base -> Base -> Bool)
-> (Base -> Base -> Bool)
-> (Base -> Base -> Bool)
-> (Base -> Base -> Base)
-> (Base -> Base -> Base)
-> Ord Base
Base -> Base -> Bool
Base -> Base -> Ordering
Base -> Base -> Base
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Base -> Base -> Base
$cmin :: Base -> Base -> Base
max :: Base -> Base -> Base
$cmax :: Base -> Base -> Base
>= :: Base -> Base -> Bool
$c>= :: Base -> Base -> Bool
> :: Base -> Base -> Bool
$c> :: Base -> Base -> Bool
<= :: Base -> Base -> Bool
$c<= :: Base -> Base -> Bool
< :: Base -> Base -> Bool
$c< :: Base -> Base -> Bool
compare :: Base -> Base -> Ordering
$ccompare :: Base -> Base -> Ordering
$cp1Ord :: Eq Base
Ord, Typeable, Typeable Base
Constr
DataType
Typeable Base =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Base -> c Base)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Base)
-> (Base -> Constr)
-> (Base -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Base))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Base))
-> ((forall b. Data b => b -> b) -> Base -> Base)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Base -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Base -> r)
-> (forall u. (forall d. Data d => d -> u) -> Base -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Base -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Base -> m Base)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Base -> m Base)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Base -> m Base)
-> Data Base
Base -> Constr
Base -> DataType
(forall b. Data b => b -> b) -> Base -> Base
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Base -> c Base
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Base
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Base -> u
forall u. (forall d. Data d => d -> u) -> Base -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Base -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Base -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Base -> m Base
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Base -> m Base
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Base
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Base -> c Base
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Base)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Base)
$cBase :: Constr
$tBase :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Base -> m Base
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Base -> m Base
gmapMp :: (forall d. Data d => d -> m d) -> Base -> m Base
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Base -> m Base
gmapM :: (forall d. Data d => d -> m d) -> Base -> m Base
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Base -> m Base
gmapQi :: Int -> (forall d. Data d => d -> u) -> Base -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Base -> u
gmapQ :: (forall d. Data d => d -> u) -> Base -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Base -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Base -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Base -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Base -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Base -> r
gmapT :: (forall b. Data b => b -> b) -> Base -> Base
$cgmapT :: (forall b. Data b => b -> b) -> Base -> Base
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Base)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Base)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Base)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Base)
dataTypeOf :: Base -> DataType
$cdataTypeOf :: Base -> DataType
toConstr :: Base -> Constr
$ctoConstr :: Base -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Base
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Base
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Base -> c Base
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Base -> c Base
$cp1Data :: Typeable Base
Data)

data Triples = Triples Subject [PredicateObjectList]
    deriving (Int -> Triples -> ShowS
[Triples] -> ShowS
Triples -> String
(Int -> Triples -> ShowS)
-> (Triples -> String) -> ([Triples] -> ShowS) -> Show Triples
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Triples] -> ShowS
$cshowList :: [Triples] -> ShowS
show :: Triples -> String
$cshow :: Triples -> String
showsPrec :: Int -> Triples -> ShowS
$cshowsPrec :: Int -> Triples -> ShowS
Show, Triples -> Triples -> Bool
(Triples -> Triples -> Bool)
-> (Triples -> Triples -> Bool) -> Eq Triples
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Triples -> Triples -> Bool
$c/= :: Triples -> Triples -> Bool
== :: Triples -> Triples -> Bool
$c== :: Triples -> Triples -> Bool
Eq, Eq Triples
Eq Triples =>
(Triples -> Triples -> Ordering)
-> (Triples -> Triples -> Bool)
-> (Triples -> Triples -> Bool)
-> (Triples -> Triples -> Bool)
-> (Triples -> Triples -> Bool)
-> (Triples -> Triples -> Triples)
-> (Triples -> Triples -> Triples)
-> Ord Triples
Triples -> Triples -> Bool
Triples -> Triples -> Ordering
Triples -> Triples -> Triples
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Triples -> Triples -> Triples
$cmin :: Triples -> Triples -> Triples
max :: Triples -> Triples -> Triples
$cmax :: Triples -> Triples -> Triples
>= :: Triples -> Triples -> Bool
$c>= :: Triples -> Triples -> Bool
> :: Triples -> Triples -> Bool
$c> :: Triples -> Triples -> Bool
<= :: Triples -> Triples -> Bool
$c<= :: Triples -> Triples -> Bool
< :: Triples -> Triples -> Bool
$c< :: Triples -> Triples -> Bool
compare :: Triples -> Triples -> Ordering
$ccompare :: Triples -> Triples -> Ordering
$cp1Ord :: Eq Triples
Ord, Typeable, Typeable Triples
Constr
DataType
Typeable Triples =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Triples -> c Triples)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Triples)
-> (Triples -> Constr)
-> (Triples -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Triples))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Triples))
-> ((forall b. Data b => b -> b) -> Triples -> Triples)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Triples -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Triples -> r)
-> (forall u. (forall d. Data d => d -> u) -> Triples -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Triples -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Triples -> m Triples)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Triples -> m Triples)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Triples -> m Triples)
-> Data Triples
Triples -> Constr
Triples -> DataType
(forall b. Data b => b -> b) -> Triples -> Triples
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Triples -> c Triples
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Triples
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Triples -> u
forall u. (forall d. Data d => d -> u) -> Triples -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Triples -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Triples -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Triples -> m Triples
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Triples -> m Triples
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Triples
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Triples -> c Triples
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Triples)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Triples)
$cTriples :: Constr
$tTriples :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Triples -> m Triples
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Triples -> m Triples
gmapMp :: (forall d. Data d => d -> m d) -> Triples -> m Triples
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Triples -> m Triples
gmapM :: (forall d. Data d => d -> m d) -> Triples -> m Triples
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Triples -> m Triples
gmapQi :: Int -> (forall d. Data d => d -> u) -> Triples -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Triples -> u
gmapQ :: (forall d. Data d => d -> u) -> Triples -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Triples -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Triples -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Triples -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Triples -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Triples -> r
gmapT :: (forall b. Data b => b -> b) -> Triples -> Triples
$cgmapT :: (forall b. Data b => b -> b) -> Triples -> Triples
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Triples)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Triples)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Triples)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Triples)
dataTypeOf :: Triples -> DataType
$cdataTypeOf :: Triples -> DataType
toConstr :: Triples -> Constr
$ctoConstr :: Triples -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Triples
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Triples
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Triples -> c Triples
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Triples -> c Triples
$cp1Data :: Typeable Triples
Data)

data Subject =
    Subject IRI
  | SubjectList [PredicateObjectList]
  | SubjectCollection [Object]
    deriving (Int -> Subject -> ShowS
[Subject] -> ShowS
Subject -> String
(Int -> Subject -> ShowS)
-> (Subject -> String) -> ([Subject] -> ShowS) -> Show Subject
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Subject] -> ShowS
$cshowList :: [Subject] -> ShowS
show :: Subject -> String
$cshow :: Subject -> String
showsPrec :: Int -> Subject -> ShowS
$cshowsPrec :: Int -> Subject -> ShowS
Show, Subject -> Subject -> Bool
(Subject -> Subject -> Bool)
-> (Subject -> Subject -> Bool) -> Eq Subject
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Subject -> Subject -> Bool
$c/= :: Subject -> Subject -> Bool
== :: Subject -> Subject -> Bool
$c== :: Subject -> Subject -> Bool
Eq, Eq Subject
Eq Subject =>
(Subject -> Subject -> Ordering)
-> (Subject -> Subject -> Bool)
-> (Subject -> Subject -> Bool)
-> (Subject -> Subject -> Bool)
-> (Subject -> Subject -> Bool)
-> (Subject -> Subject -> Subject)
-> (Subject -> Subject -> Subject)
-> Ord Subject
Subject -> Subject -> Bool
Subject -> Subject -> Ordering
Subject -> Subject -> Subject
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Subject -> Subject -> Subject
$cmin :: Subject -> Subject -> Subject
max :: Subject -> Subject -> Subject
$cmax :: Subject -> Subject -> Subject
>= :: Subject -> Subject -> Bool
$c>= :: Subject -> Subject -> Bool
> :: Subject -> Subject -> Bool
$c> :: Subject -> Subject -> Bool
<= :: Subject -> Subject -> Bool
$c<= :: Subject -> Subject -> Bool
< :: Subject -> Subject -> Bool
$c< :: Subject -> Subject -> Bool
compare :: Subject -> Subject -> Ordering
$ccompare :: Subject -> Subject -> Ordering
$cp1Ord :: Eq Subject
Ord, Typeable, Typeable Subject
Constr
DataType
Typeable Subject =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Subject -> c Subject)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Subject)
-> (Subject -> Constr)
-> (Subject -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Subject))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Subject))
-> ((forall b. Data b => b -> b) -> Subject -> Subject)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Subject -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Subject -> r)
-> (forall u. (forall d. Data d => d -> u) -> Subject -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Subject -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Subject -> m Subject)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Subject -> m Subject)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Subject -> m Subject)
-> Data Subject
Subject -> Constr
Subject -> DataType
(forall b. Data b => b -> b) -> Subject -> Subject
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Subject -> c Subject
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Subject
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Subject -> u
forall u. (forall d. Data d => d -> u) -> Subject -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Subject -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Subject -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Subject -> m Subject
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Subject -> m Subject
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Subject
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Subject -> c Subject
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Subject)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Subject)
$cSubjectCollection :: Constr
$cSubjectList :: Constr
$cSubject :: Constr
$tSubject :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Subject -> m Subject
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Subject -> m Subject
gmapMp :: (forall d. Data d => d -> m d) -> Subject -> m Subject
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Subject -> m Subject
gmapM :: (forall d. Data d => d -> m d) -> Subject -> m Subject
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Subject -> m Subject
gmapQi :: Int -> (forall d. Data d => d -> u) -> Subject -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Subject -> u
gmapQ :: (forall d. Data d => d -> u) -> Subject -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Subject -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Subject -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Subject -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Subject -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Subject -> r
gmapT :: (forall b. Data b => b -> b) -> Subject -> Subject
$cgmapT :: (forall b. Data b => b -> b) -> Subject -> Subject
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Subject)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Subject)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Subject)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Subject)
dataTypeOf :: Subject -> DataType
$cdataTypeOf :: Subject -> DataType
toConstr :: Subject -> Constr
$ctoConstr :: Subject -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Subject
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Subject
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Subject -> c Subject
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Subject -> c Subject
$cp1Data :: Typeable Subject
Data)

data Predicate = Predicate IRI
    deriving (Int -> Predicate -> ShowS
[Predicate] -> ShowS
Predicate -> String
(Int -> Predicate -> ShowS)
-> (Predicate -> String)
-> ([Predicate] -> ShowS)
-> Show Predicate
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Predicate] -> ShowS
$cshowList :: [Predicate] -> ShowS
show :: Predicate -> String
$cshow :: Predicate -> String
showsPrec :: Int -> Predicate -> ShowS
$cshowsPrec :: Int -> Predicate -> ShowS
Show, Predicate -> Predicate -> Bool
(Predicate -> Predicate -> Bool)
-> (Predicate -> Predicate -> Bool) -> Eq Predicate
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Predicate -> Predicate -> Bool
$c/= :: Predicate -> Predicate -> Bool
== :: Predicate -> Predicate -> Bool
$c== :: Predicate -> Predicate -> Bool
Eq, Eq Predicate
Eq Predicate =>
(Predicate -> Predicate -> Ordering)
-> (Predicate -> Predicate -> Bool)
-> (Predicate -> Predicate -> Bool)
-> (Predicate -> Predicate -> Bool)
-> (Predicate -> Predicate -> Bool)
-> (Predicate -> Predicate -> Predicate)
-> (Predicate -> Predicate -> Predicate)
-> Ord Predicate
Predicate -> Predicate -> Bool
Predicate -> Predicate -> Ordering
Predicate -> Predicate -> Predicate
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Predicate -> Predicate -> Predicate
$cmin :: Predicate -> Predicate -> Predicate
max :: Predicate -> Predicate -> Predicate
$cmax :: Predicate -> Predicate -> Predicate
>= :: Predicate -> Predicate -> Bool
$c>= :: Predicate -> Predicate -> Bool
> :: Predicate -> Predicate -> Bool
$c> :: Predicate -> Predicate -> Bool
<= :: Predicate -> Predicate -> Bool
$c<= :: Predicate -> Predicate -> Bool
< :: Predicate -> Predicate -> Bool
$c< :: Predicate -> Predicate -> Bool
compare :: Predicate -> Predicate -> Ordering
$ccompare :: Predicate -> Predicate -> Ordering
$cp1Ord :: Eq Predicate
Ord, Typeable, Typeable Predicate
Constr
DataType
Typeable Predicate =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Predicate -> c Predicate)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Predicate)
-> (Predicate -> Constr)
-> (Predicate -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Predicate))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Predicate))
-> ((forall b. Data b => b -> b) -> Predicate -> Predicate)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Predicate -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Predicate -> r)
-> (forall u. (forall d. Data d => d -> u) -> Predicate -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Predicate -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Predicate -> m Predicate)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Predicate -> m Predicate)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Predicate -> m Predicate)
-> Data Predicate
Predicate -> Constr
Predicate -> DataType
(forall b. Data b => b -> b) -> Predicate -> Predicate
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Predicate -> c Predicate
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Predicate
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Predicate -> u
forall u. (forall d. Data d => d -> u) -> Predicate -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Predicate -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Predicate -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Predicate -> m Predicate
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Predicate -> m Predicate
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Predicate
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Predicate -> c Predicate
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Predicate)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Predicate)
$cPredicate :: Constr
$tPredicate :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Predicate -> m Predicate
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Predicate -> m Predicate
gmapMp :: (forall d. Data d => d -> m d) -> Predicate -> m Predicate
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Predicate -> m Predicate
gmapM :: (forall d. Data d => d -> m d) -> Predicate -> m Predicate
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Predicate -> m Predicate
gmapQi :: Int -> (forall d. Data d => d -> u) -> Predicate -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Predicate -> u
gmapQ :: (forall d. Data d => d -> u) -> Predicate -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Predicate -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Predicate -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Predicate -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Predicate -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Predicate -> r
gmapT :: (forall b. Data b => b -> b) -> Predicate -> Predicate
$cgmapT :: (forall b. Data b => b -> b) -> Predicate -> Predicate
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Predicate)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Predicate)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Predicate)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Predicate)
dataTypeOf :: Predicate -> DataType
$cdataTypeOf :: Predicate -> DataType
toConstr :: Predicate -> Constr
$ctoConstr :: Predicate -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Predicate
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Predicate
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Predicate -> c Predicate
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Predicate -> c Predicate
$cp1Data :: Typeable Predicate
Data)

data Object = Object Subject
  | ObjectLiteral RDFLiteral
    deriving (Int -> Object -> ShowS
[Object] -> ShowS
Object -> String
(Int -> Object -> ShowS)
-> (Object -> String) -> ([Object] -> ShowS) -> Show Object
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Object] -> ShowS
$cshowList :: [Object] -> ShowS
show :: Object -> String
$cshow :: Object -> String
showsPrec :: Int -> Object -> ShowS
$cshowsPrec :: Int -> Object -> ShowS
Show, Object -> Object -> Bool
(Object -> Object -> Bool)
-> (Object -> Object -> Bool) -> Eq Object
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Object -> Object -> Bool
$c/= :: Object -> Object -> Bool
== :: Object -> Object -> Bool
$c== :: Object -> Object -> Bool
Eq, Eq Object
Eq Object =>
(Object -> Object -> Ordering)
-> (Object -> Object -> Bool)
-> (Object -> Object -> Bool)
-> (Object -> Object -> Bool)
-> (Object -> Object -> Bool)
-> (Object -> Object -> Object)
-> (Object -> Object -> Object)
-> Ord Object
Object -> Object -> Bool
Object -> Object -> Ordering
Object -> Object -> Object
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Object -> Object -> Object
$cmin :: Object -> Object -> Object
max :: Object -> Object -> Object
$cmax :: Object -> Object -> Object
>= :: Object -> Object -> Bool
$c>= :: Object -> Object -> Bool
> :: Object -> Object -> Bool
$c> :: Object -> Object -> Bool
<= :: Object -> Object -> Bool
$c<= :: Object -> Object -> Bool
< :: Object -> Object -> Bool
$c< :: Object -> Object -> Bool
compare :: Object -> Object -> Ordering
$ccompare :: Object -> Object -> Ordering
$cp1Ord :: Eq Object
Ord, Typeable, Typeable Object
Constr
DataType
Typeable Object =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Object -> c Object)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Object)
-> (Object -> Constr)
-> (Object -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Object))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Object))
-> ((forall b. Data b => b -> b) -> Object -> Object)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Object -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Object -> r)
-> (forall u. (forall d. Data d => d -> u) -> Object -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Object -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Object -> m Object)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Object -> m Object)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Object -> m Object)
-> Data Object
Object -> Constr
Object -> DataType
(forall b. Data b => b -> b) -> Object -> Object
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Object -> c Object
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Object
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Object -> u
forall u. (forall d. Data d => d -> u) -> Object -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Object -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Object -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Object -> m Object
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Object -> m Object
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Object
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Object -> c Object
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Object)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Object)
$cObjectLiteral :: Constr
$cObject :: Constr
$tObject :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Object -> m Object
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Object -> m Object
gmapMp :: (forall d. Data d => d -> m d) -> Object -> m Object
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Object -> m Object
gmapM :: (forall d. Data d => d -> m d) -> Object -> m Object
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Object -> m Object
gmapQi :: Int -> (forall d. Data d => d -> u) -> Object -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Object -> u
gmapQ :: (forall d. Data d => d -> u) -> Object -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Object -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Object -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Object -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Object -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Object -> r
gmapT :: (forall b. Data b => b -> b) -> Object -> Object
$cgmapT :: (forall b. Data b => b -> b) -> Object -> Object
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Object)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Object)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Object)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Object)
dataTypeOf :: Object -> DataType
$cdataTypeOf :: Object -> DataType
toConstr :: Object -> Constr
$ctoConstr :: Object -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Object
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Object
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Object -> c Object
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Object -> c Object
$cp1Data :: Typeable Object
Data)

data PredicateObjectList = PredicateObjectList Predicate [Object]
    deriving (Int -> PredicateObjectList -> ShowS
[PredicateObjectList] -> ShowS
PredicateObjectList -> String
(Int -> PredicateObjectList -> ShowS)
-> (PredicateObjectList -> String)
-> ([PredicateObjectList] -> ShowS)
-> Show PredicateObjectList
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PredicateObjectList] -> ShowS
$cshowList :: [PredicateObjectList] -> ShowS
show :: PredicateObjectList -> String
$cshow :: PredicateObjectList -> String
showsPrec :: Int -> PredicateObjectList -> ShowS
$cshowsPrec :: Int -> PredicateObjectList -> ShowS
Show, PredicateObjectList -> PredicateObjectList -> Bool
(PredicateObjectList -> PredicateObjectList -> Bool)
-> (PredicateObjectList -> PredicateObjectList -> Bool)
-> Eq PredicateObjectList
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PredicateObjectList -> PredicateObjectList -> Bool
$c/= :: PredicateObjectList -> PredicateObjectList -> Bool
== :: PredicateObjectList -> PredicateObjectList -> Bool
$c== :: PredicateObjectList -> PredicateObjectList -> Bool
Eq, Eq PredicateObjectList
Eq PredicateObjectList =>
(PredicateObjectList -> PredicateObjectList -> Ordering)
-> (PredicateObjectList -> PredicateObjectList -> Bool)
-> (PredicateObjectList -> PredicateObjectList -> Bool)
-> (PredicateObjectList -> PredicateObjectList -> Bool)
-> (PredicateObjectList -> PredicateObjectList -> Bool)
-> (PredicateObjectList
    -> PredicateObjectList -> PredicateObjectList)
-> (PredicateObjectList
    -> PredicateObjectList -> PredicateObjectList)
-> Ord PredicateObjectList
PredicateObjectList -> PredicateObjectList -> Bool
PredicateObjectList -> PredicateObjectList -> Ordering
PredicateObjectList -> PredicateObjectList -> PredicateObjectList
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: PredicateObjectList -> PredicateObjectList -> PredicateObjectList
$cmin :: PredicateObjectList -> PredicateObjectList -> PredicateObjectList
max :: PredicateObjectList -> PredicateObjectList -> PredicateObjectList
$cmax :: PredicateObjectList -> PredicateObjectList -> PredicateObjectList
>= :: PredicateObjectList -> PredicateObjectList -> Bool
$c>= :: PredicateObjectList -> PredicateObjectList -> Bool
> :: PredicateObjectList -> PredicateObjectList -> Bool
$c> :: PredicateObjectList -> PredicateObjectList -> Bool
<= :: PredicateObjectList -> PredicateObjectList -> Bool
$c<= :: PredicateObjectList -> PredicateObjectList -> Bool
< :: PredicateObjectList -> PredicateObjectList -> Bool
$c< :: PredicateObjectList -> PredicateObjectList -> Bool
compare :: PredicateObjectList -> PredicateObjectList -> Ordering
$ccompare :: PredicateObjectList -> PredicateObjectList -> Ordering
$cp1Ord :: Eq PredicateObjectList
Ord, Typeable, Typeable PredicateObjectList
Constr
DataType
Typeable PredicateObjectList =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> PredicateObjectList
 -> c PredicateObjectList)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c PredicateObjectList)
-> (PredicateObjectList -> Constr)
-> (PredicateObjectList -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c PredicateObjectList))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c PredicateObjectList))
-> ((forall b. Data b => b -> b)
    -> PredicateObjectList -> PredicateObjectList)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> PredicateObjectList -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> PredicateObjectList -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> PredicateObjectList -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> PredicateObjectList -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> PredicateObjectList -> m PredicateObjectList)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> PredicateObjectList -> m PredicateObjectList)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> PredicateObjectList -> m PredicateObjectList)
-> Data PredicateObjectList
PredicateObjectList -> Constr
PredicateObjectList -> DataType
(forall b. Data b => b -> b)
-> PredicateObjectList -> PredicateObjectList
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> PredicateObjectList
-> c PredicateObjectList
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PredicateObjectList
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> PredicateObjectList -> u
forall u.
(forall d. Data d => d -> u) -> PredicateObjectList -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PredicateObjectList -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PredicateObjectList -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> PredicateObjectList -> m PredicateObjectList
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> PredicateObjectList -> m PredicateObjectList
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PredicateObjectList
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> PredicateObjectList
-> c PredicateObjectList
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PredicateObjectList)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c PredicateObjectList)
$cPredicateObjectList :: Constr
$tPredicateObjectList :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> PredicateObjectList -> m PredicateObjectList
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> PredicateObjectList -> m PredicateObjectList
gmapMp :: (forall d. Data d => d -> m d)
-> PredicateObjectList -> m PredicateObjectList
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> PredicateObjectList -> m PredicateObjectList
gmapM :: (forall d. Data d => d -> m d)
-> PredicateObjectList -> m PredicateObjectList
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> PredicateObjectList -> m PredicateObjectList
gmapQi :: Int -> (forall d. Data d => d -> u) -> PredicateObjectList -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> PredicateObjectList -> u
gmapQ :: (forall d. Data d => d -> u) -> PredicateObjectList -> [u]
$cgmapQ :: forall u.
(forall d. Data d => d -> u) -> PredicateObjectList -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PredicateObjectList -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PredicateObjectList -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PredicateObjectList -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PredicateObjectList -> r
gmapT :: (forall b. Data b => b -> b)
-> PredicateObjectList -> PredicateObjectList
$cgmapT :: (forall b. Data b => b -> b)
-> PredicateObjectList -> PredicateObjectList
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c PredicateObjectList)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c PredicateObjectList)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c PredicateObjectList)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PredicateObjectList)
dataTypeOf :: PredicateObjectList -> DataType
$cdataTypeOf :: PredicateObjectList -> DataType
toConstr :: PredicateObjectList -> Constr
$ctoConstr :: PredicateObjectList -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PredicateObjectList
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PredicateObjectList
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> PredicateObjectList
-> c PredicateObjectList
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> PredicateObjectList
-> c PredicateObjectList
$cp1Data :: Typeable PredicateObjectList
Data)

data RDFLiteral = RDFLiteral Bool AS.LexicalForm AS.TypedOrUntyped
  | RDFNumberLit AS.FloatLit
    deriving (Int -> RDFLiteral -> ShowS
[RDFLiteral] -> ShowS
RDFLiteral -> String
(Int -> RDFLiteral -> ShowS)
-> (RDFLiteral -> String)
-> ([RDFLiteral] -> ShowS)
-> Show RDFLiteral
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RDFLiteral] -> ShowS
$cshowList :: [RDFLiteral] -> ShowS
show :: RDFLiteral -> String
$cshow :: RDFLiteral -> String
showsPrec :: Int -> RDFLiteral -> ShowS
$cshowsPrec :: Int -> RDFLiteral -> ShowS
Show, RDFLiteral -> RDFLiteral -> Bool
(RDFLiteral -> RDFLiteral -> Bool)
-> (RDFLiteral -> RDFLiteral -> Bool) -> Eq RDFLiteral
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RDFLiteral -> RDFLiteral -> Bool
$c/= :: RDFLiteral -> RDFLiteral -> Bool
== :: RDFLiteral -> RDFLiteral -> Bool
$c== :: RDFLiteral -> RDFLiteral -> Bool
Eq, Eq RDFLiteral
Eq RDFLiteral =>
(RDFLiteral -> RDFLiteral -> Ordering)
-> (RDFLiteral -> RDFLiteral -> Bool)
-> (RDFLiteral -> RDFLiteral -> Bool)
-> (RDFLiteral -> RDFLiteral -> Bool)
-> (RDFLiteral -> RDFLiteral -> Bool)
-> (RDFLiteral -> RDFLiteral -> RDFLiteral)
-> (RDFLiteral -> RDFLiteral -> RDFLiteral)
-> Ord RDFLiteral
RDFLiteral -> RDFLiteral -> Bool
RDFLiteral -> RDFLiteral -> Ordering
RDFLiteral -> RDFLiteral -> RDFLiteral
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: RDFLiteral -> RDFLiteral -> RDFLiteral
$cmin :: RDFLiteral -> RDFLiteral -> RDFLiteral
max :: RDFLiteral -> RDFLiteral -> RDFLiteral
$cmax :: RDFLiteral -> RDFLiteral -> RDFLiteral
>= :: RDFLiteral -> RDFLiteral -> Bool
$c>= :: RDFLiteral -> RDFLiteral -> Bool
> :: RDFLiteral -> RDFLiteral -> Bool
$c> :: RDFLiteral -> RDFLiteral -> Bool
<= :: RDFLiteral -> RDFLiteral -> Bool
$c<= :: RDFLiteral -> RDFLiteral -> Bool
< :: RDFLiteral -> RDFLiteral -> Bool
$c< :: RDFLiteral -> RDFLiteral -> Bool
compare :: RDFLiteral -> RDFLiteral -> Ordering
$ccompare :: RDFLiteral -> RDFLiteral -> Ordering
$cp1Ord :: Eq RDFLiteral
Ord, Typeable, Typeable RDFLiteral
Constr
DataType
Typeable RDFLiteral =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> RDFLiteral -> c RDFLiteral)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c RDFLiteral)
-> (RDFLiteral -> Constr)
-> (RDFLiteral -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c RDFLiteral))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c RDFLiteral))
-> ((forall b. Data b => b -> b) -> RDFLiteral -> RDFLiteral)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> RDFLiteral -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> RDFLiteral -> r)
-> (forall u. (forall d. Data d => d -> u) -> RDFLiteral -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> RDFLiteral -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> RDFLiteral -> m RDFLiteral)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RDFLiteral -> m RDFLiteral)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RDFLiteral -> m RDFLiteral)
-> Data RDFLiteral
RDFLiteral -> Constr
RDFLiteral -> DataType
(forall b. Data b => b -> b) -> RDFLiteral -> RDFLiteral
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RDFLiteral -> c RDFLiteral
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RDFLiteral
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> RDFLiteral -> u
forall u. (forall d. Data d => d -> u) -> RDFLiteral -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RDFLiteral -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RDFLiteral -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RDFLiteral -> m RDFLiteral
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RDFLiteral -> m RDFLiteral
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RDFLiteral
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RDFLiteral -> c RDFLiteral
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RDFLiteral)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RDFLiteral)
$cRDFNumberLit :: Constr
$cRDFLiteral :: Constr
$tRDFLiteral :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> RDFLiteral -> m RDFLiteral
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RDFLiteral -> m RDFLiteral
gmapMp :: (forall d. Data d => d -> m d) -> RDFLiteral -> m RDFLiteral
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RDFLiteral -> m RDFLiteral
gmapM :: (forall d. Data d => d -> m d) -> RDFLiteral -> m RDFLiteral
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RDFLiteral -> m RDFLiteral
gmapQi :: Int -> (forall d. Data d => d -> u) -> RDFLiteral -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> RDFLiteral -> u
gmapQ :: (forall d. Data d => d -> u) -> RDFLiteral -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> RDFLiteral -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RDFLiteral -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RDFLiteral -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RDFLiteral -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RDFLiteral -> r
gmapT :: (forall b. Data b => b -> b) -> RDFLiteral -> RDFLiteral
$cgmapT :: (forall b. Data b => b -> b) -> RDFLiteral -> RDFLiteral
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RDFLiteral)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RDFLiteral)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c RDFLiteral)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RDFLiteral)
dataTypeOf :: RDFLiteral -> DataType
$cdataTypeOf :: RDFLiteral -> DataType
toConstr :: RDFLiteral -> Constr
$ctoConstr :: RDFLiteral -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RDFLiteral
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RDFLiteral
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RDFLiteral -> c RDFLiteral
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RDFLiteral -> c RDFLiteral
$cp1Data :: Typeable RDFLiteral
Data)

-- * Datatypes for Hets manipulation

data Term =
    SubjectTerm IRI
  | PredicateTerm IRI
  | ObjectTerm (Either IRI RDFLiteral)
    deriving (Int -> Term -> ShowS
[Term] -> ShowS
Term -> String
(Int -> Term -> ShowS)
-> (Term -> String) -> ([Term] -> ShowS) -> Show Term
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Term] -> ShowS
$cshowList :: [Term] -> ShowS
show :: Term -> String
$cshow :: Term -> String
showsPrec :: Int -> Term -> ShowS
$cshowsPrec :: Int -> Term -> ShowS
Show, Term -> Term -> Bool
(Term -> Term -> Bool) -> (Term -> Term -> Bool) -> Eq Term
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Term -> Term -> Bool
$c/= :: Term -> Term -> Bool
== :: Term -> Term -> Bool
$c== :: Term -> Term -> Bool
Eq, Eq Term
Eq Term =>
(Term -> Term -> Ordering)
-> (Term -> Term -> Bool)
-> (Term -> Term -> Bool)
-> (Term -> Term -> Bool)
-> (Term -> Term -> Bool)
-> (Term -> Term -> Term)
-> (Term -> Term -> Term)
-> Ord Term
Term -> Term -> Bool
Term -> Term -> Ordering
Term -> Term -> Term
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Term -> Term -> Term
$cmin :: Term -> Term -> Term
max :: Term -> Term -> Term
$cmax :: Term -> Term -> Term
>= :: Term -> Term -> Bool
$c>= :: Term -> Term -> Bool
> :: Term -> Term -> Bool
$c> :: Term -> Term -> Bool
<= :: Term -> Term -> Bool
$c<= :: Term -> Term -> Bool
< :: Term -> Term -> Bool
$c< :: Term -> Term -> Bool
compare :: Term -> Term -> Ordering
$ccompare :: Term -> Term -> Ordering
$cp1Ord :: Eq Term
Ord, Typeable, Typeable Term
Constr
DataType
Typeable Term =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Term -> c Term)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Term)
-> (Term -> Constr)
-> (Term -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Term))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Term))
-> ((forall b. Data b => b -> b) -> Term -> Term)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Term -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Term -> r)
-> (forall u. (forall d. Data d => d -> u) -> Term -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Term -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Term -> m Term)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Term -> m Term)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Term -> m Term)
-> Data Term
Term -> Constr
Term -> DataType
(forall b. Data b => b -> b) -> Term -> Term
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Term -> c Term
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Term
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Term -> u
forall u. (forall d. Data d => d -> u) -> Term -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Term -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Term -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Term -> m Term
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Term -> m Term
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Term
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Term -> c Term
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Term)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Term)
$cObjectTerm :: Constr
$cPredicateTerm :: Constr
$cSubjectTerm :: Constr
$tTerm :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Term -> m Term
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Term -> m Term
gmapMp :: (forall d. Data d => d -> m d) -> Term -> m Term
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Term -> m Term
gmapM :: (forall d. Data d => d -> m d) -> Term -> m Term
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Term -> m Term
gmapQi :: Int -> (forall d. Data d => d -> u) -> Term -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Term -> u
gmapQ :: (forall d. Data d => d -> u) -> Term -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Term -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Term -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Term -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Term -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Term -> r
gmapT :: (forall b. Data b => b -> b) -> Term -> Term
$cgmapT :: (forall b. Data b => b -> b) -> Term -> Term
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Term)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Term)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Term)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Term)
dataTypeOf :: Term -> DataType
$cdataTypeOf :: Term -> DataType
toConstr :: Term -> Constr
$ctoConstr :: Term -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Term
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Term
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Term -> c Term
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Term -> c Term
$cp1Data :: Typeable Term
Data)

data Axiom = Axiom Term Term Term
    deriving (Int -> Axiom -> ShowS
[Axiom] -> ShowS
Axiom -> String
(Int -> Axiom -> ShowS)
-> (Axiom -> String) -> ([Axiom] -> ShowS) -> Show Axiom
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 -> Axiom -> Bool
(Axiom -> Axiom -> Bool) -> (Axiom -> Axiom -> Bool) -> Eq Axiom
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
Eq Axiom =>
(Axiom -> Axiom -> Ordering)
-> (Axiom -> Axiom -> Bool)
-> (Axiom -> Axiom -> Bool)
-> (Axiom -> Axiom -> Bool)
-> (Axiom -> Axiom -> Bool)
-> (Axiom -> Axiom -> Axiom)
-> (Axiom -> Axiom -> Axiom)
-> Ord 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
$cp1Ord :: Eq Axiom
Ord, Typeable, Typeable Axiom
Constr
DataType
Typeable Axiom =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Axiom -> c Axiom)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Axiom)
-> (Axiom -> Constr)
-> (Axiom -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Axiom))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Axiom))
-> ((forall b. Data b => b -> b) -> Axiom -> Axiom)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Axiom -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Axiom -> r)
-> (forall u. (forall d. Data d => d -> u) -> Axiom -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Axiom -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Axiom -> m Axiom)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Axiom -> m Axiom)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Axiom -> m Axiom)
-> Data Axiom
Axiom -> Constr
Axiom -> DataType
(forall b. Data b => b -> b) -> Axiom -> Axiom
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Axiom -> c Axiom
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Axiom
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Axiom -> u
forall u. (forall d. Data d => d -> u) -> Axiom -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Axiom -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Axiom -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Axiom -> m Axiom
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Axiom -> m Axiom
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Axiom
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Axiom -> c Axiom
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Axiom)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Axiom)
$cAxiom :: Constr
$tAxiom :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Axiom -> m Axiom
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Axiom -> m Axiom
gmapMp :: (forall d. Data d => d -> m d) -> Axiom -> m Axiom
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Axiom -> m Axiom
gmapM :: (forall d. Data d => d -> m d) -> Axiom -> m Axiom
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Axiom -> m Axiom
gmapQi :: Int -> (forall d. Data d => d -> u) -> Axiom -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Axiom -> u
gmapQ :: (forall d. Data d => d -> u) -> Axiom -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Axiom -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Axiom -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Axiom -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Axiom -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Axiom -> r
gmapT :: (forall b. Data b => b -> b) -> Axiom -> Axiom
$cgmapT :: (forall b. Data b => b -> b) -> Axiom -> Axiom
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Axiom)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Axiom)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Axiom)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Axiom)
dataTypeOf :: Axiom -> DataType
$cdataTypeOf :: Axiom -> DataType
toConstr :: Axiom -> Constr
$ctoConstr :: Axiom -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Axiom
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Axiom
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Axiom -> c Axiom
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Axiom -> c Axiom
$cp1Data :: Typeable Axiom
Data)

data RDFEntityType = SubjectEntity | PredicateEntity | ObjectEntity
    deriving (Int -> RDFEntityType -> ShowS
[RDFEntityType] -> ShowS
RDFEntityType -> String
(Int -> RDFEntityType -> ShowS)
-> (RDFEntityType -> String)
-> ([RDFEntityType] -> ShowS)
-> Show RDFEntityType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RDFEntityType] -> ShowS
$cshowList :: [RDFEntityType] -> ShowS
show :: RDFEntityType -> String
$cshow :: RDFEntityType -> String
showsPrec :: Int -> RDFEntityType -> ShowS
$cshowsPrec :: Int -> RDFEntityType -> ShowS
Show, RDFEntityType -> RDFEntityType -> Bool
(RDFEntityType -> RDFEntityType -> Bool)
-> (RDFEntityType -> RDFEntityType -> Bool) -> Eq RDFEntityType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RDFEntityType -> RDFEntityType -> Bool
$c/= :: RDFEntityType -> RDFEntityType -> Bool
== :: RDFEntityType -> RDFEntityType -> Bool
$c== :: RDFEntityType -> RDFEntityType -> Bool
Eq, Eq RDFEntityType
Eq RDFEntityType =>
(RDFEntityType -> RDFEntityType -> Ordering)
-> (RDFEntityType -> RDFEntityType -> Bool)
-> (RDFEntityType -> RDFEntityType -> Bool)
-> (RDFEntityType -> RDFEntityType -> Bool)
-> (RDFEntityType -> RDFEntityType -> Bool)
-> (RDFEntityType -> RDFEntityType -> RDFEntityType)
-> (RDFEntityType -> RDFEntityType -> RDFEntityType)
-> Ord RDFEntityType
RDFEntityType -> RDFEntityType -> Bool
RDFEntityType -> RDFEntityType -> Ordering
RDFEntityType -> RDFEntityType -> RDFEntityType
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: RDFEntityType -> RDFEntityType -> RDFEntityType
$cmin :: RDFEntityType -> RDFEntityType -> RDFEntityType
max :: RDFEntityType -> RDFEntityType -> RDFEntityType
$cmax :: RDFEntityType -> RDFEntityType -> RDFEntityType
>= :: RDFEntityType -> RDFEntityType -> Bool
$c>= :: RDFEntityType -> RDFEntityType -> Bool
> :: RDFEntityType -> RDFEntityType -> Bool
$c> :: RDFEntityType -> RDFEntityType -> Bool
<= :: RDFEntityType -> RDFEntityType -> Bool
$c<= :: RDFEntityType -> RDFEntityType -> Bool
< :: RDFEntityType -> RDFEntityType -> Bool
$c< :: RDFEntityType -> RDFEntityType -> Bool
compare :: RDFEntityType -> RDFEntityType -> Ordering
$ccompare :: RDFEntityType -> RDFEntityType -> Ordering
$cp1Ord :: Eq RDFEntityType
Ord, RDFEntityType
RDFEntityType -> RDFEntityType -> Bounded RDFEntityType
forall a. a -> a -> Bounded a
maxBound :: RDFEntityType
$cmaxBound :: RDFEntityType
minBound :: RDFEntityType
$cminBound :: RDFEntityType
Bounded, Int -> RDFEntityType
RDFEntityType -> Int
RDFEntityType -> [RDFEntityType]
RDFEntityType -> RDFEntityType
RDFEntityType -> RDFEntityType -> [RDFEntityType]
RDFEntityType -> RDFEntityType -> RDFEntityType -> [RDFEntityType]
(RDFEntityType -> RDFEntityType)
-> (RDFEntityType -> RDFEntityType)
-> (Int -> RDFEntityType)
-> (RDFEntityType -> Int)
-> (RDFEntityType -> [RDFEntityType])
-> (RDFEntityType -> RDFEntityType -> [RDFEntityType])
-> (RDFEntityType -> RDFEntityType -> [RDFEntityType])
-> (RDFEntityType
    -> RDFEntityType -> RDFEntityType -> [RDFEntityType])
-> Enum RDFEntityType
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: RDFEntityType -> RDFEntityType -> RDFEntityType -> [RDFEntityType]
$cenumFromThenTo :: RDFEntityType -> RDFEntityType -> RDFEntityType -> [RDFEntityType]
enumFromTo :: RDFEntityType -> RDFEntityType -> [RDFEntityType]
$cenumFromTo :: RDFEntityType -> RDFEntityType -> [RDFEntityType]
enumFromThen :: RDFEntityType -> RDFEntityType -> [RDFEntityType]
$cenumFromThen :: RDFEntityType -> RDFEntityType -> [RDFEntityType]
enumFrom :: RDFEntityType -> [RDFEntityType]
$cenumFrom :: RDFEntityType -> [RDFEntityType]
fromEnum :: RDFEntityType -> Int
$cfromEnum :: RDFEntityType -> Int
toEnum :: Int -> RDFEntityType
$ctoEnum :: Int -> RDFEntityType
pred :: RDFEntityType -> RDFEntityType
$cpred :: RDFEntityType -> RDFEntityType
succ :: RDFEntityType -> RDFEntityType
$csucc :: RDFEntityType -> RDFEntityType
Enum, Typeable, Typeable RDFEntityType
Constr
DataType
Typeable RDFEntityType =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> RDFEntityType -> c RDFEntityType)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c RDFEntityType)
-> (RDFEntityType -> Constr)
-> (RDFEntityType -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c RDFEntityType))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c RDFEntityType))
-> ((forall b. Data b => b -> b) -> RDFEntityType -> RDFEntityType)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> RDFEntityType -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> RDFEntityType -> r)
-> (forall u. (forall d. Data d => d -> u) -> RDFEntityType -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> RDFEntityType -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> RDFEntityType -> m RDFEntityType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RDFEntityType -> m RDFEntityType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RDFEntityType -> m RDFEntityType)
-> Data RDFEntityType
RDFEntityType -> Constr
RDFEntityType -> DataType
(forall b. Data b => b -> b) -> RDFEntityType -> RDFEntityType
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RDFEntityType -> c RDFEntityType
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RDFEntityType
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> RDFEntityType -> u
forall u. (forall d. Data d => d -> u) -> RDFEntityType -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RDFEntityType -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RDFEntityType -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RDFEntityType -> m RDFEntityType
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RDFEntityType -> m RDFEntityType
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RDFEntityType
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RDFEntityType -> c RDFEntityType
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RDFEntityType)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c RDFEntityType)
$cObjectEntity :: Constr
$cPredicateEntity :: Constr
$cSubjectEntity :: Constr
$tRDFEntityType :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> RDFEntityType -> m RDFEntityType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RDFEntityType -> m RDFEntityType
gmapMp :: (forall d. Data d => d -> m d) -> RDFEntityType -> m RDFEntityType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RDFEntityType -> m RDFEntityType
gmapM :: (forall d. Data d => d -> m d) -> RDFEntityType -> m RDFEntityType
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RDFEntityType -> m RDFEntityType
gmapQi :: Int -> (forall d. Data d => d -> u) -> RDFEntityType -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> RDFEntityType -> u
gmapQ :: (forall d. Data d => d -> u) -> RDFEntityType -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> RDFEntityType -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RDFEntityType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RDFEntityType -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RDFEntityType -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RDFEntityType -> r
gmapT :: (forall b. Data b => b -> b) -> RDFEntityType -> RDFEntityType
$cgmapT :: (forall b. Data b => b -> b) -> RDFEntityType -> RDFEntityType
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c RDFEntityType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c RDFEntityType)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c RDFEntityType)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RDFEntityType)
dataTypeOf :: RDFEntityType -> DataType
$cdataTypeOf :: RDFEntityType -> DataType
toConstr :: RDFEntityType -> Constr
$ctoConstr :: RDFEntityType -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RDFEntityType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RDFEntityType
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RDFEntityType -> c RDFEntityType
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RDFEntityType -> c RDFEntityType
$cp1Data :: Typeable RDFEntityType
Data)

-- | entities used for morphisms
data RDFEntity = RDFEntity RDFEntityType Term
    deriving (Int -> RDFEntity -> ShowS
[RDFEntity] -> ShowS
RDFEntity -> String
(Int -> RDFEntity -> ShowS)
-> (RDFEntity -> String)
-> ([RDFEntity] -> ShowS)
-> Show RDFEntity
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RDFEntity] -> ShowS
$cshowList :: [RDFEntity] -> ShowS
show :: RDFEntity -> String
$cshow :: RDFEntity -> String
showsPrec :: Int -> RDFEntity -> ShowS
$cshowsPrec :: Int -> RDFEntity -> ShowS
Show, RDFEntity -> RDFEntity -> Bool
(RDFEntity -> RDFEntity -> Bool)
-> (RDFEntity -> RDFEntity -> Bool) -> Eq RDFEntity
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RDFEntity -> RDFEntity -> Bool
$c/= :: RDFEntity -> RDFEntity -> Bool
== :: RDFEntity -> RDFEntity -> Bool
$c== :: RDFEntity -> RDFEntity -> Bool
Eq, Eq RDFEntity
Eq RDFEntity =>
(RDFEntity -> RDFEntity -> Ordering)
-> (RDFEntity -> RDFEntity -> Bool)
-> (RDFEntity -> RDFEntity -> Bool)
-> (RDFEntity -> RDFEntity -> Bool)
-> (RDFEntity -> RDFEntity -> Bool)
-> (RDFEntity -> RDFEntity -> RDFEntity)
-> (RDFEntity -> RDFEntity -> RDFEntity)
-> Ord RDFEntity
RDFEntity -> RDFEntity -> Bool
RDFEntity -> RDFEntity -> Ordering
RDFEntity -> RDFEntity -> RDFEntity
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: RDFEntity -> RDFEntity -> RDFEntity
$cmin :: RDFEntity -> RDFEntity -> RDFEntity
max :: RDFEntity -> RDFEntity -> RDFEntity
$cmax :: RDFEntity -> RDFEntity -> RDFEntity
>= :: RDFEntity -> RDFEntity -> Bool
$c>= :: RDFEntity -> RDFEntity -> Bool
> :: RDFEntity -> RDFEntity -> Bool
$c> :: RDFEntity -> RDFEntity -> Bool
<= :: RDFEntity -> RDFEntity -> Bool
$c<= :: RDFEntity -> RDFEntity -> Bool
< :: RDFEntity -> RDFEntity -> Bool
$c< :: RDFEntity -> RDFEntity -> Bool
compare :: RDFEntity -> RDFEntity -> Ordering
$ccompare :: RDFEntity -> RDFEntity -> Ordering
$cp1Ord :: Eq RDFEntity
Ord, Typeable, Typeable RDFEntity
Constr
DataType
Typeable RDFEntity =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> RDFEntity -> c RDFEntity)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c RDFEntity)
-> (RDFEntity -> Constr)
-> (RDFEntity -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c RDFEntity))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RDFEntity))
-> ((forall b. Data b => b -> b) -> RDFEntity -> RDFEntity)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> RDFEntity -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> RDFEntity -> r)
-> (forall u. (forall d. Data d => d -> u) -> RDFEntity -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> RDFEntity -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> RDFEntity -> m RDFEntity)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RDFEntity -> m RDFEntity)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RDFEntity -> m RDFEntity)
-> Data RDFEntity
RDFEntity -> Constr
RDFEntity -> DataType
(forall b. Data b => b -> b) -> RDFEntity -> RDFEntity
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RDFEntity -> c RDFEntity
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RDFEntity
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> RDFEntity -> u
forall u. (forall d. Data d => d -> u) -> RDFEntity -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RDFEntity -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RDFEntity -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RDFEntity -> m RDFEntity
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RDFEntity -> m RDFEntity
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RDFEntity
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RDFEntity -> c RDFEntity
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RDFEntity)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RDFEntity)
$cRDFEntity :: Constr
$tRDFEntity :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> RDFEntity -> m RDFEntity
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RDFEntity -> m RDFEntity
gmapMp :: (forall d. Data d => d -> m d) -> RDFEntity -> m RDFEntity
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RDFEntity -> m RDFEntity
gmapM :: (forall d. Data d => d -> m d) -> RDFEntity -> m RDFEntity
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RDFEntity -> m RDFEntity
gmapQi :: Int -> (forall d. Data d => d -> u) -> RDFEntity -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> RDFEntity -> u
gmapQ :: (forall d. Data d => d -> u) -> RDFEntity -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> RDFEntity -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RDFEntity -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RDFEntity -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RDFEntity -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RDFEntity -> r
gmapT :: (forall b. Data b => b -> b) -> RDFEntity -> RDFEntity
$cgmapT :: (forall b. Data b => b -> b) -> RDFEntity -> RDFEntity
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RDFEntity)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RDFEntity)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c RDFEntity)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RDFEntity)
dataTypeOf :: RDFEntity -> DataType
$cdataTypeOf :: RDFEntity -> DataType
toConstr :: RDFEntity -> Constr
$ctoConstr :: RDFEntity -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RDFEntity
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RDFEntity
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RDFEntity -> c RDFEntity
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RDFEntity -> c RDFEntity
$cp1Data :: Typeable RDFEntity
Data)

rdfEntityTypes :: [RDFEntityType]
rdfEntityTypes :: [RDFEntityType]
rdfEntityTypes = [RDFEntityType
forall a. Bounded a => a
minBound .. RDFEntityType
forall a. Bounded a => a
maxBound]

instance GetRange TurtleDocument where
instance GetRange RDFEntity where
instance GetRange Axiom where

-- | useful functions

extractTripleStatements :: [Statement] -> [Triples]
extractTripleStatements :: [Statement] -> [Triples]
extractTripleStatements ls :: [Statement]
ls = case [Statement]
ls of
    [] -> []
    h :: Statement
h : t :: [Statement]
t -> case Statement
h of
        Statement triple :: Triples
triple -> Triples
triple Triples -> [Triples] -> [Triples]
forall a. a -> [a] -> [a]
: [Statement] -> [Triples]
extractTripleStatements [Statement]
t
        _ -> [Statement] -> [Triples]
extractTripleStatements [Statement]
t

triplesOfDocument :: TurtleDocument -> [Triples]
triplesOfDocument :: TurtleDocument -> [Triples]
triplesOfDocument doc :: TurtleDocument
doc = [Statement] -> [Triples]
extractTripleStatements ([Statement] -> [Triples]) -> [Statement] -> [Triples]
forall a b. (a -> b) -> a -> b
$ TurtleDocument -> [Statement]
statements TurtleDocument
doc

rdfFirst :: IRI
rdfFirst :: IRI
rdfFirst = IRI
nullIRI { prefixName :: String
prefixName = "rdf"
                   , iriPath :: Id
iriPath = String -> Id
stringToId "first"
                   , isAbbrev :: Bool
isAbbrev = Bool
True }

rdfRest :: IRI
rdfRest :: IRI
rdfRest = IRI
nullIRI { prefixName :: String
prefixName = "rdf"
                  , iriPath :: Id
iriPath = String -> Id
stringToId "rest"
                  , isAbbrev :: Bool
isAbbrev = Bool
True }

rdfNil :: IRI
rdfNil :: IRI
rdfNil = IRI
nullIRI { prefixName :: String
prefixName = "rdf"
                 , iriPath :: Id
iriPath = String -> Id
stringToId "nil"
                 , isAbbrev :: Bool
isAbbrev = Bool
True }

isAbsoluteIRI :: IRI -> Bool
isAbsoluteIRI :: IRI -> Bool
isAbsoluteIRI i :: IRI
i = IRI -> Bool
hasFullIRI IRI
i Bool -> Bool -> Bool
&& String -> String -> Bool
forall a. Eq a => [a] -> [a] -> Bool
isPrefixOf "//" (Id -> String
forall a. Show a => a -> String
show (Id -> String) -> Id -> String
forall a b. (a -> b) -> a -> b
$ IRI -> Id
iriPath IRI
i)