[RDF] Re: En tanke

[Jonas Liljegren]

Stefan Andersson wrote to me about an idea about binding the predicate
to a parser:

> a -- type --> b
> b -- subClassOf --> Terrier
> Terrier -- subClassOf --> Dog
> type -- WRAFParser --> typeparser

And that would result in that the call a.type will result in
typeparser(a).


And my response:


Ok... There are many possible implementations.  I have tried to make
simplifications by accepting some limitations.  At least for now. :-)


The current solutions lets each interface implement it's own
interpretation of a specific predicate, based on the subjects type and
namespace.

I can agree on that that seems a little strange then compared with
Stefans suggestion about letting the predicate declare it's own
implementation.


Aaarghhh... Must i now start again? :-I



Ok. Let's think about this..:  

Each predicate has a owner; the owner of the namespace used in the
resource URI.  The official meaning of a predicate should be that
specified by it's owner.

But there can still be many implementations of the property.  The
present system of choosing implementation is by connecting to the
interfaces implementing the wanted implementations.  That will later
be extended by general interfaces with the ability to add new
functions dynamicly and choose function by other means (ie trust).


Ok. We can model the implementation of a predicate by a 'implementing'
property.  And we can still use the existing solution, because it
includes the property.  It includes three things:

 1) The propety

 2) The resource type: diffrent implementations for the designation of
    a resource.  Literal will be designated by their value rather
    than their URI.

 3) The namespace: A implementation can state that it only can answer
    questions about it's own resources.  No point in sending each
    question to all connected interfaces.


The plan is to include the interface declaration in the RDF model.  It
could be done like this ( using the predicate rdf:type as an example):

 s1: rdf:type -- wraf:implementedBy --> cpan:RDF/Service/Interface/Base/V01#type
 s2: s1 -- wraf:model --> cpan:RDF/Service/Interface/Base/V01
 s3: s1 -- wraf:prefix --> ""
 s4: s1 -- wraf:subjectTye --> RDFS:Resource


Or we could insert another step by separate the implementation
declaration from the actual function:

 rdf:type -- wraf:implementedBy --> a1
 a1 -- wraf:function --> cpan:RDF/Service/Interface/Base/V01#type
 a1 -- wraf:model --> cpan:RDF/Service/Interface/Base/V01
 a1 -- wraf:prefix --> ""
 a1 -- wraf:subjectTye --> RDFS:Resource


-- 
/ Jonas Liljegren

The Wraf project http://www.uxn.nu/wraf/
Sponsored by http://www.rit.se/