Expression

◷ Reading Time: 16 minutes

An expression is a combination of explicit values, variables, operators, and functions that are evaluated according to particular rules and then produce new values.

For evaluating an expression ExpressionEval should be used. If a variable is required an instance of VariableContainer must be passed.

An expression is the building block of writing rules and conditions. There are some other models (e.g., Decision Table) that support more expression formats as well as normal expressions.

Values

Value is an expression evaluating it will return the same result. The evaluation engine can process the following value types:

Array

An array is a list that can hold multiple values. The list can be manipulated using collection functions.

An array can be initialized using Native Complex Value or array function.

Variables

Variables can be defined with a name,

• Short variable name: alphabetic numeric _ $
  • x
  • abc3
  • point_x
  • $value
• Long variable name: { variable name }
  • {applicant name}
  • {risk factor}
  • {person’s father name}

Variables in different logic are defined as parameters. You can define them in the following types of rules and logic:

• Procedural rules
• Flow logic
• Validation rules
• Workflow logic
• Inference rules
• Decision

Operators

All the execution routing conditions in the rules and logic are based on expression evaluation. An expression is shown below:

Mathematical operators

Assignment operator

Assignment operator format:

expression = expression 

In this case, the left-hand-side expression must finish with a Property or Field of an object

variable = expression

Boolean operators

Format:  (LEFT-BOOLEAN-EXPRESSION) [boolean operator] (RIGHT-BOOEALN-EXPRESSION)

Please note you MUST use parentheses around both sides of a boolean operator to make sure you prioritize the evaluation on the left and right side of the boolean operator.

Comparing operators

Case insensitive

Priority operator

Sub-expression evaluation based on priority:

• Begin (
• End )

(1-risk)*applicantAge

Object members operators

Access to objects (variable) members:

• Method (.)
• Property (.)
• Indexer, Array, list item access ([) and (])

applicant.Age*applicant.CalculateRiskFactor("A")

Null-Aware Property

Properties and Fields of data can be null, and the normal . throws exception.

If you want to handle that exception, you may need to have if, then, else as follows.

if person != null and person.Parent !=null and person.Parent.Name !=null 
then person.Parent.Name.Length
else null

In FlexRule, to avoid repeating!= null, you can use the accesses operator ?.  as follows which does the exact same thing in above if,then else expression.

person?.Parent?.Name?.Length

Condition operator

Inline condition operator

For example:

(3==4)?'this is cool':'what are you talking about?'

If-Then-Else

The alternative of an inline condition operator is to use if-then-else format:

if condition then result else other-result

For example, the above example can be written as:

if 3==4 then 'this is cool' else 'what are you talking about?'

Also, they can be nested:

if Product Type == 'STANDARD LOAN'
then 20.00d
else if Product Type == 'SPECIAL LOAN'
then 25.00d
else null

Methods

A Method is a procedure associated with an object. This is the interface an object presents to the outside world. When a variable parameter is defined that holds an object, then the method of the object can be called using. operator. Parentheses are required at the end of the method and input arguments are comma-separated.

Example: Assume x and b are defined parameters, the expression ‘x.Calculate(2i, b)’ calls Calculate method of the x and pass integer 2 and variable b as input arguments.

String to Expression

You can use the @ sign to get the value of an expression in String format.

For example, to generate the results, we will be reading each value from keylist and use them in zip function. There, in zip function, its parameter requires a string value. Therefore, we have added 'keylist[x]' expression with a @ to retrieve its value.

keylist =  ["a", "b", "c"]
values = [1,2,3]
results = zip(range(0,keylist|count())|select(x,{@'keylist[x]':values[x]}))

results =  {
    "a" : 1,
    "b" : 2,
    "c" : 3
} 

This is another example:

Username= "John"
Message = "Hello " + @'Username'

Message = "Hello John"

Functions

Functions are expressions that relate inputs (arguments) to outputs (function result). There are two types of functions in FlexRule:

1. Built-in functions
2. Static methods
3. Your specific custom code as a function

When a function is defined it has the format shown below:

FunctionName(p1, p2, p3, ...)

where p1, p2, p3… are the parameters of the function which during the usage the values (Arguments) have to be passed to those parameters.

Or a function may have no parameters at all

FunctionName()

In both cases, the function can return a value as a result of the call which can be stored in a parameter using an assignment operator.

parameter = Function(value1, value2, ...)

Functions are very similar to methods, but the difference is that these do not belong to any specific variable. They are global in the whole expression evaluation context. For example, let’s consider the following expression:

in(age, array(3,4,56,60,3,10))

As you can see in and an array is accepting arguments with parentheses. These are comma-separated, exactly like methods, but there is no. operator involved. Functions can be defined at the application/rule level and they are a way to extend the functionality at the expression evaluation level.

Check API for built-in functions.

Decision Table Expressions

In a Decision Table, there are some more expression formats that can be used to simplify the value-based rules. In general, when a value is entered in a data section of a Decision Table, it dynamically resolves its type based on the column type and template expression.

Pipe

Pipes are types of functions that you can chain together and pass previous results to the next one.
Functions that are used with Pipe are called Monads.

|pipeName (arg1, arg2, arg3...)

For example, the result of people |count() is an integer that is the length of the people list. In this example, the count function receives people as its input and its result as a number (integer).

var list = new List<DecisionAgeTests.Person>()
{
    new DecisionAgeTests.Person("arash", 38, DecisionAgeTests.Gender.Male),
    new DecisionAgeTests.Person("Parsa", 6, DecisionAgeTests.Gender.Male),
    new DecisionAgeTests.Person("Pooya", 3, DecisionAgeTests.Gender.Male),
    new DecisionAgeTests.Person("Shah", 3, DecisionAgeTests.Gender.Female)
};
 
var vc = new VariableContainer();
vc.RegisterVariable("people", list);
 
var res = ExpressionEval.Default.Compute(vc, "people |count ()");
 
Assert.AreEqual(list.Count, (int)res); 

XML

When you are working with XML-based data/information, you need to read and manipulate XML.

For more details, visit Xml API help

Comments

When it is required to add descriptions and comments to describe the expressions, there are multiple ways you can do this in FlexRule. This link contains more information on that.

A comment section must start with /* and end with */

Learn more about adding Comments.

Examples

Here are a couple of examples with different types of expressions.

Calculation

(a+b)+(2 * c)-d

Comparison

a < 10

(a+b) gt 23

a<=(c+d)

Assignment

a = b + c

str = 'hello FlexRule expressions'

Storing the result of comparison into ‘r’

r = (b+c)<d

In the below expression, age will be declared at runtime and the value of 18 will be assigned.

age := 18

On assignment of properties, when the parameter is null, an empty object automatically will be created.

Person := null
Person.Name = "ABC"

Method Call

When obj is an object reference which is not null

a = obj.CalculateSum()+20-b

Access Value

In below example, obj is an instance of an object

b = obj.Name + '-' + obj.Family

Evaluating Expression in Code

Here is an example of how you can evaluate an expression containing some variables:

Evaluating expressions on FlexRule:

x := 5
y := 'a test string'
result := (x lt 3) ? x : (x+y.Length)

Evaluating FlexRule’s expression using C#:

var variables = new VariableContainer();
 
variables.Compute("x := 5");
variables.Compute("y := 'a test string'");
 
var res = variables.Compute("result := (x lt 3) ? x : (x+y.Length)");
// res, variables["result"] are both equal to 18

Video