The basics

In this chapter the basic features of the Workflow language are described.

Variables

Variables associate a name (such as maximumNumberOfLoginAttempts or welcomeMessage) with a value of a particular type (such as the number 10 or the string "Hello"). The value of a variable can be set to a different value in the future.

Declaring variables

Variables must be declared before they are used. You declare variables with the var keyword. Here’s an variables can be used to track the number of login attempts a user has made:

var currentLoginAttempt = 0;

This code can be read as:

“Declare a new variable called currentLoginAttempt, and give it an initial value of 0.”

Variable Types

You can provide a variable type when you declare a variable, to be clear about the kind of values the variable can store. Write the keyword as, followed by a space, followed by the name of the type to use.

This example provides a variable type for a variable called welcomeMessage, to indicate that the variable can store string values:

var welcomeMessage as string;

The code above can be read as:

“Declare a variable called welcomeMessage that is of type string.”

The phrase “of type string” means “can store any string value.” Think of it as meaning “the type of thing” (or “the kind of thing”) that can be stored.

The welcomeMessage variable can now be set as follows:

welcomeMessage = "Hello";

Naming Variables

Variable names can contain only the characters from a to z (and A to Z), underscore and numbers from 0 to 9 (but they cannot begin with a number).

Once you’ve declared a variable of a certain type, you can’t redeclare it again with the same name, or change it to store values of a different type.

Note

If you need to give a variable the same name as a reserved Workflow keyword, surround the keyword with backticks (`) when using it as a name. However, avoid using keywords as names unless you have absolutely no choice.

Basic Types

Basic types (also known as primitive types or built-in types) are the simplest data types that are built into the language. These types serve as the foundational building blocks for storing and manipulating basic kinds of data.

You can use this types to build complex data structures, implement algorithms or for plain and simple storage of data.

integer

Integers are whole numbers with no fractional component, such as 42 and -23. Integers are either signed (positive, zero, or negative) or unsigned (positive or zero).

The value of an integer ranges between -2E63, and 2E63-1.

decimal

Decimals are numbers with a fractional component, such as 3.14159, 0.1, and -273.15.

Decimal type can represent a much wider range of values than the integer type, and can store numbers that are much larger or smaller than can be stored in an integer.

datetime

Datetime type holds, as the name suggests, a date and a time including the timezone.

Datetime values help you work with date and time in a precise way, and can be used for a wide range of applications like: tracking changes to records in time, scheduling, time calculations, reporting etc.

You can also perform calculations on datetime values such as adding or removing days, calculating the number of days between values and much more, for more details see the date time package.

string

A string is a series of characters, such as "hello, world" or "albatross". When you write strings they must be enclosed in double quotes.

You can use strings for a variety of purpuses, such as: messages for users, working with files, storing and manipulating textual data and many more, for more details see the string package.

Strings are not limited in length but in some situations you may be limited by other factors such as the maximum length of 255 characters for string properties on entities.

boolean

Workflow has a basic Boolean type, called boolean. Boolean values are referred to as logical, because they can only ever be true or false. Workflow provides two Boolean constant values, true and false:

var orangesAreOrange = true;
var turnipsAreDelicious = false;

Complex Types

Complex Types are sets of Basic Types or Complex Types defining a new Complex Type given a unique name. You cand use this name as a variable type later in your code.

Here’s an example of a Complex Type called car:

type car {
	var model as string;
	var manufacturer as company;
	var yearOfManufacturing as int;
}

type company {
	var name as string;
	var country as string;
}

You can declare variables with the types defined, for example:

var myCar as car;

The code above can be read as:

“Declare a variable called myCar that is of (complex) type car.”

Automatic Instantiation

In Workflow types do not need to be instantiated in order to be used. Because types are not objects and cannot have internal state, private fields, or constructors they are automaticaly instantiated.

The folowing example shows how a variable is automaticaly instantiated on use:

//
myCar.model = "Model 1"; //on usage the myCar variable is automatically instantiated
myCar.yearOfManufacturing = 2017;
myCar.manufacturer.name = "Car builder"; //on usage the property 'manufacturer' of variable 'myCar' is automatically instantiated
myCar.manufacturer.country = "US";

Automatic instantiation happens only when you try to set a value to a property in contrast, when reading an uninitialized (or null) property the default value (or null) is returned.

Null Coalescing

If you are trying to read a chain o properties and one property value, when reading from left to right, is null then null is returned, for example:

//set myCar to null
myCar = null;

//initialModel will be null and not a null pointer exception like in C# or Java
var initialModel = myCar.model;

//initialManufacturer will be null and not a null pointer exception like in C# or Java
var intialManufacturer = myCar.manufacturer.name;

The behaviour described above is called Null Coalescing.

Type Safety

Workflow is a type-safe language. A type safe language encourages you to be clear about the types of values your code can work with. If part of your code expects a string, you can’t pass it an int by mistake.

Because Workflow is type safe, it performs type checks when compiling your code and flags any mismatched types as errors. This enables you to catch and fix errors as early as possible in the development process.

Type-checking helps you avoid errors when you’re working with different types of values. However, this doesn’t mean that you have to specify the type of every variable that you declare. If you don’t specify the type of value you need, Workflow uses type inference to work out the appropriate type. Type inference enables a compiler to deduce the type of a particular expression automatically when it compiles your code, simply by examining the values you provide.

Type Inference

Because of type inference, Workflow requires far fewer type declarations than other languages. Variables are still explicitly typed, but much of the work of specifying their type is done for you.

Type inference is particularly useful when you declare a variable with an initial value. This is often done by assigning a literal value (or literal) to the variable at the point that you declare it. (A literal value is a value that appears directly in your source code, such as 42 and 3.14159 in the examples below.)

For example, if you assign a literal value of 42 to a new variable without saying what type it is, Workflow infers that you want the variable to be an int, because you have initialized it with a number that looks like an integer:

var meaningOfLife = 42;
// meaningOfLife is inferred to be of type Int

Likewise, if you don’t specify a type for a floating-point literal, Workflow infers that you want to create a decimal:

var pi = 3.14959;

If you combine integer and floating-point literals in an expression, a type of decimal will be inferred from the context:

var anotherPi = 0.14159 + 3;
// anotherPi is also inferred to be of type decimal

The literal value of 0.14159 in the expression will be inferred as decimal and 3 will have the inferred type of integer wich is convertible to decimal thus the whole expression will be inferred as decimal.

Duck Typing

Duck-typing is a technique of automatically converting between different types if certain similarity requirements are met. The similarity requirements are called “Duck test” and, as Wikipedia describes it, this means: “If it looks like a duck, swims like a duck, and quacks like a duck, then it probably is a duck.”.

Comments

Use comments to include nonexecutable text in your code, as a note or reminder to yourself. Comments are ignored by the compiler when your code is compiled.

Single-line comments begin with two forward-slashes (//):

//this is a comment

Multiline comments start with a forward-slash followed by an asterisk (/*) and end with an asterisk followed by a forward-slash (*/):

/*
	this is a
	multiline comment
*/

The basics

Variables #

Declaring variables #

Variable Types #

Naming Variables #

Basic Types #

integer #

decimal #

datetime #

string #

boolean #

Complex Types #

Automatic Instantiation #

Null Coalescing #

Type Safety #

Type Inference #

Duck Typing #

Comments #