Language Definition

Literals

Comment	/* */ or //
Boolean	true, false
Integer	42, 0x2A
Float	0.5, .5
String	"foo", 'bar'
Array	[1, 2, 3]
Map	{a: 1, b: 2, c: 3}
Nil	nil

Operators

Arithmetic	+, -, *, /, % (modulus), ^ or ** (exponent)
Comparison	==, !=, <, >, <=, >=
Logical	not or !, and or &&, or or ||
Conditional	?: (ternary), ?? (nil coalescing)
Membership	[], ., ?., in
String	+ (concatenation), contains, startsWith, endsWith
Regex	matches
Range	..
Slice	[:]
Pipe	|

Examples:

user.Age in 18..45 and user.Name not in ["admin", "root"]

foo matches "^[A-Z].*"

Membership Operator

Fields of structs and items of maps can be accessed with . operator or [] operator. Elements of arrays and slices can be accessed with [] operator. Negative indices are supported with -1 being the last element.

The in operator can be used to check if an item is in an array or a map.

user.Name in list["available-names"]

Optional chaining

The ?. operator can be used to access a field of a struct or an item of a map without checking if the struct or the map is nil. If the struct or the map is nil, the result of the expression is nil.

author?.User?.Name

Nil coalescing

The ?? operator can be used to return the left-hand side if it is not nil, otherwise the right-hand side is returned.

author?.User?.Name ?? "Anonymous"

Slice Operator

The slice operator [:] can be used to access a slice of an array.

For example, variable array is [1, 2, 3, 4, 5]:

array[1:4] == [2, 3, 4]
array[1:-1] == [2, 3, 4]
array[:3] == [1, 2, 3]
array[3:] == [4, 5]
array[:] == array

Pipe Operator

The pipe operator | can be used to pass the result of the left-hand side expression as the first argument of the right-hand side expression.

For example, expression split(lower(user.Name), " ") can be written as:

user.Name | lower() | split(" ")

Built-in Functions

all(array, predicate)

Returns true if all elements satisfies the predicate. If the array is empty, returns true.

all(Tweets, {.Size < 280})

any(array, predicate)

Returns true if any elements satisfies the predicate. If the array is empty, returns false.

one(array, predicate)

Returns true if exactly one element satisfies the predicate. If the array is empty, returns false.

one(Participants, {.Winner})

none(array, predicate)

Returns true if all elements does not satisfy the predicate. If the array is empty, returns true.

map(array, predicate)

Returns new array by applying the predicate to each element of the array.

filter(array, predicate)

Returns new array by filtering elements of the array by predicate.

count(array, predicate)

Returns the number of elements what satisfies the predicate. Equivalent to:

len(filter(array, predicate))

len(v)

Returns the length of an array, a map or a string.

type(v)

Returns the type of the given value v. Returns on of the following types: nil, bool, int, uint, float, string, array, map. For named types and structs, the type name is returned.

type(42) == "int"
type("hello") == "string"
type(now()) == "time.Time"

abs(v)

Returns the absolute value of a number.

int(v)

Returns the integer value of a number or a string.

int("123") == 123

float(v)

Returns the float value of a number or a string.

string(v)

Converts the given value v into a string representation.

string(123) == "123"

trim(v[, chars])

Removes white spaces from both ends of a string v. If the optional chars argument is given, it is a string specifying the set of characters to be removed.

trim("  Hello  ") == "Hello"
trim("__Hello__", "_") == "Hello"

trimPrefix(v, prefix)

Removes the specified prefix from the string v if it starts with that prefix.

trimPrefix("HelloWorld", "Hello") == "World"

trimSuffix(v, suffix)

Removes the specified suffix from the string v if it ends with that suffix.

trimSuffix("HelloWorld", "World") == "Hello"

upper(v)

Converts all the characters in string v to uppercase.

upper("hello") == "HELLO"

lower(v)

Converts all the characters in string v to lowercase.

lower("HELLO") == "hello"

split(v, delimiter[, n])

Splits the string v at each instance of the delimiter and returns an array of substrings.

