Data.RDF.Types

RDF triples, nodes and literals

data LValue

The actual value of an RDF literal, represented as the LValue parameter of an LNode.

Constructors

PlainL !Text

A plain (untyped) literal value in an unspecified language.

PlainLL !Text !Text

A plain (untyped) literal value with a language specifier.

TypedL !Text !Text

A typed literal value consisting of the literal value and the URI of the datatype of the value, respectively.

Instances

Eq LValue

Two LValue values are equal iff they are of the same type and all fields are equal.

Defined in Data.RDF.Types

Methods

(==) :: LValue -> LValue -> Bool

(/=) :: LValue -> LValue -> Bool

Ord LValue

Ordering of LValue values is as follows: (PlainL _) < (PlainLL _ _) < (TypedL _ _), and values of the same type are ordered by field values, with '(PlainLL literalValue language)' being ordered by language first and literal value second, and '(TypedL literalValue datatypeUri)' being ordered by datatype first and literal value second.

Defined in Data.RDF.Types

Methods

compare :: LValue -> LValue -> Ordering

(<) :: LValue -> LValue -> Bool

(<=) :: LValue -> LValue -> Bool

(>) :: LValue -> LValue -> Bool

(>=) :: LValue -> LValue -> Bool

max :: LValue -> LValue -> LValue

min :: LValue -> LValue -> LValue

Show LValue

Defined in Data.RDF.Types

Methods

showsPrec :: Int -> LValue -> ShowS

show :: LValue -> String

showList :: [LValue] -> ShowS

Generic LValue

Defined in Data.RDF.Types

Associated Types

type Rep LValue :: Type -> Type

Methods

from :: LValue -> Rep LValue x

to :: Rep LValue x -> LValue

Hashable LValue

Defined in Data.RDF.Types

Methods

hashWithSalt :: Int -> LValue -> Int

hash :: LValue -> Int

Binary LValue

Defined in Data.RDF.Types

Methods

put :: LValue -> Put

get :: Get LValue

putList :: [LValue] -> Put

NFData LValue

Defined in Data.RDF.Types

Methods

rnf :: LValue -> ()

type Rep LValue

Defined in Data.RDF.Types

type Rep LValue = D1 (MetaData "LValue" "Data.RDF.Types" "rdf4h-4.0.0-GVSpZShnarFD2qNKU0xzq9" False) (C1 (MetaCons "PlainL" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 Text)) :+: (C1 (MetaCons "PlainLL" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 Text) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 Text)) :+: C1 (MetaCons "TypedL" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 Text) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 Text))))

data Node

An RDF node, which may be either a URIRef node (UNode), a blank node (BNode), or a literal node (LNode).

Constructors

UNode !Text

An RDF URI reference. URIs conform to the RFC3986 standard. See http://www.w3.org/TR/rdf-concepts/#section-Graph-URIref for more information.

BNode !Text

An RDF blank node. See http://www.w3.org/TR/rdf-concepts/#section-blank-nodes for more information.

BNodeGen !Int

An RDF blank node with an auto-generated identifier, as used in Turtle.

LNode !LValue

An RDF literal. See http://www.w3.org/TR/rdf-concepts/#section-Graph-Literal for more information.

Instances

Eq Node

A node is equal to another node if they are both the same type of node and if the field values are equal.

Defined in Data.RDF.Types

Methods

(==) :: Node -> Node -> Bool

(/=) :: Node -> Node -> Bool

Ord Node

Node ordering is defined first by type, with Unode < BNode < BNodeGen < LNode PlainL < LNode PlainLL < LNode TypedL, and secondly by the natural ordering of the node value.

E.g., a '(UNode _)' is LT any other type of node, and a '(LNode (TypedL _ _))' is GT any other type of node, and the ordering of '(BNodeGen 44)' and '(BNodeGen 3)' is that of the values, or 'compare 44 3', GT.

Defined in Data.RDF.Types

Methods

compare :: Node -> Node -> Ordering

(<) :: Node -> Node -> Bool

(<=) :: Node -> Node -> Bool

(>) :: Node -> Node -> Bool

(>=) :: Node -> Node -> Bool

max :: Node -> Node -> Node

min :: Node -> Node -> Node

Show Node

Defined in Data.RDF.Types

Methods

showsPrec :: Int -> Node -> ShowS

show :: Node -> String

showList :: [Node] -> ShowS

