This document is also available in this non-normative format: diff to previous version
Copyright
©
2013
2008-2014
W3C
®
(
MIT
,
ERCIM
,
Keio
,
Beihang
),
All
Rights
Reserved.
W3C
liability
,
trademark
and
document
use
rules
apply.
The Resource Description Framework ( RDF ) is a general-purpose language for representing information in the Web.
This
document
defines
a
textual
syntax
for
RDF
called
Turtle
that
allows
an
RDF
graph
to
be
completely
written
in
a
compact
and
natural
text
form,
with
abbreviations
for
common
usage
patterns
and
datatypes.
Turtle
provides
levels
of
compatibility
with
the
existing
N-Triples
[
N-TRIPLES
]
format
as
well
as
the
triple
pattern
syntax
of
the
SPARQL
W3C
Recommendation.
This section describes the status of this document at the time of its publication. Other documents may supersede this document. A list of current W3C publications and the latest revision of this technical report can be found in the W3C technical reports index at http://www.w3.org/TR/.
This
document
was
published
by
the
RDF
Working
Group
as
a
Candidate
Recommendation
.
Proposed
Recommendation.
This
document
is
intended
to
become
a
W3C
Recommendation
.
Recommendation.
The
W3C
publishes
a
Candidate
Recommendation
to
indicate
that
the
document
is
believed
to
be
stable
Membership
and
other
interested
parties
are
invited
to
encourage
implementation
by
the
developer
community.
See
the
separate
information
on
review
the
Candidate
Recommendation
exit
criteria
document
and
the
available
tests.
This
Candidate
Recommendation
is
expected
to
advance
to
Proposed
Recommendation
in
the
course
of
2013.
If
you
wish
to
make
comments
regarding
this
document,
please
send
them
comments
to
public-rdf-comments@w3.org
(
subscribe
,
archives
).
The
Candidate
Recommendation
period
ends
26
March
2013.
All
feedback
is
welcome.
The
following
feature
is
at
risk
and
may
be
removed:
In
order
to
improve
alignment
Turtle
with
SPARQL
the
Working
Group
proposes
to
add
the
grammar
productions
sparqlPrefix
and
sparqlBase
which
allow
for
using
SPARQL
style
BASE
and
PREFIX
directives
in
a
Turtle
document.
Changes
since
)
through
09
February
2014.
Advisory
Committee
Representatives
should
consult
their
WBS
questionnaires
.
Note
that
substantive
technical
comments
were
expected
during
the
Last
Call
version
(see:
the
HTML
colorized
diffs
):
review
period
that
ended
15
September
2012.
None
of
the
changes
made
since
the
July
10,
2012
start
of
Last
Call
are
considered
to
have
the
effect
of
completely
invalidating
any
previous
review
of
Please
see
the
specification.
Working
Group's
implementation
report
.
Publication
as
a
Candidate
Proposed
Recommendation
does
not
imply
endorsement
by
the
W3C
Membership.
This
is
a
draft
document
and
may
be
updated,
replaced
or
obsoleted
by
other
documents
at
any
time.
It
is
inappropriate
to
cite
this
document
as
other
than
work
in
progress.
This document was produced by a group operating under the 5 February 2004 W3C Patent Policy . W3C maintains a public list of any patent disclosures made in connection with the deliverables of the group; that page also includes instructions for disclosing a patent. An individual who has actual knowledge of a patent which the individual believes contains Essential Claim(s) must disclose the information in accordance with section 6 of the W3C Patent Policy .
This section is non-normative.
This
document
defines
Turtle,
the
Terse
RDF
Triple
Language,
a
concrete
syntax
for
RDF
([
RDF-CONCEPTS
RDF11-CONCEPTS
]).
A Turtle document is a textual representations of an RDF graph. The following Turtle document describes the relationship between Green Goblin and Spiderman.
@base <http://example.org/> .
@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
@prefix foaf: <http://xmlns.com/foaf/0.1/> .
@prefix rel: <http://www.perceive.net/schemas/relationship/> .
<#green-goblin>
rel:enemyOf <#spiderman> ;
a foaf:Person ; # in the context of the Marvel universe
foaf:name "Green Goblin" .
foaf:name "Green Goblin" .
<#spiderman>
rel:enemyOf <#green-goblin> ;
a foaf:Person ;
foaf:name
"Spiderman",
"Человек-паук"@ru
.
foaf:name "Spiderman", "Человек-паук"@ru .
This
example
introduces
many
of
features
of
the
Turtle
language:
@base
and
Relative
IRIs
,
@prefix
and
prefixed
names
,
predicate
lists
separated
by
'
;
',
objects
object
lists
separated
by
'
,
',
the
token
a
,
and
literals
.
The
Turtle
grammar
for
triples
is
a
subset
of
the
SPARQL
Query
Language
for
RDF
[
RDF-SPARQL-QUERY
]
grammar
for
TriplesBlock
.
The
two
grammars
share
production
and
terminal
names
where
possible.
The
construction
of
an
RDF
graph
from
a
Turtle
document
is
defined
in
section
6
Turtle
Grammar
and
section
7
Parsing
.
This section is non-normative.
A Turtle document allows writing down an RDF graph in a compact textual form. An RDF graph is made up of triples consisting of a subject, predicate and object.
Comments
may
be
given
after
a
'
#
'
that
is
not
part
of
another
lexical
token
and
continue
to
the
end
of
the
line.
The
simplest
triple
statement
is
a
sequence
of
(subject,
predicate,
object)
terms,
separated
by
whitespace
and
terminated
by
'
.
'
after
each
triple.
<http://example.org/#spiderman> <http://www.perceive.net/schemas/relationship/enemyOf> <http://example.org/#green-goblin> .
Often
the
same
subject
will
be
referenced
by
a
number
of
predicates.
The
predicateObjectList
production
matches
a
series
of
predicates
and
objects,
separated
by
'
;
',
following
a
subject.
This
expresses
a
series
of
RDF
Triples
with
that
subject
and
each
predicate
and
object
allocated
to
one
triple.
Thus,
the
'
;
'
symbol
is
used
to
repeat
the
subject
of
triples
that
vary
only
in
predicate
and
object
RDF
terms.
These two examples are equivalent ways of writing the triples about Spiderman.
<http://example.org/#spiderman> <http://www.perceive.net/schemas/relationship/enemyOf> <http://example.org/#green-goblin> ;
<http://xmlns.com/foaf/0.1/name> "Spiderman" .
<http://example.org/#spiderman> <http://www.perceive.net/schemas/relationship/enemyOf> <http://example.org/#green-goblin> .
<http://example.org/#spiderman> <http://xmlns.com/foaf/0.1/name> "Spiderman" .
As
with
predicates
often
objects
are
repeated
with
the
same
subject
and
predicate.
The
objectList
production
matches
a
series
of
objects
separated
by
'
,
'
following
a
predicate.
This
expresses
a
series
of
RDF
Triples
with
the
corresponding
subject
and
predicate
and
each
object
allocated
to
one
triple.
Thus,
the
'
,
'
symbol
is
used
to
repeat
the
subject
and
predicate
of
triples
that
only
differ
in
the
object
RDF
term.
These two examples are equivalent ways of writing Spiderman's name in two languages.
<http://example.org/#spiderman> <http://xmlns.com/foaf/0.1/name> "Spiderman", "Человек-паук"@ru .
<http://example.org/#spiderman> <http://xmlns.com/foaf/0.1/name> "Spiderman", "Человек-паук"@ru .
<http://example.org/#spiderman> <http://xmlns.com/foaf/0.1/name> "Spiderman" .
<http://example.org/#spiderman> <http://xmlns.com/foaf/0.1/name> "Человек-паук"@ru .
There are three types of RDF Term defined in RDF Concepts: IRIs (Internationalized Resource Identifiers), literals and blank nodes . Turtle provides a number of ways of writing each.
IRIs
may
be
written
as
relative
or
absolute
IRIs
or
prefixed
names.
Relative
and
absolute
IRIs
are
enclosed
in
'<'
and
'>'
and
may
contain
numeric
escape
sequences
(described
below).
For
example
<http://example.org/#green-goblin>
.
Relative
IRIs
like
<#green-goblin>
are
resolved
relative
to
the
current
base
IRI.
A
new
base
IRI
can
be
defined
using
the
'
@base
'
or
'
BASE
'
directive.
Specifics
of
this
operation
are
defined
in
section
6.3
IRI
References
The
token
'
a
'
in
the
predicate
position
of
a
Turtle
triple
represents
the
IRI
http://www.w3.org/1999/02/22-rdf-syntax-ns#type
.
A
prefixed
name
is
a
prefix
label
and
a
local
part,
separated
by
a
colon
":".
":".
A
prefixed
name
is
turned
into
an
IRI
by
concatenating
the
IRI
associated
with
the
prefix
and
the
local
part.
The
'
@prefix
'
or
'
PREFIX
'
directive
associates
a
prefix
label
with
an
IRI.
Subsequent
'
@prefix
'
or
'
PREFIX
'
directives
may
re-map
the
same
prefix
label.
The
Turtle
language
originally
permitted
only
the
syntax
including
the
'
@
'
character
for
writing
prefix
and
base
directives.
The
case-insensitive
'
PREFIX
'
and
'
BASE
'
forms
were
added
to
align
Turtle's
syntax
with
that
of
SPARQL
.
It
is
advisable
to
serialize
RDF
using
the
'
@prefix
'
and
'
@base
'
forms
until
RDF
1.1
Turtle
parsers
are
widely
deployed.
To
write
http://www.perceive.net/schemas/relationship/enemyOf
using
a
prefixed
name:
http://www.perceive.net/schemas/relationship/
as
rel
somePrefix
rel:enemyOf
somePrefix:enemyOf
which
is
equivalent
to
writing
<http://www.perceive.net/schemas/relationship/enemyOf>
This can be written using either the original Turtle syntax for prefix declarations:
@prefix somePrefix: <http://www.perceive.net/schemas/relationship/> .
<http://example.org/#green-goblin> somePrefix:enemyOf <http://example.org/#spiderman> .
or SPARQL 's syntax for prefix declarations:
PREFIX somePrefix: <http://www.perceive.net/schemas/relationship/>
<http://example.org/#green-goblin> somePrefix:enemyOf <http://example.org/#spiderman> .
Prefixed names are a superset of XML QNames. They differ in that the local part of prefixed names may include:
leg:3032571
or
isbn13:9780136019701
og:video:height
wgs:lat\-long
The following Turtle document contains examples of all the different ways of writing IRIs in Turtle.
# A triple with all absolute IRIs
<http://one.example/subject1> <http://one.example/predicate1> <http://one.example/object1> .
@base <http://one.example/> .
<subject2> <predicate2> <object2> . # relative IRIs, e.g. http://one.example/subject2
BASE <http://one.example/>
<subject2> <predicate2> <object2> . # relative IRIs, e.g. http://one.example/subject2
@prefix p: <http://two.example/> .
p:subject3 p:predicate3 p:object3 . # prefixed name, e.g. http://two.example/subject3
PREFIX p: <http://two.example/>
p:subject3 p:predicate3 p:object3 . # prefixed name, e.g. http://two.example/subject3
@prefix p: <path/> . # prefix p: now stands for http://one.example/path/
p:subject4 p:predicate4 p:object4 . # prefixed name, e.g. http://one.example/path/subject4
@prefix : <http://another.example/> . # empty prefix
:subject5 :predicate5 :object5 . # prefixed name, e.g. http://another.example/subject5
:subject6 a :subject7 . # same as :subject6 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> :subject7 .
<http://伝言.example/?user=أكرم&channel=R%26D> a :subject8 . # a multi-script subject IRI .
The
'
@prefix
'
and
'
@base
'
directives
require
a
trailing
'
.
'
after
the
IRI,
the
equalivent
'
PREFIX
'
and
'
BASE
'
must
not
have
a
trailing
'
.
'
after
the
IRI
part
of
the
directive.
Literals are used to identify values such as strings, numbers, dates.
@prefix foaf: <http://xmlns.com/foaf/0.1/> .
<http://example.org/#green-goblin> foaf:name "Green Goblin" .
<http://example.org/#spiderman> foaf:name "Spiderman" .
Quoted
Literals
(Grammar
production
RDFLiteral
)
have
a
lexical
form
followed
by
a
language
tag,
a
datatype
IRI,
or
neither.
The
representation
of
the
lexical
form
consists
of
an
initial
delimiter,
e.g.
(
U+0022
),
a
sequence
of
permitted
characters
or
numeric
escape
sequence
or
string
escape
sequence
,
and
a
final
delimiter.
The
corresponding
RDF
lexical
form
is
the
characters
between
the
delimiters,
after
processing
any
escape
sequences.
If
present,
the
language
tag
is
preceded
by
a
'
"
"
@
'
(
U+0040
).
If
there
is
no
language
tag,
there
may
be
a
datatype
IRI
,
preceeded
by
'
^^
'
(
U+005E
U+005E
).
The
datatype
IRI
in
Turtle
may
be
written
using
either
an
absolute
IRI
,
a
relative
IRI
,
or
prefixed
name
.
If
there
is
no
datatype
IRI
and
no
language
tag,
the
datatype
is
xsd:string
.
'
\
'
(
U+005C
)
may
not
appear
in
any
quoted
literal
except
as
part
of
an
escape
sequence.
Other
restrictions
depend
on
the
delimiter:
'
(
U+0027
),
may
not
contain
the
characters
'
,
LF
(
U+000A
),
or
CR
(
U+000D
).
"
"
,
may
not
contain
the
characters
"
"
,
LF
,
or
CR
.
'''
may
not
contain
the
sequence
of
characters
'''
.
"""
"""
may
not
contain
the
sequence
of
characters
"""
"""
.
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
@prefix show: <http://example.org/vocab/show/> .
show:218 rdfs:label "That Seventies Show"^^xsd:string . # literal with XML Schema string datatype
show:218 rdfs:label "That Seventies Show"^^<http://www.w3.org/2001/XMLSchema#string> . # same as above
show:218 rdfs:label "That Seventies Show" . # same again
show:218 show:localName "That Seventies Show"@en . # literal with a language tag
show:218 rdfs:label "That Seventies Show"^^xsd:string . # literal with XML Schema string datatype
show:218 rdfs:label "That Seventies Show"^^<http://www.w3.org/2001/XMLSchema#string> . # same as above
show:218 rdfs:label "That Seventies Show" . # same again
show:218 show:localName "That Seventies Show"@en . # literal with a language tag
show:218 show:localName 'Cette Série des Années Soixante-dix'@fr . # literal delimited by single quote
show:218 show:localName "Cette Série des Années Septante"@fr-be . # literal with a region subtag
show:218 show:localName "Cette Série des Années Septante"@fr-be . # literal with a region subtag
show:218 show:blurb '''This is a multi-line # literal with embedded new lines and quotes
literal with many quotes (""""")
literal with many quotes (""""")
and up to two sequential apostrophes ('').''' .
Numbers
can
be
written
like
other
literals
with
lexical
form
and
datatype
(e.g.
).
Turtle
has
a
shorthand
syntax
for
writing
integer
values,
arbitrary
precision
decimal
values,
and
double
precision
floating
point
values.
"-5.0"^^xsd:decimal
"-5.0"^^xsd:decimal
Data Type | Abbreviated | Lexical | Description |
---|---|---|---|
xsd:integer |
-5
|
|
Integer
values
may
be
written
as
an
optional
sign
and
a
series
of
digits.
Integers
match
the
regular
expression
[+-]?[0-9]+
|
xsd:decimal |
-5.0
|
|
Arbitrary-precision
decimals
may
be
written
as
an
optional
sign,
zero
or
more
digits,
a
decimal
point
and
one
or
more
digits.
Decimals
match
the
regular
expression
[+-]?[0-9]*\.[0-9]+
|
xsd:double |
4.2E9
|
|
Double-precision
floating
point
values
may
be
written
as
an
optionally
signed
mantissa
with
an
optional
decimal
point,
the
letter
[+-]?[0-9]+
[+-]?[0-9]+\.[0-9]+
[+-]?\.[0-9]+
[+-]?[0-9]
|
@prefix : <http://example.org/elements> .
<http://en.wikipedia.org/wiki/Helium>
:atomicNumber 2 ; # xsd:integer
:atomicMass 4.002602 ; # xsd:decimal
:specificGravity 1.663E-4 . # xsd:double
Boolean
values
may
be
written
as
either
'
true
'
or
'
false
'
(case-sensitive)
and
represent
RDF
literals
with
the
datatype
xsd:boolean
.
@prefix : <http://example.org/stats> .
<http://somecountry.example/census2007>
:isLandlocked false . # xsd:boolean
RDF
blank
nodes
in
Turtle
are
expressed
as
_:
followed
by
a
blank
node
label
which
is
a
series
of
name
characters.
The
characters
in
the
label
are
built
upon
PN_CHARS_BASE
,
liberalized
as
follows:
_
and
digits
may
appear
anywhere
in
a
blank
node
label.
.
may
appear
anywhere
except
the
first
or
last
character.
-
,
U+00B7
,
U+0300
to
U+036F
and
U+203F
to
U+2040
are
permitted
anywhere
except
the
first
character.
A fresh RDF blank node is allocated for each unique blank node label in a document. Repeated use of the same blank node label identifies the same RDF blank node.
@prefix foaf: <http://xmlns.com/foaf/0.1/> .
_:alice foaf:knows _:bob .
_:bob foaf:knows _:alice .
In Turtle, fresh RDF blank nodes are also allocated when matching the production blankNodePropertyList and the terminal ANON . Both of these may appear in the subject or object position of a triple (see the Turtle Grammar). That subject or object is a fresh RDF blank node. This blank node also serves as the subject of the triples produced by matching the predicateObjectList production embedded in a blankNodePropertyList. The generation of these triples is described in Predicate Lists . Blank nodes are also allocated for collections described below.
@prefix foaf: <http://xmlns.com/foaf/0.1/> .
# Someone knows someone else, who has the name "Bob".
[] foaf:knows [ foaf:name "Bob" ] .
The
Turtle
grammar
allows
blankNodePropertyList
s
to
be
nested.
In
this
case,
each
inner
[
establishes
a
new
subject
blank
node
which
reverts
to
the
outer
node
at
the
]
,
and
serves
as
the
current
subject
for
predicate
object
lists
.
The use of predicateObjectList within a blankNodePropertyList is a common idiom for representing a series of properties of a node.
Abbreviated:
@prefix foaf: <http://xmlns.com/foaf/0.1/> .
[ foaf:name "Alice" ] foaf:knows [
foaf:name "Bob" ;
foaf:knows [
foaf:name "Eve" ] ;
foaf:mbox <bob@example.com> ] .
Corresponding simple triples:
_:a <http://xmlns.com/foaf/0.1/name> "Alice" .
_:a <http://xmlns.com/foaf/0.1/knows> _:b .
_:b <http://xmlns.com/foaf/0.1/name> "Bob" .
_:b <http://xmlns.com/foaf/0.1/name> "Bob" .
_:b <http://xmlns.com/foaf/0.1/knows> _:c .
_:c <http://xmlns.com/foaf/0.1/name> "Eve" .
_:c <http://xmlns.com/foaf/0.1/name> "Eve" .
_:b <http://xmlns.com/foaf/0.1/mbox> <bob@example.com> .
RDF
provides
a
Collection
[
RDF-MT
]
structure
for
lists
of
RDF
nodes.
The
Turtle
syntax
for
Collections
is
a
possibly
empty
list
of
RDF
terms
enclosed
by
()
.
This
collection
represents
an
rdf:first
/
rdf:rest
list
structure
with
the
sequence
of
objects
of
the
rdf:first
statements
being
the
order
of
the
terms
enclosed
by
()
.
The
(…)
syntax
must
MUST
appear
in
the
subject
or
object
position
of
a
triple
(see
the
Turtle
Grammar).
The
blank
node
at
the
head
of
the
list
is
the
subject
or
object
of
the
containing
triple.
@prefix : <http://example.org/foo> .
# the object of this triple is the collection blank node
# the object of this triple is the RDF collection blank node
:subject :predicate ( :a :b :c ) .
# an empty collection value - rdf:nil
:subject :predicate2 () .
This section is non-normative.
This example is a Turtle translation of example 7 in the RDF /XML Syntax specification ( example1.ttl ):
@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> . @prefix dc: <http://purl.org/dc/elements/1.1/> . @prefix ex: <http://example.org/stuff/1.0/> . <http://www.w3.org/TR/rdf-syntax-grammar>dc:title "/XML Syntax Specification (Revised)" ;dc:title "RDF/XML Syntax Specification (Revised)" ; ex:editor [ex:fullname "Dave Beckett";ex:fullname "Dave Beckett"; ex:homePage <http://purl.org/net/dajobe/>] .] .
An example of an RDF collection of two literals.
PREFIX : <http://example.org/stuff/1.0/>
:a :b ( "apple" "banana" ) .
which is short for ( example2.ttl ):
@prefix : <http://example.org/stuff/1.0/> . @prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> . :a :b[ rdf:first "apple"; rdf:rest [ rdf:first "banana";[ rdf:first "apple"; rdf:rest [ rdf:first "banana"; rdf:rest rdf:nil ]] .] .
An example of two identical triples containing literal objects containing newlines, written in plain and long literal forms. The line breaks in this example are LINE FEED characters (U+000A). ( example3.ttl ):
@prefix : <http://example.org/stuff/1.0/> . :a :b "The first line\nThe second line\n more" . :a :b """The first line The second linemore""" .more""" .
As
indicated
by
the
grammar,
a
collection
can
be
either
a
subject
or
an
object
.
This
subject
or
object
will
be
the
novel
blank
node
for
the
first
object,
if
the
collection
has
one
or
more
objects,
or
rdf:nil
if
the
collection
is
empty.
For example,
@prefix : <http://example.org/stuff/1.0/> .
(1 2.0 3E1) :p "w" .
is
syntactic
sugar
for
(noting
that
the
blank
nodes
b0
,
b1
and
b2
do
not
occur
anywhere
else
in
the
RDF
graph):
@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
_:b0 rdf:first 1 ;
rdf:rest _:b1 .
_:b1 rdf:first 2.0 ;
rdf:rest _:b2 .
_:b2 rdf:first 3E1 ;
rdf:rest rdf:nil .
_:b0
:p
"w"
.
_:b0 :p "w" .
RDF collections can be nested and can involve other syntactic forms:
PREFIX : <http://example.org/stuff/1.0/>
(1 [:p :q] ( 2 ) ) :p2 :q2 .
is syntactic sugar for:
@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
_:b0 rdf:first 1 ;
rdf:rest _:b1 .
_:b1 rdf:first _:b2 .
_:b2 :p :q .
_:b1 rdf:rest _:b3 .
_:b3 rdf:first _:b4 .
_:b4 rdf:first 2 ;
rdf:rest rdf:nil .
_:b3
rdf:rest
rdf:nil
.
_:b3 rdf:rest rdf:nil .
This section is non-normative.
The SPARQL Query Language for RDF ( SPARQL ) [ RDF-SPARQL-QUERY ] uses a Turtle style syntax for its TriplesBlock production . This production differs from the Turtle language in that:
?
name
or
$
name
)
in
any
part
of
the
triple
of
the
form.
a
'.
Turtle's
@prefix
and
@base
declarations
are
case
PREFIX
and
BASE
are
case
insensitive.
true
'
and
'
false
'
are
case
insensitive
in
SPARQL
and
case
sensitive
in
Turtle.
TrUe
is
not
a
valid
boolean
value
in
Turtle.
For further information see the Syntax for IRIs and SPARQL Grammar sections of the SPARQL query document [ RDF-SPARQL-QUERY ].
As well as sections marked as non-normative, all authoring guidelines, diagrams, examples, and notes in this specification are non-normative. Everything else in this specification is normative.
The
key
words
must
MUST
,
must
not
MUST
NOT
,
required
REQUIRED
,
should
SHOULD
,
should
not
SHOULD
NOT
,
recommended
RECOMMENDED
,
may
MAY
,
and
optional
OPTIONAL
in
this
specification
are
to
be
interpreted
as
described
in
[
RFC2119
].
This specification defines conformance criteria for:
A
conforming
Turtle
document
is
a
Unicode
string
that
conforms
to
the
grammar
and
additional
constraints
defined
in
section
6
6.
Turtle
Grammar
,
starting
with
the
turtleDoc
production
.
A
Turtle
document
serializes
an
RDF
graph.
Graph.
A
conforming
Turtle
parser
is
a
system
capable
of
reading
Turtle
documents
on
behalf
of
an
application.
It
makes
the
serialized
RDF
graph,
dataset,
as
defined
in
section
7
7.
Parsing
,
available
to
the
application,
usually
through
some
form
of
API.
The
IRI
that
identifies
the
Turtle
language
is:
http://www.w3.org/ns/formats/Turtle
This specification does not define how Turtle parsers handle non-conforming input documents.
The
media
type
of
Turtle
is
text/turtle
.
The
content
encoding
of
Turtle
content
is
always
UTF-8.
Charset
parameters
on
the
mime
type
are
required
until
such
time
as
the
text/
media
type
tree
permits
UTF-8
to
be
sent
without
a
charset
parameter.
See
section
B
B.
Internet
Media
Type,
File
Extension
and
Macintosh
File
Type
for
the
media
type
registration
form.
A Turtle document is a Unicode[ UNICODE ] character string encoded in UTF-8. Unicode characters only in the range U+0000 to U+10FFFF inclusive are allowed.
White space (production WS ) is used to separate two terminals which would otherwise be (mis-)recognized as one terminal. Rule names below in capitals indicate where white space is significant; these form a possible choice of terminals for constructing a Turtle parser.
White space is significant in the production String .
Comments in Turtle take the form of '#', outside an IRIREF or String , and continue to the end of line (marked by characters U+000D or U+000A) or end of file if there is no end of line after the comment marker. Comments are treated as white space.
Relative IRIs are resolved with base IRIs as per Uniform Resource Identifier (URI): Generic Syntax [ RFC3986 ] using only the basic algorithm in section 5.2. Neither Syntax-Based Normalization nor Scheme-Based Normalization (described in sections 6.2.2 and 6.2.3 of RFC3986) are performed. Characters additionally allowed in IRI references are treated in the same way that unreserved characters are treated in URI references, per section 6.5 of Internationalized Resource Identifiers (IRIs) [ RFC3987 ].
The
@base
or
BASE
directive
defines
the
Base
IRI
used
to
resolve
relative
IRIs
per
RFC3986
section
5.1.1,
"Base
"Base
URI
Embedded
in
Content".
Content".
Section
5.1.2,
"Base
"Base
URI
from
the
Encapsulating
Entity"
Entity"
defines
how
the
In-Scope
Base
IRI
may
come
from
an
encapsulating
document,
such
as
a
SOAP
envelope
with
an
xml:base
directive
or
a
mime
multipart
document
with
a
Content-Location
header.
The
"Retrieval
URI"
"Retrieval
URI"
identified
in
5.1.3,
Base
"URI
"URI
from
the
Retrieval
URI",
URI",
is
the
URL
from
which
a
particular
Turtle
document
was
retrieved.
If
none
of
the
above
specifies
the
Base
URI,
the
default
Base
URI
(section
5.1.4,
"Default
"Default
Base
URI")
URI")
is
used.
Each
@base
or
BASE
directive
sets
a
new
In-Scope
Base
URI,
relative
to
the
previous
one.
There are three forms of escapes used in turtle documents:
numeric escape sequences represent Unicode code points:
Escape sequence | Unicode code point |
---|---|
'\u' hex hex hex hex | A Unicode character in the range U+0000 to U+FFFF inclusive corresponding to the value encoded by the four hexadecimal digits interpreted from most significant to least significant digit. |
'\U' hex hex hex hex hex hex hex hex | A Unicode character in the range U+0000 to U+10FFFF inclusive corresponding to the value encoded by the eight hexadecimal digits interpreted from most significant to least significant digit. |
where HEX is a hexadecimal character
HEX ::= [0-9] | [A-F] | [a-f]
string escape sequences represent the characters traditionally escaped in string literals:
Escape sequence | Unicode code point |
---|---|
'\t' | U+0009 |
'\b' | U+0008 |
'\n' | U+000A |
'\r' | U+000D |
'\f' | U+000C |
|
U+0022 |
'\'' | U+0027 |
'\\' | U+005C |
reserved
character
escape
sequences
consist
of
a
'\'
followed
by
one
of
~.-!$&'()*+,;=/?#@%_
and
represent
the
character
to
the
right
of
the
'\'.
numeric
escapes |
string
escapes |
reserved
character
escapes |
|
---|---|---|---|
IRI
s,
used
as
RDF
terms
or
as
in
@prefix
|
yes | no | no |
local name s | no | no | yes |
String s | yes | yes | no |
%-encoded
sequences
are
in
the
character
range
for
IRIs
and
are
explicitly
allowed
in
local
names.
These
appear
as
a
'%'
followed
by
two
hex
characters
and
represent
that
same
sequence
of
three
characters.
These
sequences
are
not
decoded
during
processing.
A
term
written
as
<http://a.example/%66oo-bar>
in
Turtle
designates
the
IRI
http://a.example/%66oo-bar
and
not
IRI
http://a.example/foo-bar
.
A
term
written
as
ex:%66oo-bar
with
a
prefix
@prefix
ex:
<http://a.example/>
also
designates
the
IRI
http://a.example/%66oo-bar
.
The EBNF used here is defined in XML 1.0 [ EBNF-NOTATION ]. Production labels consisting of a number and a final 's', e.g. [ 60s ], reference the production with that number in the SPARQL Query Language for RDF grammar [ RDF-SPARQL-QUERY ].
Notes:
@base
',
'
@prefix
',
'
a
',
'
true
',
'
false
')
are
case-sensitive.
Keywords
in
double
quotes
BASE
PREFIX
UCHAR
and
ECHAR
are
case
sensitive.
turtleDoc
.
ANON
::=
'
[
'
WS
*
'
]
'
token
allows
any
amount
of
white
space
and
comments
between
[]
s.
The
single
space
version
is
used
in
the
grammar
for
clarity.
@prefix
'
and
'
@base
'
match
the
pattern
for
LANGTAG
,
though
neither
prefix
base
"A"@base
"A"@base
)
is
in
the
Turtle
language.
[1] |
turtleDoc
|
::= |
statement
*
|
[2] |
statement
|
::= |
directive
|
triples
'
.
'
|
[3] |
directive
|
::= |
prefixID
|
base
|
sparqlPrefix
|
sparqlBase
|
[4] |
prefixID
|
::= |
'
@prefix
'
PNAME_NS
IRIREF
'
.
'
|
[5] |
base
|
::= |
'
@base
'
IRIREF
'
.
'
|
[5s] |
sparqlBase
|
::= |
BASE
|
[6s] |
sparqlPrefix
|
::= |
PREFIX
|
[6] |
triples
|
::= |
subject
predicateObjectList
|
blankNodePropertyList
predicateObjectList
?
|
[7] |
predicateObjectList
|
::= |
verb
objectList
('
;
'
(
verb
objectList
)?)
*
|
[8] |
objectList
|
::= |
object
('
,
'
object
)
*
|
[9] |
verb
|
::= |
predicate
|
'
a
'
|
[10] |
subject
|
::= |
iri
|
BlankNode
|
collection
|
[11] |
predicate
|
::= | iri |
[12] |
object
|
::= |
iri
|
BlankNode
|
collection
|
blankNodePropertyList
|
literal
|
[13] |
literal
|
::= |
RDFLiteral
|
NumericLiteral
|
BooleanLiteral
|
[14] |
blankNodePropertyList
|
::= |
'
[
'
predicateObjectList
'
]
'
|
[15] |
collection
|
::= |
'
(
'
object
*
'
)
'
|
[16] |
NumericLiteral
|
::= |
INTEGER
|
DECIMAL
|
DOUBLE
|
[128s] |
RDFLiteral
|
::= |
String
(
LANGTAG
|
'
^^
'
iri
)?
|
[133s] |
BooleanLiteral
|
::= |
'
true
'
|
'
false
'
|
[17] |
String
|
::= |
STRING_LITERAL_QUOTE
|
STRING_LITERAL_SINGLE_QUOTE
|
STRING_LITERAL_LONG_SINGLE_QUOTE
|
STRING_LITERAL_LONG_QUOTE
|
[135s] |
iri
|
::= |
IRIREF
|
PrefixedName
|
[136s] |
PrefixedName
|
::= |
PNAME_LN
|
PNAME_NS
|
[137s] |
BlankNode
|
::= |
BLANK_NODE_LABEL
|
ANON
|
Productions for terminals |
|||
[18] |
IRIREF
|
::= |
'
<
'
([
]
|
UCHAR
)
*
'
>
'
/*
#x00=NULL
#01-#x1F=control
codes
#x20=space
*/
|
[139s] |
PNAME_NS
|
::= |
PN_PREFIX
?
'
:
'
|
[140s] |
PNAME_LN
|
::= | PNAME_NS PN_LOCAL |
[141s] |
BLANK_NODE_LABEL
|
::= |
'
_:
'
(
PN_CHARS_U
|
[
0-9
])
((
PN_CHARS
|
'
.
')
*
PN_CHARS
)?
|
[144s] |
LANGTAG
|
::= |
'
@
'
[
a-zA-Z
]
+
('
-
'
[
a-zA-Z0-9
]
+
)
*
|
[19] |
INTEGER
|
::= |
[
+-
]?
[
0-9
]
+
|
[20] |
DECIMAL
|
::= |
[
+-
]?
[
0-9
]
*
'
.
'
[
0-9
]
+
|
[21] |
DOUBLE
|
::= |
[
+-
]?
([
0-9
]
+
'
.
'
[
0-9
]
*
EXPONENT
|
'
.
'
[
0-9
]
+
EXPONENT
|
[
0-9
]
+
|
[154s] |
EXPONENT
|
::= |
[
eE
]
[
+-
]?
[
0-9
]
+
|
[22] |
STRING_LITERAL_QUOTE
|
::= |
'
'
([
^#x22#x5C#xA#xD
]
|
ECHAR
|
UCHAR
)
*
'
'
/*
#x22="
#x5C=\
#xA=new
line
#xD=carriage
return
*/
|
[23] |
STRING_LITERAL_SINGLE_QUOTE
|
::= |
'
^#x27#x5C#xA#xD
]
|
ECHAR
|
UCHAR
)
*
'
|
[24] |
STRING_LITERAL_LONG_SINGLE_QUOTE
|
::= |
'''
'
|
''
^'\
]
|
ECHAR
|
UCHAR
)
*
'''
|
[25] |
STRING_LITERAL_LONG_QUOTE
|
::= |
'
'
(('
'
|
'
')?
[
]
|
ECHAR
|
UCHAR
)
*
'
'
|
[26] |
UCHAR
|
::= |
'
\u
'
HEX
HEX
HEX
HEX
|
'
\U
'
HEX
HEX
HEX
HEX
HEX
HEX
HEX
HEX
|
[159s] |
ECHAR
|
::= |
'
\
'
[
]
|
[161s] |
WS
|
::= |
#x20
|
#x9
|
#xD
|
#xA
/*
#x20=space
#x9=character
tabulation
#xD=carriage
return
#xA=new
line
*/
|
[162s] |
ANON
|
::= |
'
[
'
WS
*
'
]
'
|
[163s] |
PN_CHARS_BASE
|
::= |
[
A-Z
]
|
[
a-z
]
|
[
]
|
[
]
|
[
]
|
[
]
|
[
]
|
[
]
|
[
]
|
[
]
|
[
]
|
[
]
|
[
]
|
[
]
|
[164s] |
PN_CHARS_U
|
::= |
PN_CHARS_BASE
|
'
_
'
|
[166s] |
PN_CHARS
|
::= |
PN_CHARS_U
|
'
-
'
|
[
0-9
]
|
|
[
]
|
[
]
|
[167s] |
PN_PREFIX
|
::= |
PN_CHARS_BASE
((
PN_CHARS
|
'
.
')
*
PN_CHARS
)?
|
[168s] |
PN_LOCAL
|
::= |
(
PN_CHARS_U
|
'
:
'
|
[
0-9
]
|
PLX
)
((
PN_CHARS
|
'
.
'
|
'
:
'
|
PLX
)
*
(
PN_CHARS
|
'
:
'
|
PLX
))?
|
[169s] |
PLX
|
::= |
PERCENT
|
PN_LOCAL_ESC
|
[170s] |
PERCENT
|
::= |
'
%
'
HEX
HEX
|
[171s] |
HEX
|
::= |
[
0-9
]
|
[
A-F
]
|
[
a-f
]
|
[172s] |
PN_LOCAL_ESC
|
::= |
'
\
'
('
_
'
|
'
~
'
|
'
.
'
|
'
-
'
|
'
!
'
|
'
$
'
|
'
&
'
|
'
|
'
(
'
|
'
)
'
|
'
*
'
|
'
+
'
|
'
,
'
|
'
;
'
|
'
=
'
|
'
/
'
|
'
?
'
|
'
#
'
|
'
@
'
|
'
%
')
|
The
RDF
1.1
Concepts
and
Abstract
Syntax
specification
([
RDF-CONCEPTS
RDF11-CONCEPTS
])
specification
defines
three
types
of
RDF
Term
:
IRIs
,
literals
and
blank
nodes
.
Literals
are
composed
of
a
lexical
form
and
an
optional
language
tag
[
BCP47
]
or
datatype
IRI.
An
extra
type,
prefix
,
is
used
during
parsing
to
map
string
identifiers
to
namespace
IRIs.
This
section
maps
a
string
conforming
to
the
grammar
in
section
6.5
Grammar
to
a
set
of
triples
by
mapping
strings
matching
productions
and
lexical
tokens
to
RDF
terms
or
their
components
(e.g.
language
tags,
lexical
forms
of
literals).
Grammar
productions
change
the
parser
state
and
emit
triples.
Parsing Turtle requires a state of five items:
baseURI
—
When
the
base
production
is
reached,
the
second
rule
argument,
IRIREF
,
is
the
base
URI
used
for
relative
IRI
namespaces
—
The
second
and
third
rule
arguments
(
PNAME_NS
and
IRIREF
)
in
the
prefixID
production
assign
a
namespace
name
(
IRIREF
)
for
the
prefix
(
PNAME_NS
).
Outside
of
a
prefixID
production,
any
PNAME_NS
is
substituted
with
the
PNAME_NS,
PNAME_NS
production:
(PN_PREFIX)?
":"
(test:
default1
)
.
":"
.
bnodeLabels
—
A
mapping
from
string
to
blank
node.
curSubject
—
The
curSubject
is
bound
to
the
subject
production.
curPredicate
—
The
curPredicate
is
bound
to
the
verb
production.
If
token
matched
was
a
curPredicate
is
bound
to
the
IRI
http://www.w3.org/1999/02/22-rdf-syntax-ns#type
(test:
type
)
.
.
This
table
maps
productions
and
lexical
tokens
to
RDF
terms
or
components
of
RDF
terms
listed
in
section
7
7.
Parsing
:
production | type | procedure |
---|---|---|
IRIREF | IRI |
The
characters
between
|
PNAME_NS | prefix |
When
used
in
a
prefixID
or
sparqlPrefix
production,
the
prefix
is
the
potentially
empty
unicode
string
matching
the
first
argument
of
the
rule
is
a
key
into
the
namespaces
map
.
|
IRI |
When
used
in
a
PrefixedName
production,
the
iri
is
the
value
in
the
namespaces
map
corresponding
to
the
first
argument
of
the
rule.
|
|
PNAME_LN | IRI |
A
potentially
empty
prefix
is
identified
by
the
first
sequence,
PNAME_NS
.
The
namespaces
map
namespace
.
The
unicode
string
of
the
IRI
is
formed
by
unescaping
the
reserved
characters
in
the
second
argument,
PN_LOCAL
,
and
concatenating
this
onto
the
namespace
.
|
STRING_LITERAL_SINGLE_QUOTE | lexical form |
The
characters
between
the
outermost
|
STRING_LITERAL_QUOTE | lexical form |
The
characters
between
the
outermost
|
STRING_LITERAL_LONG_SINGLE_QUOTE | lexical form |
The
characters
between
the
outermost
|
STRING_LITERAL_LONG_QUOTE | lexical form |
The
characters
between
the
outermost
|
LANGTAG | language tag |
The
characters
following
the
@
form
the
unicode
string
of
the
language
tag.
|
RDFLiteral | literal |
The
literal
has
a
lexical
form
of
the
first
rule
argument,
String
.
If
the
'^^'
iri
rule
matched,
the
datatype
is
iri
and
LANGTAG
and
the
LANGTAG
.
If
neither
matched,
the
xsd:string
and
the
literal
has
no
language
tag.
|
INTEGER | literal |
The
literal
has
a
lexical
form
of
the
input
string,
and
a
datatype
of
xsd:integer
.
|
DECIMAL | literal |
The
literal
has
a
lexical
form
of
the
input
string,
and
a
datatype
of
xsd:decimal
.
|
DOUBLE | literal |
The
literal
has
a
lexical
form
of
the
input
string,
and
a
datatype
of
xsd:double
.
|
BooleanLiteral | literal |
The
literal
has
a
lexical
form
of
the
true
or
false
,
depending
on
which
matched
the
input,
and
a
datatype
of
xsd:boolean
.
|
BLANK_NODE_LABEL | blank node |
The
string
matching
the
second
argument,
PN_LOCAL
,
is
a
key
in
bnodeLabels
.
If
there
is
no
corresponding
blank
node
in
the
map,
one
is
allocated.
|
ANON | blank node | A blank node is generated. |
blankNodePropertyList | blank node |
A
blank
node
is
generated.
Note
the
rules
for
blankNodePropertyList
in
the
next
section.
|
collection | blank node |
For
non-empty
lists,
a
blank
node
is
generated.
Note
the
rules
for
collection
in
the
next
section.
|
IRI |
For
empty
lists,
the
resulting
IRI
is
rdf:nil
.
Note
the
rules
for
collection
in
the
next
section.
|
A
Turtle
document
defines
an
RDF
graph
composed
of
set
of
RDF
triple
s.
The
subject
production
sets
the
curSubject
.
The
verb
production
sets
the
curPredicate
.
Each
object
N
in
the
document
produces
an
RDF
triple:
curSubject
curPredicate
N
.
Beginning
the
blankNodePropertyList
production
records
the
curSubject
and
curPredicate
,
and
sets
curSubject
to
a
novel
blank
node
B
.
Finishing
the
blankNodePropertyList
production
restores
curSubject
and
curPredicate
.
The
node
produced
by
matching
blankNodePropertyList
is
the
blank
node
B
.
Beginning
the
collection
production
records
the
curSubject
and
curPredicate
.
Each
object
in
the
collection
production
has
a
curSubject
set
to
a
novel
blank
node
B
and
a
curPredicate
set
to
rdf:first
.
For
each
object
object
n
after
the
first
produces
a
triple:
object
n-1
rdf:rest
object
n
.
Finishing
the
collection
production
creates
an
additional
triple
curSubject
rdf:rest
rdf:nil
.
and
restores
curSubject
and
curPredicate
The
node
produced
by
matching
collection
is
the
first
blank
node
B
for
non-empty
lists
and
rdf:nil
for
empty
lists.
This section is non-normative.
The following informative example shows the semantic actions performed when parsing this Turtle document with an LALR(1) parser:
@prefix ericFoaf: <http://www.w3.org/People/Eric/ericP-foaf.rdf#> .
@prefix : <http://xmlns.com/foaf/0.1/> .
ericFoaf:ericP :givenName "Eric" ;
ericFoaf:ericP :givenName "Eric" ;
:knows <http://norman.walsh.name/knows/who/dan-brickley> ,
[ :mbox <mailto:timbl@w3.org> ] ,
<http://getopenid.com/amyvdh> .
ericFoaf
to
the
IRI
http://www.w3.org/People/Eric/ericP-foaf.rdf#
.
http://xmlns.com/foaf/0.1/
.
curSubject
the
IRI
http://www.w3.org/People/Eric/ericP-foaf.rdf#ericP
.
curPredicate
the
IRI
http://xmlns.com/foaf/0.1/givenName
.
<...rdf#ericP>
<.../givenName>
"Eric"
"Eric"
.
curPredicate
the
IRI
http://xmlns.com/foaf/0.1/knows
.
<...rdf#ericP>
<.../knows>
<...who/dan-brickley>
.
<...rdf#ericP>
<.../knows>
_:1
.
curSubject
and
reassign
to
the
blank
node
_:1
.
curPredicate
.
curPredicate
the
IRI
http://xmlns.com/foaf/0.1/mbox
.
_:1
<.../mbox>
<mailto:timbl@w3.org>
.
curSubject
and
curPredicate
to
their
saved
values
(
<...rdf#ericP>
,
<.../knows>
).
<...rdf#ericP>
<.../knows>
<http://getopenid.com/amyvdh>
.
This section is non-normative.
HTML
([
HTML5
])
script
tags
can
be
used
to
embed
data
blocks
in
documents.
Turtle
can
be
easily
embedded
in
HTML
this
way.
<script type="text/turtle"> @prefix dc: <http://purl.org/dc/terms/> . @prefix frbr: <http://purl.org/vocab/frbr/core#> . <http://books.example.com/works/45U8QJGZSQKDH8N> a frbr:Work ;dc:creator "Wil Wheaton"@en ; dc:title "Just a Geek"@en ;dc:creator "Wil Wheaton"@en ; dc:title "Just a Geek"@en ; frbr:realization <http://books.example.com/products/9780596007683.BOOK>, <http://books.example.com/products/9780596802189.EBOOK> . <http://books.example.com/products/9780596007683.BOOK> a frbr:Expression ; dc:type <http://books.example.com/product-types/BOOK> . <http://books.example.com/products/9780596802189.EBOOK> a frbr:Expression ; dc:type <http://books.example.com/product-types/EBOOK> . </script>
Turtle
content
should
be
placed
in
a
script
tag
with
the
type
attribute
set
to
text/turtle
.
<
and
>
symbols
do
not
need
to
be
escaped
inside
of
script
tags.
The
character
encoding
of
the
embedded
Turtle
will
match
the
HTML
documents
encoding.
This section is non-normative.
Like
JavaScript,
Turtle
authored
for
HTML
(
text/html
)
can
break
when
used
in
XHTML
(
application/xhtml+xml
).
The
solution
is
the
same
one
used
for
JavaScript.
<script type="text/turtle"> # <![CDATA[ @prefix frbr: <http://purl.org/vocab/frbr/core#> . <http://books.example.com/works/45U8QJGZSQKDH8N> a frbr:Work . # ]]> </script>
When
embedded
in
XHTML
Turtle
data
blocks
must
be
enclosed
in
CDATA
sections.
Those
CDATA
markers
must
be
in
Turtle
comments.
If
the
character
sequence
"
"
]]>
"
"
occurs
in
the
document
it
must
be
escaped
using
strings
escapes
(
\u005d\u0054\u003e
).
This
will
also
make
Turtle
safe
in
polyglot
documents
served
as
both
text/html
and
application/xhtml+xml
.
Failing
to
use
CDATA
sections
or
escape
"
"
]]>
"
"
may
result
in
a
non
well-formed
XML
document.
This section is non-normative.
There
are
no
syntactic
or
grammar
differences
between
parsing
Turtle
that
has
been
embedded
and
normal
Turtle
documents.
A
Turtle
document
parsed
from
an
HTML
DOM
will
be
a
stream
of
character
data
rather
than
a
stream
of
UTF-8
encoded
bytes.
No
decoding
is
necessary
if
the
HTML
document
has
already
been
parsed
into
DOM.
Each
script
data
block
is
considered
to
be
it's
own
Turtle
document.
@prefix
and
@base
declarations
in
a
Turtle
data
bloc
are
scoped
to
that
data
block
and
do
not
effect
other
data
blocks.
The
HTML
lang
attribute
or
XHTML
xml:lang
attribute
have
no
effect
on
the
parsing
of
the
data
blocks.
The
base
URI
of
the
encapsulating
HTML
document
provides
a
"Base
"Base
URI
Embedded
in
Content"
Content"
per
RFC3986
section
5.1.1.
The
Internet
Media
Type
/
MIME
Type
for
Turtle
is
"text/turtle".
"text/turtle".
It
is
recommended
that
Turtle
files
have
the
extension
".ttl"
".ttl"
(all
lowercase)
on
all
platforms.
It
is
recommended
that
Turtle
files
stored
on
Macintosh
HFS
file
systems
be
given
a
file
type
of
"TEXT".
"TEXT".
This information that follows has been submitted to the IESG for review, approval, and registration with IANA.
charset
—
this
parameter
is
required
when
transferring
non-ASCII
data.
If
present,
the
value
of
charset
is
always
UTF-8
.
This work was described in the paper New Syntaxes for RDF which discusses other RDF syntaxes and the background to the Turtle (Submitted to WWW2004, referred to as N-Triples Plus there).
This work was started during the Semantic Web Advanced Development Europe (SWAD-Europe) project funded by the EU IST-7 programme IST-2001-34732 (2002-2004) and further development supported by the Institute for Learning and Research Technology at the University of Bristol , UK (2002-Sep 2005).
Valuable contributions to this version were made by Gregg Kellogg, Andy Seaborn, Sandro Hawke and the members of the RDF Working Group.
The document was improved through the review process by the wider community.
BASE
and
PREFIX
directives
in
a
Turtle
document
was
marked
"at
risk"
in
the
ex:first.name
.
ex:7tm
.
See also the pre- W3C Submission changelog .