Safe Haskell | None |
---|
The Core module exports all serializers and parsers, types, and query functions of the library.
- class RDF rdf where
- baseUrl :: rdf -> Maybe BaseUrl
- prefixMappings :: rdf -> PrefixMappings
- addPrefixMappings :: rdf -> PrefixMappings -> Bool -> rdf
- empty :: rdf
- mkRdf :: Triples -> Maybe BaseUrl -> PrefixMappings -> rdf
- triplesOf :: rdf -> Triples
- select :: rdf -> NodeSelector -> NodeSelector -> NodeSelector -> Triples
- query :: rdf -> Maybe Node -> Maybe Node -> Maybe Node -> Triples
- class RdfSerializer s where
- hWriteRdf :: forall rdf. RDF rdf => s -> Handle -> rdf -> IO ()
- writeRdf :: forall rdf. RDF rdf => s -> rdf -> IO ()
- hWriteH :: forall rdf. RDF rdf => s -> Handle -> rdf -> IO ()
- writeH :: forall rdf. RDF rdf => s -> rdf -> IO ()
- hWriteTs :: s -> Handle -> Triples -> IO ()
- writeTs :: s -> Triples -> IO ()
- hWriteT :: s -> Handle -> Triple -> IO ()
- writeT :: s -> Triple -> IO ()
- hWriteN :: s -> Handle -> Node -> IO ()
- writeN :: s -> Node -> IO ()
- class RdfParser p where
- parseString :: forall rdf. RDF rdf => p -> Text -> Either ParseFailure rdf
- parseFile :: forall rdf. RDF rdf => p -> String -> IO (Either ParseFailure rdf)
- parseURL :: forall rdf. RDF rdf => p -> String -> IO (Either ParseFailure rdf)
- module Data.RDF.Types
- module Data.RDF.Query
- module Data.RDF.TriplesGraph
- module Data.RDF.MGraph
- module Text.RDF.RDF4H.NTriplesSerializer
- module Text.RDF.RDF4H.NTriplesParser
- module Text.RDF.RDF4H.TurtleSerializer
- module Text.RDF.RDF4H.TurtleParser
- module Text.RDF.RDF4H.XmlParser
Documentation
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.
baseUrl :: rdf -> Maybe BaseUrlSource
Return the base URL of this RDF, if any.
prefixMappings :: rdf -> PrefixMappingsSource
Return the prefix mappings defined for this RDF, if any.
addPrefixMappings :: rdf -> PrefixMappings -> Bool -> rdfSource
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.
Return an empty RDF.
mkRdf :: Triples -> Maybe BaseUrl -> PrefixMappings -> rdfSource
Return a RDF containing all the given triples. Handling of duplicates in the input depend on the particular RDF implementation.
triplesOf :: rdf -> TriplesSource
Return all triples in the RDF, as a list.
select :: rdf -> NodeSelector -> NodeSelector -> NodeSelector -> TriplesSource
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 -> Maybe Node -> Maybe Node -> Maybe Node -> TriplesSource
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.
class RdfSerializer s whereSource
An RdfSerializer is a serializer of RDF to some particular output format, such as NTriples or Turtle.
hWriteRdf :: forall rdf. RDF rdf => s -> Handle -> rdf -> IO ()Source
Write the RDF to a file handle using whatever configuration is specified by the first argument.
writeRdf :: forall rdf. RDF rdf => s -> rdf -> IO ()Source
Write the RDF to stdout; equivalent to
.
hWriteRdf
stdout
hWriteH :: forall rdf. RDF rdf => s -> Handle -> rdf -> IO ()Source
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 :: forall rdf. RDF rdf => s -> rdf -> IO ()Source
Write header information to stdout; equivalent to
.
hWriteRdf
stdout
hWriteTs :: s -> Handle -> Triples -> IO ()Source
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 ()Source
Write some triples to stdout; equivalent to
.
hWriteTs
stdout
hWriteT :: s -> Handle -> Triple -> IO ()Source
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 ()Source
Write a single triple to stdout; equivalent to
.
hWriteT
stdout
hWriteN :: s -> Handle -> Node -> IO ()Source
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 ()Source
Write a single node to sdout; equivalent to
.
hWriteN
stdout
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.
parseString :: forall rdf. RDF rdf => p -> Text -> Either ParseFailure rdfSource
Parse RDF from the given text, yielding a failure with error message or the resultant RDF.
parseFile :: forall rdf. RDF rdf => p -> String -> IO (Either ParseFailure rdf)Source
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 :: forall rdf. RDF rdf => p -> String -> IO (Either ParseFailure rdf)Source
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.
RdfParser NTriplesParser |
|
RdfParser TurtleParser |
|
RdfParser XmlParser |
Export types and query functions
module Data.RDF.Types
module Data.RDF.Query
Export RDF type class instances
module Data.RDF.TriplesGraph
module Data.RDF.MGraph
Export RDF parsers and serializers
module Text.RDF.RDF4H.TurtleParser
module Text.RDF.RDF4H.XmlParser