Generic Node

Defined in Data.RDF.Types

Associated Types

type Rep Node :: Type -> Type

Methods

from :: Node -> Rep Node x

to :: Rep Node x -> Node

Hashable Node

Defined in Data.RDF.Types

Methods

hashWithSalt :: Int -> Node -> Int

hash :: Node -> Int

Binary Node

Defined in Data.RDF.Types

Methods

put :: Node -> Put

get :: Get Node

putList :: [Node] -> Put

NFData Node

Defined in Data.RDF.Types

Methods

rnf :: Node -> ()

type Rep Node

Defined in Data.RDF.Types

type Rep Node = D1 (MetaData "Node" "Data.RDF.Types" "rdf4h-4.0.0-GVSpZShnarFD2qNKU0xzq9" False) ((C1 (MetaCons "UNode" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 Text)) :+: C1 (MetaCons "BNode" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 Text))) :+: (C1 (MetaCons "BNodeGen" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 Int)) :+: C1 (MetaCons "LNode" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 LValue))))

type Subject = Node

An alias for Node, defined for convenience and readability purposes.

type Predicate = Node

An alias for Node, defined for convenience and readability purposes.

type Object = Node

An alias for Node, defined for convenience and readability purposes.

data Triple

An RDF triple is a statement consisting of a subject, predicate, and object, respectively.

See http://www.w3.org/TR/rdf-concepts/#section-triples for more information.

Constructors

Triple !Node !Node !Node

Instances

Eq Triple

Two triples are equal iff their respective subjects, predicates, and objects are equal.

Defined in Data.RDF.Types

Methods

(==) :: Triple -> Triple -> Bool

(/=) :: Triple -> Triple -> Bool

Ord Triple

The ordering of triples is based on that of the subject, predicate, and object of the triple, in that order.

Defined in Data.RDF.Types

Methods

compare :: Triple -> Triple -> Ordering

(<) :: Triple -> Triple -> Bool

(<=) :: Triple -> Triple -> Bool

(>) :: Triple -> Triple -> Bool

(>=) :: Triple -> Triple -> Bool

max :: Triple -> Triple -> Triple

min :: Triple -> Triple -> Triple

Show Triple

Defined in Data.RDF.Types

Methods

showsPrec :: Int -> Triple -> ShowS

show :: Triple -> String

showList :: [Triple] -> ShowS

Generic Triple

Defined in Data.RDF.Types

Associated Types

type Rep Triple :: Type -> Type

Methods

from :: Triple -> Rep Triple x

to :: Rep Triple x -> Triple

Binary Triple

Defined in Data.RDF.Types

Methods

put :: Triple -> Put

get :: Get Triple

putList :: [Triple] -> Put

NFData Triple

Defined in Data.RDF.Types

Methods

rnf :: Triple -> ()

type Rep Triple

Defined in Data.RDF.Types

type Rep Triple = D1 (MetaData "Triple" "Data.RDF.Types" "rdf4h-4.0.0-GVSpZShnarFD2qNKU0xzq9" False) (C1 (MetaCons "Triple" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 Node) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 Node) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 Node))))

type Triples = [Triple]

A list of triples. This is defined for convenience and readability.

class View a b where

A type class for ADTs that expose views to clients.

Methods

view :: a -> b

Constructor functions

plainL :: Text -> LValue

Return a PlainL LValue for the given string value.

plainLL :: Text -> Text -> LValue

Return a PlainLL LValue for the given string value and language, respectively.

typedL :: Text -> Text -> LValue

Return a TypedL LValue for the given string value and datatype URI, respectively.

unode :: Text -> Node

Return a URIRef node for the given URI.

bnode :: Text -> Node

Return a blank node using the given string identifier.

lnode :: LValue -> Node

Return a literal node using the given LValue.

triple :: Subject -> Predicate -> Object -> Triple

A smart constructor function for Triple that verifies the node arguments are of the correct type and creates the new Triple if so or calls error. subj must be a UNode or BNode, and pred must be a UNode.

unodeValidate :: Text -> Maybe Node

Validate a URI and return it in a Just UNode if it is valid, otherwise Nothing is returned. Performs the following:

1. unescape unicode RDF literals
2. checks validity of this unescaped URI using isURI from URI
3. if the unescaped URI is valid then Node constructed with UNode

uriValidate :: Text -> Maybe Text

