Everywhere you use Cascade call expression it redirects evaluation to given function and takes value that function returns.
Cascade call syntax:
cascade statement
meaning
$f fun
evaluates function fun and takes its result
$f fun (1, 5, active)
function is called with 3 arguments passed: "1", "5" and "active",note that arguments are always passed as string values
$f fun (1; 5; A,B,C)
if semicolon ; is present anywhere in arguments expression - Hyperon will use that semicolon as argument delimiter, otherwise it will use comma , as delimiter, note that this call will pass 3 string arguments: "1", "5", "A,B,C"
$f fun (ctx:insured.age, 5)
you may pass values taken directly from current context by using ctx:path syntax, note that this example will take first argument from current context with standard context API: ctx.get( "insured.age" )
$f fun [ idx ]
if function returns compound result (ParamValue, MultiValue, java array, Collection or Iterable), then cascade call extracts element from position idx, where idx = 0 is first element
$f fun [ code ]
if function returns compound result (ParamValue, MultiValue or Map), then cascade call extracts element associated with key = code - result.get(code)
$f fun (1, ctx:prd.code) [factor]
one more example: fun is called with 2 arguments, first is given as a literal, second is taken from current context from prd.code path, and finally - Hyperon extracts "factor" field from function's compound result.
Implicit type conversion
Suppose, you have parameter P with level L1 of type T1, and function F returning value of type T2. If you use cascade call inside P[L1] pointing to F, then:
step 1: internally cascade call will return value of type T2, internally cascade step 2: next, T2 will be converted to Holder,
conversion will meet Hyperon's conversion standards, see _dec(), _num(), _str(), _date(), _bool() conversion methods,
conversion may be lossy (eg. T1 is integer while T2 is number)
Example
Suppose we have function calc.factors and parameter client.factors defined as follows:
Function calc.factors:
function (age) {
// normalize arguments (this is recommended as they may come as strings)
age = _num( age );
var factor1 = 1.0 + age/100;
var factor2 = 3.0 + age/10;
// return f1 mapped to factor1, and f2 mapped to factor2return util.map(
'f1', factor1,
'f2', factor2
);
}
Parameter client.factors:
IN insured.age
OUT factor1 (integer)
OUT factor2 (number)
0 - 30
1.0
3.0
31 - 40
1.1
$f calc.factors (ctx:insured.age) [f2]
41 - 50
1.2
$f calc.factors (50) [f2]
*
$f calc.factors (65) [f1]
$f calc.factors (50) [f2]
Below you can see parameter's results for some values of insured.age property: