Templates, Generics, and Polymorphism in Semantic Web Languages

[AdamSobieski]

I recently had an idea pertaining to templates, generics, and polymorphism in Semantic Web languages. Such functionality would be useful for planning domain definition languages and ontologies and for other scenarios such as machine lexicons.

In C# or Java, generic types resemble Widget<T1, T2, T3>. Semantic Web generic types might, conceptually, resemble: ex:Widget<ex:Foo, ex:Foo2, ex:Foo3>. The <> brackets are utilized for other purposes in Semantic Web languages so some brainstorming was required.

For Semantic Web languages, templates and generics could utilize the following syntax:

@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
@prefix ex:  <http://example.org/#> . 

[] rdf:type ex:Widget??(ex:Foo ex:Foo2 ex:Foo3)

Utilizing the prefix:localpart syntax, this extended syntax also maps with URIs or URLs. It utilizes the query string portion.

The syntax in the example, above, ex:Widget??(ex:Foo ex:Foo2 ex:Foo3), would map with a URI or URL resembling:

http://example.org/?T[]=http%3A%2F%2Fexample.org%2F%23Foo&T[]=http%3A%2F%2Fexample.org%2F%23Foo2&T[]=http%3A%2F%2Fexample.org%2F%23Foo3#Widget

Also, the following example:

@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
@prefix ex:  <http://example.org/#> . 

[] rdf:type ex:Widget??(("p1" ex:Foo) ("p2" ex:Foo2) ("p3" ex:Foo3))

shows the syntax ex:Widget??(("p1" ex:Foo) ("p2" ex:Foo2) ("p3" ex:Foo3)) which would map with a URI or URL utilizing, instead of T[], named query string parameters, e.g,. p1, p2, and p3:

http://example.org?p1=http%3A%2F%2Fexample.org%2F%23Foo&p2=http%3A%2F%2Fexample.org%2F%23Foo2&p3=http%3A%2F%2Fexample.org%2F%23Foo3#Widget

Beyond being constrained to URIs for types or classes, template arguments could be other URIs, e.g., those representing individuals, and other built-in datatypes such as strings or numerical datatypes.

Interestingly, this syntax would be utilizable with client-side and server-side processing, e.g., PHP, where output contents could vary depending on the query string arguments. A client-side preprocessor component or a server-side PHP script could vary output content, e.g., content of type application/trig, utilizing a provided knowledgebase (e.g., a graph or SPARQL endpoint) and the provided template arguments.

What do you think of these ideas and syntax?

---

Update: I switched the syntax sketch from ^^ to ?? to avoid confusion with the ^^ syntax for indicating the datatypes of RDF literals and in hopes that the ?? syntax reminds developers of URIs' query strings.

[AdamSobieski]

Building on the concepts of client-side preprocessing, the techniques, above, enable named graphs templates which can produce concrete named graph instances for valid sequences of provided arguments.

Let us consider that named graph templates, e.g., ex:ng??(?x ?y), resemble functions which return or produce concrete named graphs. N3 could be utilized to implement these named graph templates.

The named graph template ex:ng??(?x ?y) could be instantiated or invoked, for example with ex:ng??(ex:alice ex:bob). Interestingly, the URI mapped with the ex:ng??(ex:alice ex:bob) syntax is the name of the resultant concrete named graph instance.

Envisioned is that developers will be able to construct N3-based named graph templates and then add them to datasets so that these could, for each sequence of arguments provided, produce a concrete named graph instance.

Some sketches and syntactical possibilities:

@prefix list:  <http://www.w3.org/2000/10/swap/list#> .  
@prefix log:   <http://www.w3.org/2000/10/swap/log#> .  
@prefix ex:    <http://example.org/#> .  
@prefix graph: <http://www.w3.org/2000/10/swap/graph#> . 
@prefix rdf:   <http://www.w3.org/1999/02/22-rdf-syntax-ns#> . 

ex:ng??(?x ?y) :graph  
{  
    ?x rdf:type foaf:Person .  
    ?y rdf:type foaf:Person .  
    ?x foaf:knows ?y .  
    ?y foaf:knows ?x .  
} .  

### example usage of template
{  
    ex:ng??(ex:alice ex:bob) :graph ?graph .  
    ?graph graph:member ?stmt .  
    ?stmt log:equalTo { ?s ?p ?o } .  
}  
=>  
{   
    ?s ?p ?o .      
} .  

We can also consider adding a named graph parameter, ?kb, and using something like @requires to guard the input arguments.