Validate a Text URI and return it in a Just Text if it is valid, otherwise Nothing is returned. See unodeValidate.

uriValidateString :: String -> Maybe String

Same as uriValidate, but on String rather than Text

Node query function

isUNode :: Node -> Bool

Answer if given node is a URI Ref node.

isLNode :: Node -> Bool

Answer if given node is a literal node.

isBNode :: Node -> Bool

Answer if given node is a blank node.

Miscellaneous

resolveQName :: Text -> PrefixMappings -> Maybe Text

Resolve a prefix using the given prefix mappings.

isAbsoluteUri :: Text -> Bool

returns True if URI is absolute.

mkAbsoluteUrl :: Text -> Text -> Text

Deprecated: Use resolveIRI instead, because mkAbsoluteUrl is a partial function

Make an absolute URL by returning as is if already an absolute URL and otherwise appending the URL to the given base URL.

escapeRDFSyntax :: Text -> Either ParseError Text

Deprecated: Use unescapeUnicode instead

Unescapes Uxxxxxxxx and uxxxx character sequences according to the RDF specification.

unescapeUnicode :: Text -> Either ParseError Text

Unescapes Uxxxxxxxx and uxxxx character sequences according to the RDF specification.

fileSchemeToFilePath :: IsString s => Node -> Maybe s

Removes "file://" schema from URIs in UNode nodes

filePathToUri :: IsString s => FilePath -> Maybe s

Converts a file path to a URI with "file:" scheme

iriFragment :: (CharParsing m, Monad m) => m Text

uchar :: (CharParsing m, Monad m) => m Char

RDF data family

data family RDF a

RDF data family

Instances

Rdf a => Show (RDF a)

Defined in Data.RDF.Types

Methods

showsPrec :: Int -> RDF a -> ShowS

show :: RDF a -> String

showList :: [RDF a] -> ShowS

Generic (RDF TList)

Defined in Data.RDF.Graph.TList

Associated Types

type Rep (RDF TList) :: Type -> Type

Methods

from :: RDF TList -> Rep (RDF TList) x

to :: Rep (RDF TList) x -> RDF TList

Generic (RDF AlgebraicGraph)

Defined in Data.RDF.Graph.AlgebraicGraph

Associated Types

type Rep (RDF AlgebraicGraph) :: Type -> Type

Methods

from :: RDF AlgebraicGraph -> Rep (RDF AlgebraicGraph) x

to :: Rep (RDF AlgebraicGraph) x -> RDF AlgebraicGraph

Generic (RDF AdjHashMap)

Defined in Data.RDF.Graph.AdjHashMap

Associated Types

type Rep (RDF AdjHashMap) :: Type -> Type

Methods

from :: RDF AdjHashMap -> Rep (RDF AdjHashMap) x

to :: Rep (RDF AdjHashMap) x -> RDF AdjHashMap

NFData (RDF TList)

Defined in Data.RDF.Graph.TList

Methods

rnf :: RDF TList -> ()

NFData (RDF AlgebraicGraph)

Defined in Data.RDF.Graph.AlgebraicGraph

Methods

rnf :: RDF AlgebraicGraph -> ()

NFData (RDF AdjHashMap)

Defined in Data.RDF.Graph.AdjHashMap

Methods

rnf :: RDF AdjHashMap -> ()

data RDF TList

Defined in Data.RDF.Graph.TList

data RDF TList = TListC (Triples, Maybe BaseUrl, PrefixMappings)

data RDF AlgebraicGraph

Defined in Data.RDF.Graph.AlgebraicGraph

data RDF AlgebraicGraph = AlgebraicGraph {

• _graph :: Graph (HashSet Node) Node
• _baseUrl :: Maybe BaseUrl
• _prefixMappings :: PrefixMappings

}

data RDF AdjHashMap

Defined in Data.RDF.Graph.AdjHashMap

data RDF AdjHashMap = AdjHashMap (TMaps, Maybe BaseUrl, PrefixMappings)

type Rep (RDF TList)

Defined in Data.RDF.Graph.TList

type Rep (RDF TList) = D1 (MetaData "RDF" "Data.RDF.Graph.TList" "rdf4h-4.0.0-GVSpZShnarFD2qNKU0xzq9" False) (C1 (MetaCons "TListC" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Triples, Maybe BaseUrl, PrefixMappings))))

type Rep (RDF AlgebraicGraph)

