Make use of Arrow Functions in Java Script

Question

With medini 2024 R2 the Java Script engine version was increased and with that a script can now use arrow functions. The name is derived from the operator which is ``=>`` which looks like an arrow. There is pretty good explanation out there in the net for example at JavaScript Arrow Function.

This article is not really about the arrow function itself and its advantages but more on how we can use them together with known scripting API as the ``Finder`` resp. ``FinderResult``. Lets take this example:

finder.findByType(Metamodel.projectmodel.PJPackage).filter(function(p) {
 return p && p.containedElements.size() > 0;
});

This example finds all packages which have content. According to the "Arrow Function" articles, one would now be able to change that into:

finder.findByType(Metamodel.projectmodel.PJPackage).filter(p => p && p.containedElements.size() > 0);

However, that fails with an error: Cannot convert org.mozilla.javascript.ArrowFunction to de.ikv.medini.scripting.core.Filter which pretty much explains the problem. The scripting API is a Java API and accepts a simple function with a single parameter. The Arrow Function is internally converted into a complex function interface with lots of parameters like scripting context etc. The tight coupling of Java and Rhino scripting is suddenly an issue here (for first time) and blocks us which is a pity.

We can now try to workaround the problem a bit like this:

finder.findByType(Metamodel.projectmodel.PJPackage).toArray().filter(p => p && p.containedElements.size() > 0);

That solution is pretty nice. We convert the finder result first to a native JS array and can use the filter function of that array. Only problem here is that we somewhat lose the Finder API, no more "and" or "not" or "withTag" calls possible. That brings us to this solution:

finder.findByType(Metamodel.projectmodel.PJPackage).filter( {accept: p => p && p.containedElements.size() > 0} );

Which works! But wait, what is happening here? The enclosing bracelets convert the construct into an object with a single function "accept" which internally can be mapped by Rhino to a "filter function" which is accepted by the filter function. The magic that the filter is calling the filter function which evaluates the arrow function is in Rhino :-)

Happy Arrow

Jan

medini_1059007410 · Answer

There are some other nice usages of the arrow function, which now work. Note that the examples below all use JS arrays - if you come from a Java list, first convert it via toArray().

* filter: Arrays can be filtered with an (arrow) function (note that in the example the Java list "contains()" method is used - you could replace it for a JS Array by "includes()", if you include a polyfill for it in your script/library)* var filteredArray = myArrayOfStrings.filter(str => someOtherObject.user_list_of_strings.contains(str));

* map: This can be used to emulate the AQL/OCL behavior when accessing/drilling down to properties of items in a collection (like "myObject.user_list_of_componentEntries.element.name" in AQL) - or any other stuff for replacing the entries by something else. Very powerful:* myObject.user_list_of_componentEntries.toArray().map(ce => ce.element.name)

* forEach: Normally you have to use "myElementsArray.forEach(function optionalFctName(element) { ...do something... });", but instead you can use this for short functions:* myElementsArray.forEach(element => ...do something...);

Cheers,

Nils

medini_1024169437 · Answer

I would like to thanks Marian for the valuable input for this article