@prefix list:  <http://www.w3.org/2000/10/swap/list#> .  
@prefix log:   <http://www.w3.org/2000/10/swap/log#> .  
@prefix ex:    <http://example.org/#> .  
@prefix graph: <http://www.w3.org/2000/10/swap/graph#> .  
@prefix rdf:   <http://www.w3.org/1999/02/22-rdf-syntax-ns#> . 
@prefix owl:   <http://www.w3.org/2002/07/owl#> . 

ex:ng??(?kb ?x ?y) :graph  
{  
    @requires ?kb holds { ?x rdf:type foaf:Person } .  
    @requires ?kb holds { ?y rdf:type foaf:Person } . 
    @requires ?kb holds { ?x owl:differentFrom ?y } .  

    ?x foaf:knows ?y .  
    ?y foaf:knows ?x .  
} .  

### example usage of template
{  
    ex:ng??(:this ex:alice ex:bob) :graph ?graph .  
    ?graph graph:member ?stmt .  
    ?stmt log:equalTo { ?s ?p ?o } .  
}  
=>  
{   
    ?s ?p ?o .      
} .  

The three @requires expressions could also be merged into one using a graph:

@prefix list:  <http://www.w3.org/2000/10/swap/list#> .  
@prefix log:   <http://www.w3.org/2000/10/swap/log#> .  
@prefix ex:    <http://example.org/#> .  
@prefix graph: <http://www.w3.org/2000/10/swap/graph#> .  
@prefix rdf:   <http://www.w3.org/1999/02/22-rdf-syntax-ns#> . 
@prefix owl:   <http://www.w3.org/2002/07/owl#> . 

ex:ng??(?kb ?x ?y) :graph  
{  
    @requires ?kb holds
    {
        ?x rdf:type foaf:Person .
        ?y rdf:type foaf:Person .
        ?x owl:differentFrom ?y .
    } .  
    ?x foaf:knows ?y .  
    ?y foaf:knows ?x .  
} .  

### example usage of template
{  
    ex:ng??(:this ex:alice ex:bob) :graph ?graph .  
    ?graph graph:member ?stmt .  
    ?stmt log:equalTo { ?s ?p ?o } .  
}  
=>  
{   
    ?s ?p ?o .      
} .  

If the @requires subgraph is not contained in the knowledgebase, ?kb, the template could return an empty graph. Also possible is that an error could also be logged and/or thrown.

[AdamSobieski]

Brainstorming towards being able to express if, then, else with semantic templates and building on the @requires expression syntactic approach:

@prefix list:  <http://www.w3.org/2000/10/swap/list#> .  
@prefix log:   <http://www.w3.org/2000/10/swap/log#> .  
@prefix ex:    <http://example.org/#> .  
@prefix graph: <http://www.w3.org/2000/10/swap/graph#> .  
@prefix rdf:   <http://www.w3.org/1999/02/22-rdf-syntax-ns#> . 
@prefix owl:   <http://www.w3.org/2002/07/owl#> . 

ex:ng??(?kb ?x ?y) :graph  
{  
    @if ?kb holds
    {
        ?x rdf:type foaf:Person .
        ?y rdf:type foaf:Person .
        ?x owl:differentFrom ?y .
    }
    @then
    {  
        ?x foaf:knows ?y .  
        ?y foaf:knows ?x .  
    }
    @else { }
} .

the above example intends to express a semantic template which conditionally provides one of two graphs depending on whether a provided graph, ?kb, holds an indicated subgraph.

Interestingly, with negation for @requires (@requires ?kb not holds { ... }) and, as semantic templates can be defined as returning empty graphs if their @requires are not fulfilled, the @if @then @else syntactic construct can be related with a union of two named graphs which each use a @requires construct, one the negation of the other.

@prefix list:  <http://www.w3.org/2000/10/swap/list#> .  
@prefix log:   <http://www.w3.org/2000/10/swap/log#> .  
@prefix ex:    <http://example.org/#> .  
@prefix graph: <http://www.w3.org/2000/10/swap/graph#> .  
@prefix rdf:   <http://www.w3.org/1999/02/22-rdf-syntax-ns#> . 
@prefix owl:   <http://www.w3.org/2002/07/owl#> . 

ex:ng1??(?kb ?x ?y) :graph  
{  
    @requires ?kb holds
    {
        ### the condition
        ?x rdf:type foaf:Person .
        ?y rdf:type foaf:Person .
        ?x owl:differentFrom ?y .
    } .  
    ### the "then" content
    ?x foaf:knows ?y .  
    ?y foaf:knows ?x .  
} .  