Defined in Data.RDF.Graph.AlgebraicGraph

type Rep (RDF AlgebraicGraph) = D1 (MetaData "RDF" "Data.RDF.Graph.AlgebraicGraph" "rdf4h-4.0.0-GVSpZShnarFD2qNKU0xzq9" False) (C1 (MetaCons "AlgebraicGraph" PrefixI True) (S1 (MetaSel (Just "_graph") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Graph (HashSet Node) Node)) :*: (S1 (MetaSel (Just "_baseUrl") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe BaseUrl)) :*: S1 (MetaSel (Just "_prefixMappings") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 PrefixMappings))))

type Rep (RDF AdjHashMap)

Defined in Data.RDF.Graph.AdjHashMap

type Rep (RDF AdjHashMap)

Rdf type class

class (Generic rdfImpl, NFData rdfImpl) => Rdf rdfImpl where

An RDF value is a set of (unique) RDF triples, together with the operations defined upon them.

For information about the efficiency of the functions, see the documentation for the particular RDF instance.

For more information about the concept of an RDF graph, see the following: http://www.w3.org/TR/rdf-concepts/#section-rdf-graph.

Methods

baseUrl :: RDF rdfImpl -> Maybe BaseUrl

Return the base URL of this RDF, if any.

prefixMappings :: RDF rdfImpl -> PrefixMappings

Return the prefix mappings defined for this RDF, if any.

addPrefixMappings :: RDF rdfImpl -> PrefixMappings -> Bool -> RDF rdfImpl

Return an RDF with the specified prefix mappings merged with the existing mappings. If the Bool arg is True, then a new mapping for an existing prefix will replace the old mapping; otherwise, the new mapping is ignored.

empty :: RDF rdfImpl

Return an empty RDF.

mkRdf :: Triples -> Maybe BaseUrl -> PrefixMappings -> RDF rdfImpl

Return a RDF containing all the given triples. Handling of duplicates in the input depend on the particular RDF implementation.

addTriple :: RDF rdfImpl -> Triple -> RDF rdfImpl

Adds a triple to an RDF graph.

removeTriple :: RDF rdfImpl -> Triple -> RDF rdfImpl

Removes all occurrences of a triple in an RDF graph.

triplesOf :: RDF rdfImpl -> Triples

Return all triples in the RDF, as a list.

Note that this function returns a list of triples in the RDF as they were added, without removing duplicates and without expanding namespaces.

uniqTriplesOf :: RDF rdfImpl -> Triples

Return unique triples in the RDF, as a list.

This function performs namespace expansion and removal of duplicates.

select :: RDF rdfImpl -> NodeSelector -> NodeSelector -> NodeSelector -> Triples

Select the triples in the RDF that match the given selectors.

The three NodeSelector parameters are optional functions that match the respective subject, predicate, and object of a triple. The triples returned are those in the given graph for which the first selector returns true when called on the subject, the second selector returns true when called on the predicate, and the third selector returns true when called on the ojbect. A Nothing parameter is equivalent to a function that always returns true for the appropriate node; but implementations may be able to much more efficiently answer a select that involves a Nothing parameter rather than an (id True) parameter.

The following call illustrates the use of select, and would result in the selection of all and only the triples that have a blank node as subject and a literal node as object:

select gr (Just isBNode) Nothing (Just isLNode)

Note: this function may be very slow; see the documentation for the particular RDF implementation for more information.

query :: RDF rdfImpl -> Maybe Node -> Maybe Node -> Maybe Node -> Triples

Return the triples in the RDF that match the given pattern, where the pattern (3 Maybe Node parameters) is interpreted as a triple pattern.

The Maybe Node params are interpreted as the subject, predicate, and object of a triple, respectively. Just n is true iff the triple has a node equal to n in the appropriate location; Nothing is always true, regardless of the node in the appropriate location.

For example, query rdf (Just n1) Nothing (Just n2) would return all and only the triples that have n1 as subject and n2 as object, regardless of the predicate of the triple.

showGraph :: RDF rdfImpl -> String

pretty prints the RDF graph

Instances

Rdf TList

Defined in Data.RDF.Graph.TList

Methods

baseUrl :: RDF TList -> Maybe BaseUrl

prefixMappings :: RDF TList -> PrefixMappings

addPrefixMappings :: RDF TList -> PrefixMappings -> Bool -> RDF TList

