Processing literals

Hi all!

This is regarding the question of whether @property should stop any
further RDFa processing of the content it captures or not.

Now, I do understand the reasons for not to. The analogy to
@rdf:parseType="Literal" in RDF/XML is quite to the point, for one.

I did however entertain the idea before, with one example being:

    <dl about="#me">
        <dt>Name</dt>
        <dd property="foaf:name" datatype="" xml:lang="">
            <span property="foaf:givenname">Niklas</span>
            <span property="foaf:family_name">Lindström</span>
        </dd>
    </dl>

yielding:

    <#me> foaf:name "Niklas Lindström" .
    <#me> foaf:givenname "Niklas" .
    <#me> foaf:family_name "Lindström" .

I found this particular example quite DRY. Alebeit a little dangerous,
since a casual look may confuse @property here with a @rel, and expect
the nested properties to provide the predicate-objects of a BNode.

Furthermore, it might be an edge case altogether.

Continuing though, I have cases in my current work where it *might* be
usable if (XML-)literals where also processed. Consider this:

    <div property="legal:advice">
        A general practise would be ... See also <a rel="rdfs:seeAlso"
        href="http://.../about_some_case">this case of XYZ</a>
        ..
    </div>

, that could result in RDF containing both the actual content and a
precise rdfs:seeAlso relation within that.

But I came to the conclusion that applications using the body of legal
texts could really access the fragment (being the advice) instead
using regular XML processing. So I can probably be satisfied with:

    <div id="advice" rel="legal:advice" resource="#advice">
        A general practise would be ... See also <a rel="rdfs:seeAlso"
        href="http://.../about_some_case">this case of XYZ</a>
        ..
    </div>

, combined with fetching the content of the div (as said by processing
<.../this_doc#advice>).

So I was fairly content.

But now I re-read parts of Kurt Cagle's article about RDFa [1], and
the final example [2] concerned me. Look at the ev:content element in
the Atom XML. It contains the XML given in the XHTML+RDFa spoken of
[3]. "Fortunately", this does not contain any @property="ex:content",
which would as of now (though not voted on, right?) *not* expose the
provided RDFa within the text.

So the question is, what are the relative pros and cons of allowing this?

I am not sure where I stand on this myself. This case kind of hints of
a possible good use. I wonder at what cost in terms of complexity..

Thoughts?

Best regards,
Niklas

[1]: <http://www.devx.com/semantic/Article/35373>
[2]: <http://www.devx.com/semantic/Article/35373/0/page/5>
[3]: <http://www.devx.com/semantic/Article/35373/0/page/4>

Received on Saturday, 29 September 2007 17:07:34 UTC