ex:ng2??(?kb ?x ?y) :graph  
{  
    @requires ?kb not holds
    {
        ### the condition
        ?x rdf:type foaf:Person .
        ?y rdf:type foaf:Person .
        ?x owl:differentFrom ?y .
    } .  
    ### the "else" content (in this case none)
} .  

ex:ng3??(?kb ?x ?y) :graph
{
    @union
    {
        ex:ng1??(?kb ?x ?y) .
        ex:ng2??(?kb ?x ?y) .
    }
} .

[AdamSobieski]

With @requires and @if @then @else syntactic constructs for semantic templates, we can more easily create templates which can vary their output contents per their input arguments. This is generally useful and can be of use for implementing generics, e.g., generic types, and other forms of polymorphism.

Templates, generics, and polymorphism are tools with which to enhance languages' expressiveness, convenience, and readability. These language features could equip developers and enhance the development of planning domains, types, operators, predicates, expressions, graphs, constraints, preferences, and so forth.

Here is an example sketch of a generic operator, move<,>, using a pseudo-language:

public operator move<?KB, ?T>(?world, ?robot, ?from, ?to)
{
    preconditions { ... }
    effects { ... }
    implementation { ... }    
}

The preconditions, effects, and implementations of operators, e.g., move<?KB, ?T>, could vary per template arguments.

In addition to using template variables in operators' preconditions, effects, and implementations, resultant operators could be varied more significantly per semantic template processing. That is, the semantic graphs representing operators could be varied based on the processing of template arguments, e.g., ?T, and using one or more knowledgebases, e.g., ?KB.

Here's a rough-draft sketch in JavaScript to show the concepts:

var move = domain.get('move');
if (move.validateTemplateArguments(kb, T))
{
    var move_operator = move.createOperator(kb, T);
    if (move_operator.preconditionsMet(world, robby, room_1, room_2))
    {
        var move_action = move_operator.createAction(world, robby, room_1, room_2);
        move_action.invoke(world);
    }
}

In this example, T could be anything. While developers are accustomed to using types or classes as template arguments, e.g., move<Robot>, arguments for T could be adverbial modifiers which result in producing specific operator instances of the verb move. A family of related operators could be: move<slow>, move<medium>, and move<fast>. Arguments for T could also be scalars, centimeters per second, and a family of related operators could be: move<1>, move<2>, move<3>, ..., move<10>. In any event, sets of related operators can be developed intuitively and conveniently using templates.

[AdamSobieski]

In addition to uses of the proposed prefix:localpart??(... list ...) mapping's usefulness for invoking semantic templates, the mapping could also be utilized to form general-purpose URIs, including those URIs which are also URLs.

Utilizing the prefix:localpart??(... list ...) mapping described, developers could more easily describe Web-based resources, e.g., PHP-produced resources, those resources which are produced using URL query string data.

To stir the imagination, let us consider a computer lexicon scenario involving verbs and sets of thematic relations:

@prefix vn : <https://www.verbnet.org/index.php#> .
@prefix ex : <http://example.org/#> .

vn:frame??(("verb" ex:ate) ("agent" ex:bob) ("patient" ex:cheese)) rdf:type   vn:VerbNetFrame ;
                                                                   vn:verb    ex:ate ;
                                                                   vn:agent   ex:bob ;
                                                                   vn:patient ex:cheese . 

where the subject of that example's graph's triples maps with a URI:

https://www.verbnet.org/index.php?verb=http%3A%2F%2Fexample.org%2F%23ate&agent=http%3A%2F%2Fexample.org%2F%23bob&patient=http%3A%2F%2Fexample.org%2F%23cheese#frame

This example URI could also be a URL which, perhaps, provides a Semantic Web resource.

Interestingly, we can consider an N3 language feature for fetching or retrieving language-integrated named graphs from URLs. That is, there could be a language-integrated feature, which perhaps resembles invoking a special template, for fetching or retrieving Semantic Web content from URLs and then using the resultant content as first-class named graphs in the language.

This "special template invocation" for fetching Semantic Web content from URLs could resemble:

special:fetch??( vn:frame??(("verb" ex:ate) ("agent" ex:bob) ("patient" ex:cheese)) ) .

[AdamSobieski]

Per some recent discussions in the Semantic Web Interest Group mailing list (see: here), also possible are the following new syntactic options, utilizing the $ symbol as a prefix to both RDF literals and URI nodes when arguments are desired to be processed into them.

ex:alice  ex:says  $"Hello {?world}" .

$<http://www.verbnet.org/index.php?verb={?x}&agent={?y}&patient={?z}#frame> rdf:type   vn:VerbNetFrame ;
                                                                            vn:verb    ?x ;
                                                                            vn:agent   ?y ;
                                                                            vn:patient ?z .