split("apple,orange,grape", ",") == ["apple", "orange", "grape"]
split("apple,orange,grape", ",", 2) == ["apple", "orange,grape"]

splitAfter(v, delimiter[, n])

Splits the string v after each instance of the delimiter.

splitAfter("apple,orange,grape", ",") == ["apple,", "orange,", "grape"]
splitAfter("apple,orange,grape", ",", 2) == ["apple,", "orange,grape"]

replace(v, old, new)

Replaces all occurrences of old in string v with new.

replace("Hello World", "World", "Universe") == "Hello Universe"

repeat(v, n)

Repeats the string v n times.

repeat("Hi", 3) == "HiHiHi"

join(v[, delimiter])

Joins an array of strings v into a single string with the given delimiter. If no delimiter is given, an empty string is used.

join(["apple", "orange", "grape"], ",") == "apple,orange,grape"
join(["apple", "orange", "grape"]) == "appleorangegrape"

indexOf(v, substring)

Returns the index of the first occurrence of the substring in string v or -1 if not found.

indexOf("apple pie", "pie") == 6

lastIndexOf(v, substring)

Returns the index of the last occurrence of the substring in string v or -1 if not found.

lastIndexOf("apple pie apple", "apple") == 10

hasPrefix(v, prefix)

Returns true if string v starts with the given prefix.

hasPrefix("HelloWorld", "Hello") == true

hasSuffix(v, suffix)

Returns true if string v ends with the given suffix.

hasSuffix("HelloWorld", "World") == true

max(v1, v2)

Returns the maximum of the two values v1 and v2.

max(5, 7) == 7

min(v1, v2)

Returns the minimum of the two values v1 and v2.

min(5, 7) == 5

toJSON(v)

Converts the given value v to its JSON string representation.

toJSON({"name": "John", "age": 30})

fromJSON(v)

Parses the given JSON string v and returns the corresponding value.

fromJSON('{"name": "John", "age": 30}')

toBase64(v)

Encodes the string v into Base64 format.

toBase64("Hello World") == "SGVsbG8gV29ybGQ="

fromBase64(v)

Decodes the Base64 encoded string v back to its original form.

fromBase64("SGVsbG8gV29ybGQ=") == "Hello World"

now()

Returns the current date and time.

createdAt > now() - duration(1h)

duration(v)

Returns time.Duration value of the given string v.

Valid time units are "ns", "us" (or "µs"), "ms", "s", "m", "h".

duration("1h").Seconds() == 3600

date(v[, format[, timezone]])

Converts the given value v into a date representation.

If the optional format argument is given, it is a string specifying the format of the date. The format string uses the same formatting rules as the standard Go time package.

If the optional timezone argument is given, it is a string specifying the timezone of the date.

If the format argument is not given, the v argument must be in one of the following formats:

• 2006-01-02
• 15:04:05
• 2006-01-02 15:04:05
• RFC3339
• RFC822,
• RFC850,
• RFC1123,

date("2023-08-14")
date("15:04:05")
date("2023-08-14T00:00:00Z")
date("2023-08-14 00:00:00", "2006-01-02 15:04:05", "Europe/Zurich")

first(v)

Returns the first element from an array v. If the array is empty, returns nil.

first([1, 2, 3]) == 1

last(v)

Returns the last element from an array v. If the array is empty, returns nil.

last([1, 2, 3]) == 3

get(v, index)

Retrieves the element at the specified index from an array or map v. If the index is out of range, returns nil. Or the key does not exist, returns nil.

get([1, 2, 3], 1) == 2
get({"name": "John", "age": 30}, "name") == "John"

Predicate

The predicate is an expression that accepts a single argument. To access the argument use the # symbol.

map(0..9, {# / 2})

If items of the array is a struct or a map, it is possible to access fields with omitted # symbol (#.Value becomes .Value).

filter(Tweets, {len(.Value) > 280})

Braces { } can be omitted:

filter(Tweets, len(.Value) > 280)

$env variable

The $env variable is a map of all variables passed to the expression.

Foo.Name == $env["Foo"].Name