empty :: RDF TList

mkRdf :: Triples -> Maybe BaseUrl -> PrefixMappings -> RDF TList

addTriple :: RDF TList -> Triple -> RDF TList

removeTriple :: RDF TList -> Triple -> RDF TList

triplesOf :: RDF TList -> Triples

uniqTriplesOf :: RDF TList -> Triples

select :: RDF TList -> NodeSelector -> NodeSelector -> NodeSelector -> Triples

query :: RDF TList -> Maybe Node -> Maybe Node -> Maybe Node -> Triples

showGraph :: RDF TList -> String

Rdf AlgebraicGraph

Defined in Data.RDF.Graph.AlgebraicGraph

Methods

baseUrl :: RDF AlgebraicGraph -> Maybe BaseUrl

prefixMappings :: RDF AlgebraicGraph -> PrefixMappings

addPrefixMappings :: RDF AlgebraicGraph -> PrefixMappings -> Bool -> RDF AlgebraicGraph

empty :: RDF AlgebraicGraph

mkRdf :: Triples -> Maybe BaseUrl -> PrefixMappings -> RDF AlgebraicGraph

addTriple :: RDF AlgebraicGraph -> Triple -> RDF AlgebraicGraph

removeTriple :: RDF AlgebraicGraph -> Triple -> RDF AlgebraicGraph

triplesOf :: RDF AlgebraicGraph -> Triples

uniqTriplesOf :: RDF AlgebraicGraph -> Triples

select :: RDF AlgebraicGraph -> NodeSelector -> NodeSelector -> NodeSelector -> Triples

query :: RDF AlgebraicGraph -> Maybe Node -> Maybe Node -> Maybe Node -> Triples

showGraph :: RDF AlgebraicGraph -> String

Rdf AdjHashMap

Defined in Data.RDF.Graph.AdjHashMap

Methods

baseUrl :: RDF AdjHashMap -> Maybe BaseUrl

prefixMappings :: RDF AdjHashMap -> PrefixMappings

addPrefixMappings :: RDF AdjHashMap -> PrefixMappings -> Bool -> RDF AdjHashMap

empty :: RDF AdjHashMap

mkRdf :: Triples -> Maybe BaseUrl -> PrefixMappings -> RDF AdjHashMap

addTriple :: RDF AdjHashMap -> Triple -> RDF AdjHashMap

removeTriple :: RDF AdjHashMap -> Triple -> RDF AdjHashMap

triplesOf :: RDF AdjHashMap -> Triples

uniqTriplesOf :: RDF AdjHashMap -> Triples

select :: RDF AdjHashMap -> NodeSelector -> NodeSelector -> NodeSelector -> Triples

query :: RDF AdjHashMap -> Maybe Node -> Maybe Node -> Maybe Node -> Triples

showGraph :: RDF AdjHashMap -> String

Parsing RDF

class RdfParser p where

An RdfParser is a parser that knows how to parse 1 format of RDF and can parse an RDF document of that type from a string, a file, or a URL. Required configuration options will vary from instance to instance.

Methods

parseString :: Rdf a => p -> Text -> Either ParseFailure (RDF a)

Parse RDF from the given text, yielding a failure with error message or the resultant RDF.

parseFile :: Rdf a => p -> String -> IO (Either ParseFailure (RDF a))

Parse RDF from the local file with the given path, yielding a failure with error message or the resultant RDF in the IO monad.

parseURL :: Rdf a => p -> String -> IO (Either ParseFailure (RDF a))

Parse RDF from the remote file with the given HTTP URL (https is not supported), yielding a failure with error message or the resultant graph in the IO monad.

Instances

RdfParser NTriplesParserCustom

NTriplesParser is an instance of RdfParser.

Defined in Text.RDF.RDF4H.NTriplesParser

Methods

parseString :: Rdf a => NTriplesParserCustom -> Text -> Either ParseFailure (RDF a)

parseFile :: Rdf a => NTriplesParserCustom -> String -> IO (Either ParseFailure (RDF a))

parseURL :: Rdf a => NTriplesParserCustom -> String -> IO (Either ParseFailure (RDF a))

RdfParser NTriplesParser

NTriplesParser is an instance of RdfParser using parsec based parsers.

Defined in Text.RDF.RDF4H.NTriplesParser

Methods

parseString :: Rdf a => NTriplesParser -> Text -> Either ParseFailure (RDF a)