Also, the running example of ex:Widget<ex:Foo, ex:Foo2, ex:Foo3> could, using this new option, resemble:

@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
@prefix ex:  <http://example.org/#> . 

[] rdf:type $<http://example.org/?T[]={ex:Foo}&T[]={ex:Foo2}&T[]={ex:Foo3}#Widget> .

And, using this new syntax option and putting together some pieces, an N3 semantic template definition could resemble:

@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
@prefix vn : <https://www.verbnet.org/> .

@define ex:template (?kb ?x)
{
    @if ?kb holds
    {
        ?x rdf:type vn:Verb .
    }
    @then
    {
        @dereference $<https://www.verbnet.org/index.php?verb={?x}#frame> .        
    }
    @else { }
}

This example semantic template guards an input parameter, ?x, ensuring it is a vn:Verb, and, if so, retrieves a Semantic Web graph from a template-generated URI, and, if not, returns an empty graph.

Also possible is using a :world graph in N3 instead of using an explicit ?kb parameter:

@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
@prefix vn : <https://www.verbnet.org/> .

@define ex:template (?x)
{
    @if :world holds
    {
        ?x rdf:type vn:Verb .
    }
    @then
    {
        @dereference $<https://www.verbnet.org/index.php?verb={?x}#frame> .        
    }
    @else { }
}

[AdamSobieski]

From a recent email that I wrote to Semantic Web Interest Group mailing list (see: here), here are some use cases for the syntax under discussion:

Use Case 1: Templates, Generic Types and Polymorphism

For this interesting use case, we can move the URI pattern to the subject position of a triple in a graph defining an OWL class.

@define ex:generateWidget (?n)
{
    ex:Widget??(?n)  rdf:type  owl:Class .
    ...
}

or, if more readable:

@define ex:generateWidget (?n)
{
    $<http://example.org/?T[]={?n}#Widget>  rdf:type  owl:Class .
    ...
}

So, for example, for integers, ?n, OWL classes could be generated, each with a URI instead of a blank node.

Then, elsewhere, we could create instances of that templated, generic type.

ex:somewidget  rdf:type  ex:Widget??(4) .

So, for an example of what a template would produce, the ex:generateWidget template invoked with an argument of 4 would produce

{
    ex:Widget??(4)  rdf:type  owl:Class .
    ...
}

or, if more readable:

{
    <http://example.org/?T[]=4#Widget>  rdf:type  owl:Class .
    ...
}

There could be, for example, four Widget types, one for each integer 1 through 4. The feature of semantic templates allows for four generic classes to be defined simply and conveniently in one place, a template. A fuller example could show the resultant graph more significantly varying per the template arguments provided; a cardinality restriction with the OWL class could, for example, differ for each of the four classes using the variable ?n . There are also, under discussion, @if/@then/@else keywords (see: here) which could be of use for expressing more significant variations in resultant graphs based on provided template arguments.

Use Case 2: Parametric URI for Dereferencing

In this use case, a @dereference keyword (see: here) could enable downloading Semantic Web graphs from URIs.

@define ex:downloadVerbFrame (?verb)
{
    @dereference vn:??(("verb" ?verb)) .
}

or, if more readable:

@define ex:downloadVerbFrame (?verb)
{
    @dereference $<https://www.verbnet.org/index.php?verb={?verb}> .
}

This template, when expanded or invoked, returns a graph which, in this case, is one downloaded from a templated URI. With templates and parameters, developers could more conveniently utilize client-side processing, per semantic templates, and server-side processing, per PHP scripts.

Use Case 3: Describing Resources which Utilize the URI Query String in a Patterned Manner

A templated URI could be such that variables in the URI have semantic meaning, these variables could be book ISSN's, or, in the following example, some event-related data structure parameters:

ex2:??(("location" ?loc) ("from" ?f) ("to" ?t))  rdf:type     ex:Event ;
                                                 ex:location  ?loc ;
                                                 ex:fromTime  ?f ;
                                                 ex:untilTime ?t .

or, if more readable:

$<http://www.example2.org/index.php?location={?loc}&from={?f}&to={?t}>  rdf:type     ex:Event ;
                                                                        ex:location  ?loc ;
                                                                        ex:fromTime  ?f ;
                                                                        ex:untilTime ?t .

So, one can express that, for every URI like a specified pattern, a resource of or at each URI can be described in a certain way.

Use Case 4: String Templates for RDF Literals

For this use case, we can see how template parameters could be utilized in string templates for RDF literals.

ex:alice  ex:says  $"Hello {?world}" .