Data.RDF.Types

This module provides types for representing RDF data based on the abstract syntax described in RDF 1.1 Concepts and Abstract Syntax.

Graphs

data RDFGraph

A contiguous RDF graph with optional label. Note that a contiguous graph within an RDF data set will not appear as a single contiguous graph to this library if the graph's constituent triples are not contiguous in the original data set. This strategy allows for incremental processing of RDF data in constant space.

Constructors

RDFGraph

Fields

• rdfLabel :: !(Maybe IRI)

  A named RDF graph includes an IRI.

• rdfTriples :: [Triple]

  The constituent triples. A proper graph is a strict set of triples (i.e. no duplicate nodes or edges), but this guarantee cannot be made if the triples are to be processed incrementally in constant space. Programs using this type for interpreting RDF graphs should ignore any supernumerary triples in this list.

Instances

Generic RDFGraph

Defined in Data.RDF.Internal

Associated Types

type Rep RDFGraph :: Type -> Type

Methods

from :: RDFGraph -> Rep RDFGraph x

to :: Rep RDFGraph x -> RDFGraph

Read RDFGraph

Defined in Data.RDF.Internal

Methods

readsPrec :: Int -> ReadS RDFGraph

readList :: ReadS [RDFGraph]

readPrec :: ReadPrec RDFGraph

readListPrec :: ReadPrec [RDFGraph]

Show RDFGraph

Defined in Data.RDF.Internal

Methods

showsPrec :: Int -> RDFGraph -> ShowS

show :: RDFGraph -> String

showList :: [RDFGraph] -> ShowS

NFData RDFGraph

Defined in Data.RDF.Internal

Methods

rnf :: RDFGraph -> ()

Eq RDFGraph

Defined in Data.RDF.Internal

Methods

(==) :: RDFGraph -> RDFGraph -> Bool

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

Ord RDFGraph

Defined in Data.RDF.Internal

Methods

compare :: RDFGraph -> RDFGraph -> Ordering

(<) :: RDFGraph -> RDFGraph -> Bool

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

(>) :: RDFGraph -> RDFGraph -> Bool

(>=) :: RDFGraph -> RDFGraph -> Bool

max :: RDFGraph -> RDFGraph -> RDFGraph

min :: RDFGraph -> RDFGraph -> RDFGraph

type Rep RDFGraph

Defined in Data.RDF.Internal