parseFile :: Rdf a => NTriplesParser -> String -> IO (Either ParseFailure (RDF a))

parseURL :: Rdf a => NTriplesParser -> String -> IO (Either ParseFailure (RDF a))

RdfParser TurtleParserCustom

TurtleParser is an instance of RdfParser using either a parsec or an attoparsec based parser.

Defined in Text.RDF.RDF4H.TurtleParser

Methods

parseString :: Rdf a => TurtleParserCustom -> Text -> Either ParseFailure (RDF a)

parseFile :: Rdf a => TurtleParserCustom -> String -> IO (Either ParseFailure (RDF a))

parseURL :: Rdf a => TurtleParserCustom -> String -> IO (Either ParseFailure (RDF a))

RdfParser TurtleParser

TurtleParser is an instance of RdfParser using a parsec based parser.

Defined in Text.RDF.RDF4H.TurtleParser

Methods

parseString :: Rdf a => TurtleParser -> Text -> Either ParseFailure (RDF a)

parseFile :: Rdf a => TurtleParser -> String -> IO (Either ParseFailure (RDF a))

parseURL :: Rdf a => TurtleParser -> String -> IO (Either ParseFailure (RDF a))

RdfParser XmlParser

Defined in Text.RDF.RDF4H.XmlParser

Methods

parseString :: Rdf a => XmlParser -> Text -> Either ParseFailure (RDF a)

parseFile :: Rdf a => XmlParser -> String -> IO (Either ParseFailure (RDF a))

parseURL :: Rdf a => XmlParser -> String -> IO (Either ParseFailure (RDF a))

Serializing RDF

class RdfSerializer s where

An RdfSerializer is a serializer of RDF to some particular output format, such as NTriples or Turtle.

Methods

hWriteRdf :: Rdf a => s -> Handle -> RDF a -> IO ()

Write the RDF to a file handle using whatever configuration is specified by the first argument.

writeRdf :: Rdf a => s -> RDF a -> IO ()

Write the RDF to stdout; equivalent to hWriteRdf stdout.

hWriteH :: Rdf a => s -> Handle -> RDF a -> IO ()

Write to the file handle whatever header information is required based on the output format. For example, if serializing to Turtle, this method would write the necessary @prefix declarations and possibly a @baseUrl declaration, whereas for NTriples, there is no header section at all, so this would be a no-op.

writeH :: Rdf a => s -> RDF a -> IO ()

Write header information to stdout; equivalent to hWriteRdf stdout.

hWriteTs :: s -> Handle -> Triples -> IO ()

Write some triples to a file handle using whatever configuration is specified by the first argument.

WARNING: if the serialization format has header-level information that should be output (e.g., @prefix declarations for Turtle), then you should use hWriteG instead of this method unless you're sure this is safe to use, since otherwise the resultant document will be missing the header information and will not be valid.

writeTs :: s -> Triples -> IO ()

Write some triples to stdout; equivalent to hWriteTs stdout.

hWriteT :: s -> Handle -> Triple -> IO ()

Write a single triple to the file handle using whatever configuration is specified by the first argument. The same WARNING applies as to hWriteTs.

writeT :: s -> Triple -> IO ()

Write a single triple to stdout; equivalent to hWriteT stdout.

hWriteN :: s -> Handle -> Node -> IO ()

Write a single node to the file handle using whatever configuration is specified by the first argument. The same WARNING applies as to hWriteTs.

writeN :: s -> Node -> IO ()

Write a single node to sdout; equivalent to hWriteN stdout.

Instances

RdfSerializer NTriplesSerializer

Defined in Text.RDF.RDF4H.NTriplesSerializer

Methods

hWriteRdf :: Rdf a => NTriplesSerializer -> Handle -> RDF a -> IO ()

writeRdf :: Rdf a => NTriplesSerializer -> RDF a -> IO ()

hWriteH :: Rdf a => NTriplesSerializer -> Handle -> RDF a -> IO ()

writeH :: Rdf a => NTriplesSerializer -> RDF a -> IO ()

hWriteTs :: NTriplesSerializer -> Handle -> Triples -> IO ()

writeTs :: NTriplesSerializer -> Triples -> IO ()

hWriteT :: NTriplesSerializer -> Handle -> Triple -> IO ()

writeT :: NTriplesSerializer -> Triple -> IO ()

