Operators ​

Operators combine values into new values. Most, like arithmetic and comparison operators, work the same way they do in other languages. Two operators are specific to WEL:

• The pipeline: >> turns a multi-step transformation into a single line that reads top to bottom.
• The fallbacks: | and |? supply a default value instead of a nested conditional.

_ is the input your expression receives in these examples. Refer to Input variables for more information.

Precedence ​

The following table lists operators by precedence. Operators higher in the table run before ones lower in it, regardless of where each appears in the expression. Parentheses (()) override precedence order. Wrap part of an expression in parentheses to evaluate it first.

Arithmetic ​

+ - * / % ^ work on Integer, Float, and Decimal.

Dividing by zero raises E200 rather than producing infinity.

Decimal and Float can't mix. Refer to Data types for which types support arithmetic.

Dates and durations ​

Operators also work on temporal data types. Add an Integer to a PlainDate to add days, subtract two dates to return the number of days between them, and subtract two instants to return a Duration. Use advance_date or add_months instead for calendar arithmetic where the answer depends on month lengths.

Concatenation ​

++ joins two values of the same type.

Mixing types raises E101. 'x' ++ 1 is an error, not x1. Convert with String(...), or use an f-string, which converts as it interpolates.

Pipeline operator ​

>> passes the value on its left as the first argument to the function on its right.

Pipelines read left to right, in the order the steps run. In the following examples lower runs first, then trim, then upper:

_.email >> lower >> trim >> upper

Nested calls can achieve the same result as pipelines, but they force you to read the transformation inside-out:

upper(trim(lower(_.email)))

This is especially important with lambdas, where nesting quickly becomes unreadable:

take(reverse(sort_by(filter_by(_.orders, o ~> o.status == 'open'), o ~> o.total)), 3)

_.orders
  >> filter_by(o ~> o.status == 'open')
  >> sort_by(o ~> o.total)
  >> reverse
  >> take(3)

Fallbacks ​

The fallback operators solve different problems:

Null value fallback ​

| handles null values.

presence reports every kind of absence as null so one fallback operator (| ) catches them all, including empty strings, whitespace-only strings, empty lists, and empty maps.

presence(_.display_name) | 'Unknown'

Error fallback ​

|? catches errors.

Reading a field that doesn't exist raises E104 rather than producing null, so | won't catch it and |? will:

_.customer.nickname |? 'none'

Refer to Error codes for which errors are catchable.

Comparison ​

== != < > <= >= compare two values.

Numeric comparison is by value, so an Integer and a Float holding the same number are equal.

Text that looks identical isn't always equal, because the same characters can be stored more than one way. Use unicode_compare to compare text from two different systems.

Containment ​

in tests whether a value is an element of a list.

in is list-only. Use one of the following alternatives for other types:

• Substring: Use contains?. 'WID' in 'WID-1' raises E101.
• Map key: Use has_key?. 'a' in {a: 1} raises E101.

Logic ​

and, or, and not are spelled as words.

Conditionals ​

if ... then ... else ... is an expression. It produces a value, so it can go anywhere a value can.

The following example shows a conditional inside a map:

{
  tier: if _.total > 1000 then 'gold' else 'standard'
}

Related ​

• Data types: Which operators apply to which types.
• Strings and formatting: More information about f-strings and interpolation.
• Standard library: The functions you pipe into.
• Error codes: Troubleshoot job failures such as E101, E103, E104, and E200.