Methods and functions

Workflow language is a procedural language and any program must have at least one method or function.

Methods and functions are self-contained chunks of code that perform a specific task. You give to a method (or function) a name that identifies what it does, and this name is used to “call” the function to perform its task when needed.

A method can take any number of inputs (including zero) and executes its code and does not return a value, on the other hand a function behaves just like a method the only difference being that it returns a value. 

Here is an example of a method that increments a counter:

//Method definition
method incrementCounter() {
	var c = GET counter(1); //1 = the key of the counter
	c.count = c.count + 1;
	PUT c;
}

//Calling the method
this->incrementCounter();

Here is an example of a function that concatenates two strings:

//Function definition
function concat(name as string, surname as string) as string {
	return name + ", " + surname;
}

//Calling the function
var msg = this->concat("John", "Doe");

Definition #

When you define a method (or function), you can optionally define one or more named, typed values that the method takes as input, known as parameters. For function you can also define a type of value that the function will pass back as output when it is done, known as its return type.

Every method (or function) has a method name (or function name), which describes the task that the method (or function) performs. To use a method (or function), you “call” that method (or function) with its name and pass it input values (known as arguments) that match the types of the method’s (or function’s) parameters. A method’s (or function’s) arguments must always be provided in the same order as the method’s (or function’s) parameter list.

The function in the example below is called sayHello, because that’s what is does, it takes the name as input and returns that person’s name, say “John” and says “Hello John”. To accomplish this, you define one input parameter, a string value called name and a return type of type string, wich will contain the hello phrase.

All of this information is rolled up into the function’s definition, which is prefixed with the function keyword. You indicate the function’s return type with the as keyword, which is followed by the name of the type to return.

function sayHello(name as string) as string {
	return "Hello " + name;
}

The definition describes what the method (or function) does, what it expects to receive, and what it returns when it is done. The definition makes it easy for the function to be called unambiguously from elsewhere in your code.

Parameters #

Methods and functions are very flexible helping you define from the simplest utility methods (or functions) to complex data processing units of code with multiple parameters, complex return values and transaction management.

Methods (or functions) are not required to define input parameters. Here’s a function with no input parameters, which always returns the same string message whenever it is called:

//Function definition
function helloWorld() as string  {
	return "Hello world...";
}

//Calling the function
var msg = this->helloWord();

The function definition still needs parentheses after the function’s name, even though it does not take any parameters. The function name is also followed by an empty pair of parentheses when the function is called.

Functions can have multiple input parameters, which are written within the function’s parentheses, separated by commas.

The function in this example has two input parameters:

//Function definition
function sum(val1 as int, val2 as int) as int {
	return val1 + val2;
}

//Calling the function
var value = this->sum(10, 12);

//Nesting function calls
var value = this->sum(10, this->sum(12, 13));
//value will contain the sum of 10, 12 and 13

You call the sum function by passing it two int argument values in parentheses, separated by commas.

Calling #

Calling methods (or functions) defined in the the same program is done by specifing the keyword this, followed by the operator ->, and then the name of the method (or function) to call, like in the following example:

var greeting = this->sayHello("John");
//greeting variable contains "Hello John"

var greeting = this->sayHello("Anna");
//greeting variable contains "Hello Anna";

When calling methods (or functions) from other programs, the keyword this is replaced by the alias for the import, like in the following example:

import HelloLibrary alias helloLibrary;

method main() {
	//Will call the sayHello function defined in the HelloLibrary program
	var result = helloLibrary->sayHello("John");
}

Importing and exporting #

The import mechanism in the Workflow languages is a way to include code from one program into another. This mechanism allows developers to organize the code into units and reuse code across different parts of an application.

Here’s a general overview of how the import mechanism works:

Generally we create some library program that defines functions or methods for other programs to use, as in this example:

workflow HelloLibrary;

function sayHello(name as string) as string {
	return "Hello " + name;
}

All methods (and functions) defined in a program are automatically exported and available to be imported by other programs.

In the destination program use the import keyword, as in this example:

import HelloLibrary alias helloLibrary;

method main() {
	//Will call the sayHello function defined in the HelloLibrary program
	var result = helloLibrary->sayHello("John");
}

Transactionality #

When you define a method (or function), you can optionally define the method’s (or function’s) transactional behaviour. 

Methods (and functions) have the atomic and isolated keywords (before the method’s (or function’s) name) that help you control the transactional behaviour.

Here is an example of one transactional method:

method atomic process() {
	//do some data processing in which all operations fail or succeed together
}

For examples and more details about transactions make sure you first read the Working with entities chapter and afterwards read the Transactions chapter.