rdf4h-1.3.0: A library for RDF processing in Haskell

Safe HaskellNone
LanguageHaskell98

Data.RDF.Types

Contents

Synopsis

RDF triples, nodes and literals

data LValue Source

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.

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.

Show LValue 
Generic LValue 
Hashable LValue 
type Rep LValue 

data Node Source

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.

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.

Show Node 
Generic Node 
Hashable Node 
type Rep Node 

type Subject = Node Source

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

type Predicate = Node Source

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

type Object = Node Source

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

data Triple Source

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.

Ord Triple

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

Show Triple 

type Triples = [Triple] Source

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

class View a b where Source

A type class for ADTs that expose views to clients.

Methods

view :: a -> b Source

Constructor functions

plainL :: Text -> LValue Source

Return a PlainL LValue for the given string value.

plainLL :: Text -> Text -> LValue Source

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

typedL :: Text -> Text -> LValue Source

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

unode :: Text -> Node Source

Return a URIRef node for the given bytetring URI.

bnode :: Text -> Node Source

Return a blank node using the given string identifier.

lnode :: LValue -> Node Source

Return a literal node using the given LValue.

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

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.

Node query function

isUNode :: Node -> Bool Source

Answer if given node is a URI Ref node.

isLNode :: Node -> Bool Source

Answer if given node is a literal node.

isBNode :: Node -> Bool Source

Answer if given node is a blank node.

Miscellaneous

RDF Type

class RDF rdf where Source

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 -> Maybe BaseUrl Source

Return the base URL of this RDF, if any.

prefixMappings :: rdf -> PrefixMappings Source

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

addPrefixMappings :: rdf -> PrefixMappings -> Bool -> rdf Source

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 Source

Return an empty RDF.

mkRdf :: Triples -> Maybe BaseUrl -> PrefixMappings -> rdf Source

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

triplesOf :: rdf -> Triples Source

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 -> Triples Source

Return unique triples in the RDF, as a list.

This function performs namespace expansion and removal of duplicates.

select :: rdf -> NodeSelector -> NodeSelector -> NodeSelector -> Triples Source

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 -> Triples Source

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.

Parsing RDF

class RdfParser p where Source

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 :: forall rdf. RDF rdf => p -> Text -> Either ParseFailure rdf Source

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.

Serializing RDF

class RdfSerializer s where Source

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

Methods

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.

Namespaces and Prefixes

data Namespace Source

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

newtype PrefixMappings Source

An alias for a map from prefix to namespace URI.

Constructors

PrefixMappings (Map Text Text) 

newtype PrefixMapping Source

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

Constructors

PrefixMapping (Text, Text) 

Supporting types

newtype BaseUrl Source

The base URL of an RDF.

Constructors

BaseUrl Text 

type NodeSelector = Maybe (Node -> Bool) Source

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 Source

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

Constructors

ParseFailure String