Evaluating Expression Graphs in RDF Languages

[AdamSobieski]

Introduction

Ideas are presented about evaluating expression graphs in RDF languages, including lambda expression graphs.

The techniques described, below, can be useful for forming and evaluating set-algebraic operations such as intersection, union, and differencing, for forming and evaluating Boolean-algebraic operations such as conjunction, disjunction, and negation, and for forming and evaluating nested expressions involving these.

Considering the ideas presented in #7 and #8, what if the syntax possibilities resembling:

!builtin:intersection?( ( *<1.uris> ) ( *<2.uris ) ) a ex:Example .

could, additionally or instead, be represented in a graph-based manner? What if such graphs could also be evaluated into results?

Examples

The following theorized syntax expression, resulting in a list:

!builtin:intersection?( ( *<1.uris> ) ( *<2.uris ) ) a ex:Example .

could, additionally or instead, be expressed:

@prefix expr: <http://www.tdb.org/2026/expressions#> .

<#expression> a expr:IntersectionExpression ;
              expr:children ( [ a expr:ListUrlDereferenceExpression ; expr:children ( <1.uris> ) ]
                              [ a expr:ListUrlDereferenceExpression ; expr:children ( <2.uris> ) ] ) .

!<#expression> a ex:Example .

in TriG, this could also be expressed:

@prefix ex: <http://www.example.org/stuff/1.0/> .
@prefix expr: <http://www.tdb.org/2026/expressions#> .

<http://www.example.org/graph1> {
  <http://www.example.org/graph1#expression> a expr:IntersectionExpression ;
            expr:children ( [ a expr:ListUrlDereferenceExpression ; expr:children ( <1.uris> ) ]
                            [ a expr:ListUrlDereferenceExpression ; expr:children ( <2.uris> ) ] ) .
}

<http://www.example.org/graph2> {
  !<http://www.example.org/graph1#expression> a ex:Example .
}

and, building on the * symbol (see: #7), notation for dereferencing and evaluating an expression would resemble:

!*<http://www.data.org/examples/example.ttl#expression> a ex:Example .

with the resource example.ttl being:

@prefix expr: <http://www.tdb.org/2026/expressions#> .

<#expression> a expr:IntersectionExpression ;
              expr:children ( [ a expr:ListUrlDereferenceExpression ; expr:children ( <1.uris> ) ]
                              [ a expr:ListUrlDereferenceExpression ; expr:children ( <2.uris> ) ] ) .

Lambda Expressions

Lambda expressions could be represented via an expr:LambdaExpression class and use instances of an expr:ParameterExpression class. To create lambda-invocation expressions, one could use a ?( ...) syntax and, putting it all together, evaluating a dereferenced graph's lambda expression with arguments could resemble the following examples.

!<#lambdaExpression>?( ex:x ex: y ) a ex:Example .

For a more complex example, in the case that a dereferenced lambda expression returned a list, ( ex:a ex:b ex:c ), the following:

!*<http://www.data.org/examples/lambda.ttl#expression>?( ex:x ex:y ex:z ) a ex:Example .

would become:

( ex:a ex:b ex:c ) a ex:Example .

To expand a resultant list into multiple triples, such that each list element was the subject of its own triple, one could use the * symbol:

*!*<http://www.data.org/examples/lambda.ttl#expression>?( ex:x ex:y ex:z ) a ex:Example .

which would be evaluated into:

*( ex:a ex:b ex:c ) a ex:Example .

and then into:

ex:a a ex:Example .
ex:b a ex:Example .
ex:c a ex:Example .

Glossary

Abstract Syntax Tree, Expression

Conclusion

What do you think about these ideas? Thank you.