type Rep RDFGraph = D1 ('MetaData "RDFGraph" "Data.RDF.Internal" "rdf-0.1.0.7-KwPFeMtuF2mFgprU5G6Koq" 'False) (C1 ('MetaCons "RDFGraph" 'PrefixI 'True) (S1 ('MetaSel ('Just "rdfLabel") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (Maybe IRI)) :*: S1 ('MetaSel ('Just "rdfTriples") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Triple])))

data Quad

An RDF quad, i.e. a triple belonging to a named graph.

Constructors

Quad

Fields

• quadTriple :: !Triple
• quadGraph :: !(Maybe IRI)

Instances

Generic Quad

Defined in Data.RDF.Internal

Associated Types

type Rep Quad :: Type -> Type

Methods

from :: Quad -> Rep Quad x

to :: Rep Quad x -> Quad

Read Quad

Defined in Data.RDF.Internal

Methods

readsPrec :: Int -> ReadS Quad

readList :: ReadS [Quad]

readPrec :: ReadPrec Quad

readListPrec :: ReadPrec [Quad]

Show Quad

Defined in Data.RDF.Internal

Methods

showsPrec :: Int -> Quad -> ShowS

show :: Quad -> String

showList :: [Quad] -> ShowS

NFData Quad

Defined in Data.RDF.Internal

Methods

rnf :: Quad -> ()

Eq Quad

Defined in Data.RDF.Internal

Methods

(==) :: Quad -> Quad -> Bool

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

Ord Quad

Defined in Data.RDF.Internal

Methods

compare :: Quad -> Quad -> Ordering

(<) :: Quad -> Quad -> Bool

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

(>) :: Quad -> Quad -> Bool

(>=) :: Quad -> Quad -> Bool

max :: Quad -> Quad -> Quad

min :: Quad -> Quad -> Quad

type Rep Quad

Defined in Data.RDF.Internal

type Rep Quad = D1 ('MetaData "Quad" "Data.RDF.Internal" "rdf-0.1.0.7-KwPFeMtuF2mFgprU5G6Koq" 'False) (C1 ('MetaCons "Quad" 'PrefixI 'True) (S1 ('MetaSel ('Just "quadTriple") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Triple) :*: S1 ('MetaSel ('Just "quadGraph") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (Maybe IRI))))

data Triple

An RDF triple.

Constructors

Triple !Subject !Predicate !Object

Instances

Generic Triple

Defined in Data.RDF.Internal

Associated Types

type Rep Triple :: Type -> Type

Methods

from :: Triple -> Rep Triple x

to :: Rep Triple x -> Triple

Read Triple

Defined in Data.RDF.Internal

Methods

readsPrec :: Int -> ReadS Triple

readList :: ReadS [Triple]

readPrec :: ReadPrec Triple

readListPrec :: ReadPrec [Triple]

Show Triple

Defined in Data.RDF.Internal

Methods

showsPrec :: Int -> Triple -> ShowS

show :: Triple -> String

showList :: [Triple] -> ShowS

NFData Triple

Defined in Data.RDF.Internal

Methods

rnf :: Triple -> ()

Eq Triple

Defined in Data.RDF.Internal

Methods

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

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

Ord Triple

Defined in Data.RDF.Internal

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

type Rep Triple

Defined in Data.RDF.Internal

type Rep Triple = D1 ('MetaData "Triple" "Data.RDF.Internal" "rdf-0.1.0.7-KwPFeMtuF2mFgprU5G6Koq" 'False) (C1 ('MetaCons "Triple" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Subject) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Predicate) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Object))))

Triple Components

data Subject

An RDF subject, i.e. either an IRI or a BlankNode.

This type has an IsString instance, allowing string literals to be interpreted as Subjects with -XOverloadedStrings, like so:

>>> "<http://example.com> :: Subject
IRISubject (IRI (...))
>>> "_:some-node" :: Subject
BlankSubject (BlankNode {unBlankNode = "some-node"})

Constructors

IRISubject !IRI

BlankSubject !BlankNode

Instances

IsString Subject

This instance uses parseSubject and calls error if the literal is invalid. It is not clear exactly when fromString is evaluated so this error is difficult to explictly catch. This can be solved by ensuring that your Subject literals are eagerly evaluated so any malformed literals can be caught immediately. It would be nicer if this happened at compile time.

Defined in Data.RDF.Internal

Methods

fromString :: String -> Subject

Generic Subject

Defined in Data.RDF.Internal

Associated Types

type Rep Subject :: Type -> Type

Methods

from :: Subject -> Rep Subject x

to :: Rep Subject x -> Subject

Read Subject

Defined in Data.RDF.Internal

Methods

readsPrec :: Int -> ReadS Subject

readList :: ReadS [Subject]

readPrec :: ReadPrec Subject

readListPrec :: ReadPrec [Subject]

Show Subject

Defined in Data.RDF.Internal

Methods

showsPrec :: Int -> Subject -> ShowS

show :: Subject -> String

showList :: [Subject] -> ShowS

NFData Subject

Defined in Data.RDF.Internal

Methods

rnf :: Subject -> ()

Eq Subject

Defined in Data.RDF.Internal

Methods

(==) :: Subject -> Subject -> Bool

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

Ord Subject

Defined in Data.RDF.Internal

Methods

compare :: Subject -> Subject -> Ordering

(<) :: Subject -> Subject -> Bool

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

(>) :: Subject -> Subject -> Bool

(>=) :: Subject -> Subject -> Bool

max :: Subject -> Subject -> Subject

min :: Subject -> Subject -> Subject

type Rep Subject

Defined in Data.RDF.Internal

type Rep Subject = D1 ('MetaData "Subject" "Data.RDF.Internal" "rdf-0.1.0.7-KwPFeMtuF2mFgprU5G6Koq" 'False) (C1 ('MetaCons "IRISubject" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 IRI)) :+: C1 ('MetaCons "BlankSubject" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 BlankNode)))

newtype Predicate

An RDF predicate.

This type has an IsString instance, allowing string literals to be interpreted as Predicates with -XOverloadedStrings, like so:

>>> "<http://example.com>" :: Predicate
Predicate {unPredicate = IRI (...)}

Constructors

Predicate

Fields

• unPredicate :: IRI

Instances

IsString Predicate

This instance uses parsePredicate and calls error if the literal is invalid. It is not clear exactly when fromString is evaluated so this error is difficult to explictly catch. This can be solved by ensuring that your Predicate literals are eagerly evaluated so any malformed literals can be caught immediately. It would be nicer if this happened at compile time.

Defined in Data.RDF.Internal

Methods

fromString :: String -> Predicate

Generic Predicate

Defined in Data.RDF.Internal

Associated Types

type Rep Predicate :: Type -> Type

Methods

from :: Predicate -> Rep Predicate x

to :: Rep Predicate x -> Predicate

Read Predicate

Defined in Data.RDF.Internal

Methods

readsPrec :: Int -> ReadS Predicate

readList :: ReadS [Predicate]

readPrec :: ReadPrec Predicate

readListPrec :: ReadPrec [Predicate]

Show Predicate

Defined in Data.RDF.Internal

Methods

showsPrec :: Int -> Predicate -> ShowS

show :: Predicate -> String

showList :: [Predicate] -> ShowS

NFData Predicate

Defined in Data.RDF.Internal

Methods

rnf :: Predicate -> ()

Eq Predicate

Defined in Data.RDF.Internal

Methods

(==) :: Predicate -> Predicate -> Bool

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

Ord Predicate

Defined in Data.RDF.Internal

Methods

compare :: Predicate -> Predicate -> Ordering

(<) :: Predicate -> Predicate -> Bool

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

(>) :: Predicate -> Predicate -> Bool

(>=) :: Predicate -> Predicate -> Bool

max :: Predicate -> Predicate -> Predicate

min :: Predicate -> Predicate -> Predicate

type Rep Predicate

Defined in Data.RDF.Internal

type Rep Predicate = D1 ('MetaData "Predicate" "Data.RDF.Internal" "rdf-0.1.0.7-KwPFeMtuF2mFgprU5G6Koq" 'True) (C1 ('MetaCons "Predicate" 'PrefixI 'True) (S1 ('MetaSel ('Just "unPredicate") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 IRI)))

data Object

An RDF object, i.e. either an IRI, a Literal, or a BlankNode.

This type has an IsString instance, allowing string literals to be interpreted as Objects with -XOverloadedStrings, like so:

>>> "<http://example.com>" :: Object
IRIObject (IRI (...))
>>> "_:some-node" :: Object
BlankObject (BlankNode {unBlankNode = "some-node"})
>>> "computer" :: Object
LiteralObject (Literal {litString = "computer", litType = LiteralUntyped})

The precedence for literal interpretation is IRI > BlankNode > Literal. To force a literal that is also a valid blank node label or IRI to be interpreted as a LiteralObject, wrap it in an extra set of double quotes:

>>> "\"_:some-node\"" :: Object
LiteralObject (Literal {litString = "_:some-node", litType = LiteralUntyped})

Constructors

IRIObject !IRI

BlankObject !BlankNode

LiteralObject !Literal

Instances

IsString Object

This instance uses parseObject and calls error if the literal is invalid. It is not clear exactly when fromString is evaluated so this error is difficult to explictly catch. This can be solved by ensuring that your Object literals are eagerly evaluated so any malformed literals can be caught immediately. It would be nicer if this happened at compile time.

Defined in Data.RDF.Internal

Methods

fromString :: String -> Object

Generic Object

Defined in Data.RDF.Internal

Associated Types

type Rep Object :: Type -> Type

Methods

from :: Object -> Rep Object x

to :: Rep Object x -> Object

Read Object

Defined in Data.RDF.Internal

Methods

readsPrec :: Int -> ReadS Object

readList :: ReadS [Object]

readPrec :: ReadPrec Object

readListPrec :: ReadPrec [Object]

Show Object

Defined in Data.RDF.Internal

Methods

showsPrec :: Int -> Object -> ShowS

show :: Object -> String

showList :: [Object] -> ShowS

NFData Object

Defined in Data.RDF.Internal

Methods

rnf :: Object -> ()

Eq Object

Defined in Data.RDF.Internal

Methods

(==) :: Object -> Object -> Bool

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

Ord Object

Defined in Data.RDF.Internal

Methods

compare :: Object -> Object -> Ordering

(<) :: Object -> Object -> Bool

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

(>) :: Object -> Object -> Bool

(>=) :: Object -> Object -> Bool

max :: Object -> Object -> Object

min :: Object -> Object -> Object

type Rep Object

Defined in Data.RDF.Internal

type Rep Object = D1 ('MetaData "Object" "Data.RDF.Internal" "rdf-0.1.0.7-KwPFeMtuF2mFgprU5G6Koq" 'False) (C1 ('MetaCons "IRIObject" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 IRI)) :+: (C1 ('MetaCons "BlankObject" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 BlankNode)) :+: C1 ('MetaCons "LiteralObject" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Literal))))

Terms

newtype BlankNode

A blank node with its local label, without the preceeding "_:". Other programs processing RDF are permitted to discard these node labels, i.e. all blank node labels are local to a specific representation of an RDF data set.

This type has an IsString instance, allowing string literals to be interpreted as BlankNodes with -XOverloadedStrings, like so:

>>> "_:some-node" :: BlankNode
BlankNode {unBlankNode = "some-node"}

Constructors

BlankNode

Fields

• unBlankNode :: Text

Instances

IsString BlankNode

This instance uses parseBlankNode and calls error if the literal is invalid. It is not clear exactly when fromString is evaluated so this error is difficult to explictly catch. This can be solved by ensuring that your BlankNode literals are eagerly evaluated so any malformed literals can be caught immediately. It would be nicer if this happened at compile time.

Defined in Data.RDF.Internal

Methods

fromString :: String -> BlankNode

Generic BlankNode

Defined in Data.RDF.Internal

Associated Types

type Rep BlankNode :: Type -> Type

Methods

from :: BlankNode -> Rep BlankNode x

to :: Rep BlankNode x -> BlankNode

Read BlankNode

Defined in Data.RDF.Internal

Methods

readsPrec :: Int -> ReadS BlankNode

readList :: ReadS [BlankNode]

readPrec :: ReadPrec BlankNode

readListPrec :: ReadPrec [BlankNode]

Show BlankNode

Defined in Data.RDF.Internal

Methods

showsPrec :: Int -> BlankNode -> ShowS

show :: BlankNode -> String

showList :: [BlankNode] -> ShowS

NFData BlankNode

Defined in Data.RDF.Internal

Methods

rnf :: BlankNode -> ()

Eq BlankNode

Defined in Data.RDF.Internal

Methods

(==) :: BlankNode -> BlankNode -> Bool

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

Ord BlankNode

Defined in Data.RDF.Internal

Methods

compare :: BlankNode -> BlankNode -> Ordering

(<) :: BlankNode -> BlankNode -> Bool

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

(>) :: BlankNode -> BlankNode -> Bool

(>=) :: BlankNode -> BlankNode -> Bool

max :: BlankNode -> BlankNode -> BlankNode

min :: BlankNode -> BlankNode -> BlankNode

type Rep BlankNode

Defined in Data.RDF.Internal

type Rep BlankNode = D1 ('MetaData "BlankNode" "Data.RDF.Internal" "rdf-0.1.0.7-KwPFeMtuF2mFgprU5G6Koq" 'True) (C1 ('MetaCons "BlankNode" 'PrefixI 'True) (S1 ('MetaSel ('Just "unBlankNode") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Text)))

data Literal

An RDF literal. As stipulated by the RDF standard, the litType is merely metadata; all RDF processing programs must try to handle literals that are ill-typed.

This type has an IsString instance, allowing string literals to be interpreted as Literals with -XOverloadedStrings, like so:

>>> "computer" :: Literal
Literal {litString = "computer", litType = LiteralUntyped}

For untyped literals the extra double quotes are not required. They are required for typed literals:

>>> "\"computer\"@en" :: Literal
Literal {litString = "computer", litType = LiteralLangType "en"}

>>> "\"computer\"^^<http://computer.machine/machine>" :: Literal
Literal { litString = "computer", litType = LiteralIRIType (...)}

Constructors

Literal

Fields

• litString :: !Text
• litType :: !LiteralType

Instances

IsString Literal

This instance uses parseLiteral and calls error if the literal is invalid. It is not clear exactly when fromString is evaluated so this error is difficult to explictly catch. This can be solved by ensuring that your Literal literals are eagerly evaluated so any malformed literals can be caught immediately. It would be nicer if this happened at compile time.

Defined in Data.RDF.Internal

Methods

fromString :: String -> Literal

Generic Literal

Defined in Data.RDF.Internal

Associated Types

type Rep Literal :: Type -> Type

Methods

from :: Literal -> Rep Literal x

to :: Rep Literal x -> Literal

Read Literal

Defined in Data.RDF.Internal

Methods

readsPrec :: Int -> ReadS Literal

readList :: ReadS [Literal]

readPrec :: ReadPrec Literal

readListPrec :: ReadPrec [Literal]

Show Literal

Defined in Data.RDF.Internal

Methods

showsPrec :: Int -> Literal -> ShowS

show :: Literal -> String

showList :: [Literal] -> ShowS

NFData Literal

Defined in Data.RDF.Internal

Methods

rnf :: Literal -> ()

Eq Literal

Defined in Data.RDF.Internal

Methods

(==) :: Literal -> Literal -> Bool

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

Ord Literal

Defined in Data.RDF.Internal

Methods

compare :: Literal -> Literal -> Ordering

(<) :: Literal -> Literal -> Bool

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

(>) :: Literal -> Literal -> Bool

(>=) :: Literal -> Literal -> Bool

max :: Literal -> Literal -> Literal

min :: Literal -> Literal -> Literal

type Rep Literal

Defined in Data.RDF.Internal

type Rep Literal = D1 ('MetaData "Literal" "Data.RDF.Internal" "rdf-0.1.0.7-KwPFeMtuF2mFgprU5G6Koq" 'False) (C1 ('MetaCons "Literal" 'PrefixI 'True) (S1 ('MetaSel ('Just "litString") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Text) :*: S1 ('MetaSel ('Just "litType") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 LiteralType)))

data LiteralType

An RDF literal type. As stipulated by the RDF standard, this is merely metadata; all RDF processing programs must try to handle literals that are ill-typed.

Constructors

LiteralIRIType !IRI

LiteralLangType !Text

LiteralUntyped

Instances

Generic LiteralType

Defined in Data.RDF.Internal

Associated Types

type Rep LiteralType :: Type -> Type

Methods

from :: LiteralType -> Rep LiteralType x

to :: Rep LiteralType x -> LiteralType

Read LiteralType

Defined in Data.RDF.Internal

Methods

readsPrec :: Int -> ReadS LiteralType

readList :: ReadS [LiteralType]

readPrec :: ReadPrec LiteralType

readListPrec :: ReadPrec [LiteralType]

Show LiteralType

Defined in Data.RDF.Internal

Methods

showsPrec :: Int -> LiteralType -> ShowS

show :: LiteralType -> String

showList :: [LiteralType] -> ShowS

NFData LiteralType

Defined in Data.RDF.Internal

Methods

rnf :: LiteralType -> ()

Eq LiteralType

Defined in Data.RDF.Internal

Methods

(==) :: LiteralType -> LiteralType -> Bool

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

Ord LiteralType

Defined in Data.RDF.Internal

Methods

compare :: LiteralType -> LiteralType -> Ordering

(<) :: LiteralType -> LiteralType -> Bool

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

(>) :: LiteralType -> LiteralType -> Bool

(>=) :: LiteralType -> LiteralType -> Bool

max :: LiteralType -> LiteralType -> LiteralType

min :: LiteralType -> LiteralType -> LiteralType

type Rep LiteralType

Defined in Data.RDF.Internal

type Rep LiteralType = D1 ('MetaData "LiteralType" "Data.RDF.Internal" "rdf-0.1.0.7-KwPFeMtuF2mFgprU5G6Koq" 'False) (C1 ('MetaCons "LiteralIRIType" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 IRI)) :+: (C1 ('MetaCons "LiteralLangType" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Text)) :+: C1 ('MetaCons "LiteralUntyped" 'PrefixI 'False) (U1 :: Type -> Type)))

IRIs

data IRI

An Internationalized Resource Identifier. This library preferentially follows RFC 3987 over the RDF 1.1 specification, as the two standards disagree about precisely what constitutes an IRI. A notable exception is the handling of IRI fragments; this library follows the RDF 1.1 specification, allowing IRI fragments to occur in absolute IRIs, even though this is expressly prohibited by RFC 3987.

Unlike the network-uri package's behavior with URI fields, this library does not include the sentinel tokens in the parsed fields. For example, when parsing http://example.com, network-uri will provide the string http: as the scheme, while this library will provide http as the scheme.

This type has an IsString instnace, allowing string literals to be interpreted as IRIs with -XOverloadedStrings, like so:

>>> "http://example.com" :: IRI
IRI { iriScheme = "http"
    , iriAuth = Just (IRIAuth { iriUser = Nothing
                              , iriHost = "example.com"
                              , iriPort = Nothing
                              })
    , iriPath = ""
    , iriQuery = Nothing
    , iriFragment = Nothing
    }

Constructors

IRI

Fields

• iriScheme :: !Text

  The IRI scheme, e.g. http

• iriAuth :: !(Maybe IRIAuth)

  The IRI authority, e.g. example.com

• iriPath :: !Text

  The IRI path, e.g. posts/index.html

• iriQuery :: !(Maybe Text)

  The IRI query, i.e. the component after the ? if present.

• iriFragment :: !(Maybe Text)

  The IRI fragment, i.e. the component after the # if present.

Instances

IsString IRI

This instance uses parseIRI and calls error if the literal is invalid. It is not clear exactly when fromString is evaluated so this error is difficult to explictly catch. This can be solved by ensuring that your IRI literals are eagerly evaluated so any malformed literals can be caught immediately. It would be nicer if this happened at compile time.

Defined in Data.RDF.Internal

Methods

fromString :: String -> IRI

Generic IRI

Defined in Data.RDF.Internal

Associated Types

type Rep IRI :: Type -> Type

Methods

from :: IRI -> Rep IRI x

to :: Rep IRI x -> IRI

Read IRI

Defined in Data.RDF.Internal

Methods

readsPrec :: Int -> ReadS IRI

readList :: ReadS [IRI]

readPrec :: ReadPrec IRI

readListPrec :: ReadPrec [IRI]

Show IRI

Defined in Data.RDF.Internal

Methods

showsPrec :: Int -> IRI -> ShowS

show :: IRI -> String

showList :: [IRI] -> ShowS

NFData IRI

Defined in Data.RDF.Internal

Methods

rnf :: IRI -> ()

Eq IRI

Defined in Data.RDF.Internal

Methods

(==) :: IRI -> IRI -> Bool

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

Ord IRI

Defined in Data.RDF.Internal

Methods

compare :: IRI -> IRI -> Ordering

(<) :: IRI -> IRI -> Bool

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

(>) :: IRI -> IRI -> Bool

(>=) :: IRI -> IRI -> Bool

max :: IRI -> IRI -> IRI

min :: IRI -> IRI -> IRI

type Rep IRI

Defined in Data.RDF.Internal

type Rep IRI = D1 ('MetaData "IRI" "Data.RDF.Internal" "rdf-0.1.0.7-KwPFeMtuF2mFgprU5G6Koq" 'False) (C1 ('MetaCons "IRI" 'PrefixI 'True) ((S1 ('MetaSel ('Just "iriScheme") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Text) :*: S1 ('MetaSel ('Just "iriAuth") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (Maybe IRIAuth))) :*: (S1 ('MetaSel ('Just "iriPath") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Text) :*: (S1 ('MetaSel ('Just "iriQuery") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (Maybe Text)) :*: S1 ('MetaSel ('Just "iriFragment") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (Maybe Text))))))

data IRIAuth

An IRI Authority, as described by RFC 3987.

Constructors

IRIAuth

Fields

• iriUser :: !(Maybe Text)

  The IRI user, i.e. the component before the @ if present.

• iriHost :: Text

  The IRI host, e.g. example.com.

• iriPort :: !(Maybe Text)

  The IRI port, i.e. the numeral after the : if present.

Instances

Generic IRIAuth

Defined in Data.RDF.Internal

Associated Types

type Rep IRIAuth :: Type -> Type

Methods

from :: IRIAuth -> Rep IRIAuth x

to :: Rep IRIAuth x -> IRIAuth

Read IRIAuth

Defined in Data.RDF.Internal

Methods

readsPrec :: Int -> ReadS IRIAuth

readList :: ReadS [IRIAuth]

readPrec :: ReadPrec IRIAuth

readListPrec :: ReadPrec [IRIAuth]

Show IRIAuth

Defined in Data.RDF.Internal

Methods

showsPrec :: Int -> IRIAuth -> ShowS

show :: IRIAuth -> String

showList :: [IRIAuth] -> ShowS

NFData IRIAuth

Defined in Data.RDF.Internal

Methods

rnf :: IRIAuth -> ()

Eq IRIAuth

Defined in Data.RDF.Internal

Methods

(==) :: IRIAuth -> IRIAuth -> Bool

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

Ord IRIAuth

Defined in Data.RDF.Internal

Methods

compare :: IRIAuth -> IRIAuth -> Ordering

(<) :: IRIAuth -> IRIAuth -> Bool

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

(>) :: IRIAuth -> IRIAuth -> Bool

(>=) :: IRIAuth -> IRIAuth -> Bool

max :: IRIAuth -> IRIAuth -> IRIAuth

min :: IRIAuth -> IRIAuth -> IRIAuth

type Rep IRIAuth

Defined in Data.RDF.Internal

type Rep IRIAuth = D1 ('MetaData "IRIAuth" "Data.RDF.Internal" "rdf-0.1.0.7-KwPFeMtuF2mFgprU5G6Koq" 'False) (C1 ('MetaCons "IRIAuth" 'PrefixI 'True) (S1 ('MetaSel ('Just "iriUser") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (Maybe Text)) :*: (S1 ('MetaSel ('Just "iriHost") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Text) :*: S1 ('MetaSel ('Just "iriPort") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (Maybe Text)))))