Dynamic function invocation

[rvesse]

Why?

Currently SPARQL has a fairly robust extension function mechanism that allows for arbitrary functions to be referred to by URIs. This allows for vendors to implement useful extensions and for those to be even interoperable if vendors publish definitions of the semantics of their functions, since then other vendors can also add implementations associated with the same URI.

However there is no way currently to do dynamic function invocation i.e. cases where you want to run different functions based on some conditions. The best you can do currently is to use IF to select different functions, which are known in advance, to evaluate based on some conditions e.g.

BIND(IF(?x > 0, ex:a(?x), ex:b(?x)) AS ?z)

This doesn't cover the use case of data driven function selection e.g. where the data itself encodes the desired function. So the following is currently illegal:

BIND(?x(?y) AS ?z)

Existing Solutions

Apache Jena currently supports dynamic function invocation by introducing a new built-in function called CALL() in it's ARQ syntax:

BIND(CALL(?x, ?y) AS ?z)

This is a n-ary function i.e. it can take any number of arguments. It's semantics are defined as follows:

• If there are zero arguments error
• Evaluate the first argument (which may itself be an arbitrary expression)
• If the result is not a URI then error
• If the result is a URI treat as an extension function and attempt to evaluate the identified function passing in the remaining arguments (which again may be arbitrary expressions) and return its result (or error)

[jindrichmynarz]

How would you select the function to run if not via if()? VALUES or determining the function IRI by pattern matching in data describing the functions? In other words, it would help me to understand the issue if there were examples of using the dynamic function invocation.

[cygri]

In TopQuadrant we have used the call function as provided by ARQ to check lexical forms against a datatype in a generic way:

BIND (call(?datatypeIRI, ?lexicalForm) AS ?literal)

If bound(?literal) returns true, then the lexical form is valid for that datatype. This makes use of the fact that datatype constructor functions return an error for invalid lexical forms. Only works for supported datatypes, of course.

[zacharywhitley]

This sounds similar to what was proposed by Maurizio Atzori in "Toward the Web of Functions: Interoperable Higher-Order Functions in SPARQL" It outlined more than what is being discussed here but it included something like a CALL() function

[VladimirAlexiev]

These are related:

• https://fno.io http://users.ugent.be/~bjdmeest/function/: The Function Ontology, Unofficial Draft 18 March 2019 An Ontology to Semantically Declare and Describe Functions (ESWC 2016 POSTER) Declarative Data Transformations for Linked Data Generation- The Case of DBpedia (ESWC 2017) Discovering and Using Functions via Content Negotiation (ISWC 2016 poster)
• https://www.scss.tcd.ie/~crottija/funul/: FunUL - Functions in Uplift mapping Languages R2RML-F: Towards Sharing and Executing Domain Logic in R2RML Mappings. In: Workshop on Linked Data on the Web, LDOW 2016. Incorporating Functions in Mappings to Facilitate the Uplift of CSV Files into RDF. In: Proceedings of the 13th Extended Semantic Web Conference: Posters and Demos, ESWC 2016. Implementations: https://github.com/CNGL-repo/RMLProcessor, https://github.com/CNGL-repo/db2triples