hWriteN :: NTriplesSerializer -> Handle -> Node -> IO ()

writeN :: NTriplesSerializer -> Node -> IO ()

RdfSerializer TurtleSerializer

Defined in Text.RDF.RDF4H.TurtleSerializer

Methods

hWriteRdf :: Rdf a => TurtleSerializer -> Handle -> RDF a -> IO ()

writeRdf :: Rdf a => TurtleSerializer -> RDF a -> IO ()

hWriteH :: Rdf a => TurtleSerializer -> Handle -> RDF a -> IO ()

writeH :: Rdf a => TurtleSerializer -> RDF a -> IO ()

hWriteTs :: TurtleSerializer -> Handle -> Triples -> IO ()

writeTs :: TurtleSerializer -> Triples -> IO ()

hWriteT :: TurtleSerializer -> Handle -> Triple -> IO ()

writeT :: TurtleSerializer -> Triple -> IO ()

hWriteN :: TurtleSerializer -> Handle -> Node -> IO ()

writeN :: TurtleSerializer -> Node -> IO ()

Namespaces and Prefixes

data Namespace

Represents a namespace as either a prefix and uri, respectively, or just a uri.

Constructors

PrefixedNS Text Text

PlainNS Text

Instances

Eq Namespace

Defined in Data.RDF.Types

Methods

(==) :: Namespace -> Namespace -> Bool

(/=) :: Namespace -> Namespace -> Bool

Show Namespace

Defined in Data.RDF.Types

Methods

showsPrec :: Int -> Namespace -> ShowS

show :: Namespace -> String

showList :: [Namespace] -> ShowS

newtype PrefixMappings

An alias for a map from prefix to namespace URI.

Constructors

PrefixMappings (Map Text Text)

Instances

Eq PrefixMappings

Defined in Data.RDF.Types

Methods

(==) :: PrefixMappings -> PrefixMappings -> Bool

(/=) :: PrefixMappings -> PrefixMappings -> Bool

Ord PrefixMappings

Defined in Data.RDF.Types

Methods

compare :: PrefixMappings -> PrefixMappings -> Ordering

(<) :: PrefixMappings -> PrefixMappings -> Bool

(<=) :: PrefixMappings -> PrefixMappings -> Bool

(>) :: PrefixMappings -> PrefixMappings -> Bool

(>=) :: PrefixMappings -> PrefixMappings -> Bool

max :: PrefixMappings -> PrefixMappings -> PrefixMappings

min :: PrefixMappings -> PrefixMappings -> PrefixMappings

Show PrefixMappings

Defined in Data.RDF.Types

Methods

showsPrec :: Int -> PrefixMappings -> ShowS

show :: PrefixMappings -> String

showList :: [PrefixMappings] -> ShowS

Generic PrefixMappings

Defined in Data.RDF.Types

Associated Types

type Rep PrefixMappings :: Type -> Type

Methods

from :: PrefixMappings -> Rep PrefixMappings x

to :: Rep PrefixMappings x -> PrefixMappings

Semigroup PrefixMappings

Defined in Data.RDF.Types

Methods

(<>) :: PrefixMappings -> PrefixMappings -> PrefixMappings

sconcat :: NonEmpty PrefixMappings -> PrefixMappings

stimes :: Integral b => b -> PrefixMappings -> PrefixMappings

Monoid PrefixMappings

Defined in Data.RDF.Types

Methods

mempty :: PrefixMappings

mappend :: PrefixMappings -> PrefixMappings -> PrefixMappings

mconcat :: [PrefixMappings] -> PrefixMappings

Binary PrefixMappings

Defined in Data.RDF.Types

Methods

put :: PrefixMappings -> Put

get :: Get PrefixMappings

putList :: [PrefixMappings] -> Put

NFData PrefixMappings

Defined in Data.RDF.Types

Methods

rnf :: PrefixMappings -> ()

type Rep PrefixMappings

Defined in Data.RDF.Types

type Rep PrefixMappings = D1 (MetaData "PrefixMappings" "Data.RDF.Types" "rdf4h-4.0.0-GVSpZShnarFD2qNKU0xzq9" True) (C1 (MetaCons "PrefixMappings" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Map Text Text))))

newtype PrefixMapping

A mapping of a prefix to the URI for that prefix.

Constructors

PrefixMapping (Text, Text)

Instances

Eq PrefixMapping

Defined in Data.RDF.Types

Methods

(==) :: PrefixMapping -> PrefixMapping -> Bool

(/=) :: PrefixMapping -> PrefixMapping -> Bool

Ord PrefixMapping

Defined in Data.RDF.Types

Methods

compare :: PrefixMapping -> PrefixMapping -> Ordering

(<) :: PrefixMapping -> PrefixMapping -> Bool

(<=) :: PrefixMapping -> PrefixMapping -> Bool

(>) :: PrefixMapping -> PrefixMapping -> Bool

(>=) :: PrefixMapping -> PrefixMapping -> Bool

max :: PrefixMapping -> PrefixMapping -> PrefixMapping

min :: PrefixMapping -> PrefixMapping -> PrefixMapping

Show PrefixMapping

Defined in Data.RDF.Types

Methods

showsPrec :: Int -> PrefixMapping -> ShowS

show :: PrefixMapping -> String

showList :: [PrefixMapping] -> ShowS

Supporting types

newtype BaseUrl

The base URL of an RDF.

Constructors

BaseUrl

Fields

• unBaseUrl :: Text

Instances

Eq BaseUrl

Defined in Data.RDF.Types

Methods

(==) :: BaseUrl -> BaseUrl -> Bool

(/=) :: BaseUrl -> BaseUrl -> Bool

Ord BaseUrl

Defined in Data.RDF.Types

Methods

compare :: BaseUrl -> BaseUrl -> Ordering

(<) :: BaseUrl -> BaseUrl -> Bool

(<=) :: BaseUrl -> BaseUrl -> Bool

(>) :: BaseUrl -> BaseUrl -> Bool

(>=) :: BaseUrl -> BaseUrl -> Bool

max :: BaseUrl -> BaseUrl -> BaseUrl

min :: BaseUrl -> BaseUrl -> BaseUrl

Show BaseUrl

Defined in Data.RDF.Types

Methods

showsPrec :: Int -> BaseUrl -> ShowS

show :: BaseUrl -> String

showList :: [BaseUrl] -> ShowS

Generic BaseUrl

Defined in Data.RDF.Types

Associated Types

type Rep BaseUrl :: Type -> Type

Methods

from :: BaseUrl -> Rep BaseUrl x

to :: Rep BaseUrl x -> BaseUrl

Semigroup BaseUrl

Defined in Data.RDF.Types

Methods

(<>) :: BaseUrl -> BaseUrl -> BaseUrl

sconcat :: NonEmpty BaseUrl -> BaseUrl

stimes :: Integral b => b -> BaseUrl -> BaseUrl

Monoid BaseUrl

Defined in Data.RDF.Types

Methods

mempty :: BaseUrl

mappend :: BaseUrl -> BaseUrl -> BaseUrl

mconcat :: [BaseUrl] -> BaseUrl

Binary BaseUrl

Defined in Data.RDF.Types

Methods

put :: BaseUrl -> Put

get :: Get BaseUrl

putList :: [BaseUrl] -> Put

NFData BaseUrl

Defined in Data.RDF.Types

Methods

rnf :: BaseUrl -> ()

type Rep BaseUrl

Defined in Data.RDF.Types

type Rep BaseUrl = D1 (MetaData "BaseUrl" "Data.RDF.Types" "rdf4h-4.0.0-GVSpZShnarFD2qNKU0xzq9" True) (C1 (MetaCons "BaseUrl" PrefixI True) (S1 (MetaSel (Just "unBaseUrl") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Text)))

type NodeSelector = Maybe (Node -> Bool)

A NodeSelector is either a function that returns True or False for a node, or Nothing, which indicates that all nodes would return True.

The selector is said to select, or match, the nodes for which it returns True.

When used in conjunction with the select method of Graph, three node selectors are used to match a triple.

newtype ParseFailure

Represents a failure in parsing an N-Triples document, including an error message with information about the cause for the failure.

Constructors

ParseFailure String

Instances

Eq ParseFailure

Defined in Data.RDF.Types

Methods

(==) :: ParseFailure -> ParseFailure -> Bool

(/=) :: ParseFailure -> ParseFailure -> Bool

Show ParseFailure

Defined in Data.RDF.Types

Methods

showsPrec :: Int -> ParseFailure -> ShowS

show :: ParseFailure -> String

showList :: [ParseFailure] -> ShowS