Operators¶

Basic Operators¶

These operators are all binary, requiring two operands. All of these operators can be implemented by a type containing the properly named method. Only the left-hand operand’s method is called. None of these operators should modify either operand, but must return a new object. The examples that follow show the use of each operator:

op1 + op2
// => // Returns the value of adding op2 to op1

op1 - op2
// => // Returns the value of subtracting opt2 from op1

op1 * op2
// => // Returns the value of multiplying op1 by op2

op1 / op2
// => // Returns the value of dividing op1 by op2

op1 % op2
// => // Returns the remainder of dividing op1 by op2 (modulo operation)

(: 10 + 3, 10 - 3, 10 * 3, 10 / 3, 10 % 3)
// => staticarray(13, 7, 30, 3, 1)

Assignment Operators¶

While the basic arithmetical operators use their operands to produce a new value, Lasso supports syntax for applying the operator to one of the operands. The following operators perform their operation and assign the result to the left-hand side operand. Only the left-hand operand can be assigned to and not every expression is capable of being assigned to, as described in the section on assignment operations. These assignment expressions do not produce a value.

// Equivalent to op1 = op1 + op2
op1 += op2

// Equivalent to op1 = op1 - op2
op1 -= op2

// Equivalent to op1 = op1 * op2
op1 *= op2

// Equivalent to op1 = op1 / op2
op1 /= op2

// Equivalent to op1 = op1 % op2
op1 %= op2

During parsing, these operators are expanded to their regular arithmetical and assignment operations, so a type does not need to do anything to support them aside from implementing the assignment operator method and the appropriate arithmetical operator method.

Pre-/Post-Increment and Decrement Operators¶

There is a common need to “advance” an object in a bidirectional manner. Usually this is done using integers as counters, though the concept can be applied elsewhere. Lasso supports the increment and decrement operators (++ and --) in both pre and post modes.

Pre-incrementing and pre-decrementing an object will add or subtract 1 to or from the object and then produce that object as a result. Post-incrementing and post-decrementing an object first copies that object, then adds or subtracts 1 to or from the original operand, then produces the copied object as a result.

// Pre-increment "op"
++op
// => // Produces the newly incremented "op"

// Pre-decrement "op"
--op
// => // Produces the newly decremented "op"

// Post-increment "op"
op++
// => // Produces a copy of "op" before incrementing

// Post-decrement "op"
op--
// => // Produces a copy of "op" before decrementing

These increment/decrement operators are translated into regular arithmetical method calls with “1” as the method parameter. This means that if a type is intended to be used with the increment (++) and decrement (--) operators, all that’s necessary is to implement + and - which will be called with “1” as the parameter.

Positive and Negative Operators¶

Lasso supports the unary operators which are typically intended to change the sign of an integer or decimal number. These operators can be applied to any object that supports them. When applied, these operators will produce a new object, leaving the single operand unchanged.

+op1
// => // Produces a new object whose value is positive op1

-op1
// => // Produces a new object whose value is negative op1

Types can implement this operator by defining a method named + or - that accepts no parameters. When unary + or - is applied to integer or decimal literals, no method call is generated. Instead, the positive or negative number is created from the beginning.

Logical Operators¶

There are three logical operators. The first is the unary operator “not”. This operator treats its single operand as a boolean value and produces the opposite of that value. The “not” operator turns a “true” into a “false” and a “false” into a “true”. Although the operand can be of any type, this operator always produces a “true” or “false” value. The “not” operator can take one of two forms: an exclamation mark (!) or the not keyword.

!true
// => false

not false
// => true

The other two logical operators are logical “and” and logical “or”, and they also can take two forms: double ampersands (&&) or the and keyword for logical “and”, and double pipes (||) or the or keyword for logical “or”.

These binary operators treat their first operand as a boolean value and perform their operation based on that value. Logical “and” inspects its first operand, and if it is “true”, produces its second operand. If the first operand is “false”, logical “and” will produce the value “false”. Logical “or” inspects its first operand, and if it is “true”, produces that first operand. If the first operand is “false”, logical “or” will produce the second operand.

op1 && op2
// => // Returns "false" if either op1 or op2 evaluates to "false" else opt2

op1 || op2
// => // Returns op1 if it evaluates to "true" else op2

These operators perform shortcut evaluation, meaning that if the result of the operation is determined before the second operand is evaluated, the second operand will not be evaluated. Also note that the behavior of the logical operators cannot be defined by the operand objects.

Equality Operators¶

The equality operators are used to determine if one object is logically equivalent to another. These operators are split into positive and negative equality tests as well as strict and non-strict equality tests. A positive equality test checks if one object is equal to another object while a negative equality test checks if an object is not equal to another. Strict equality testing further tests the types of the operand objects. If the right-hand operand is not an instance of the type of the left-hand operand, the equality test fails. These operators all produce either a “true” or “false” value.

op1 == op2
// => // Produces "true" if op1 is equal to op2 else false

op1 != op2
// => // Produces "true" if op1 is not equal to op2 else false

op1 === op2
// => // Produces "true" if op1 is both equal to and the same type as op2 else false

op1 !== op2
// => // Produces "true" if op1 is not equal to or not the same type as op2 else false

(: 3 == 3.0, 3 != 3.0, 3 === 3.0, 3 !== 3.0)
// => staticarray(true, false, false, true)

For allowing an object to be tested for equality against another, its type must implement a method named onCompare, which is automatically called at runtime to perform equality checks. It must require one parameter for the right-hand operand, which will be compared to the left-hand operand. When called, it indicates whether the left-hand operand is less than, equal to, or greater than the right-hand operand by returning either an integer less than zero, zero, or greater than zero, respectively. The act of checking the object types in the case of strict equality testing is automatically performed by the runtime, so a type need not account for that scenario in its own implementation of onCompare.

Relative Equality Operators¶

The relative equality operators indicate whether an object is less than, greater than, or possibly equal to another object. These operators all produce either a “true” or “false” value.

op1 < op2
// => // Produces "true" if op1 less than op2 else "false"

op1 > op2
// => // Produces "true" if op1 greater than op2 else "false"

op1 <= op2
// => // Produces "true" if op1 less than or equal to op2 else "false"

op1 >= op2
// => // Produces "true" if op1 greater than or equal to op2 else "false"

Types control how equality checks behave by implementing the onCompare method as described above in the section on equality operators. Because onCompare is required to return an integer value (either zero, less than zero, or greater than zero), it can handle all possible types of equality tests.

Containment Operators¶

There are two containment operators used to test if an object “contains” another object. One checks for positive containment (>>) and the other for negative containment (!>>). Both are binary operators and both produce either a “true” or “false” value.

op1 >> op2
// => // Produces "true" if op2 is contained within op1 else false

op1 !>> op2
// => // Produces "true" if op2 is not contained within op1 else false

To support containment testing, a type must implement a method named contains which requires one parameter for the right-hand operand and returns a boolean “true” or “false”. Only the left-hand operand will have its contains method called.

Containment testing only logically applies to certain types of objects. For example, it makes no sense to ask what an integer object contains, because it is scalar, consisting of only one value. Containment testing is primarily done on collection types such as array or map. Objects of those types can contain any number of other arbitrary objects, so it makes sense to query them for their contents.

Conditional Operator¶

The conditional operator allows for concisely implementing if/then/else logic in which an expression is tested and depending on its boolean value, either the “then” or the “else” expressions will be executed and their values produced as the result of the operator. The “then” and “else” can consist of only one expression. The “else” portion of a conditional operator may be omitted. In such a case, if the condition is “false”, a “void” object will be produced.

The conditional operator is a ternary operator consisting of the two “?” and “|” characters. The “?” follows the test condition and the “|” delimits the “then” and “else” expressions. A conditional operator with no “else” condition will have no delimiting “|” character.

test ? expression1 | expression2
// => // Produces expression1 if test is "true" else expression2

test ? expression
// => // Produces expression if test is "true" else void

Retarget Operation¶

The retarget operation allows the same target object to be used for multiple method calls. The retarget operator (&) is placed between the individual method calls. Retarget is only ever used in the context of a member method call using the target operator (->). The target object of the last target operator is used as the object for the retargeted member call. For each method call, the & is placed following the method’s name, parameters, and capture block (if present).

The retarget operator can string two or more methods together. The return value of the final method will be produced by this type of retarget.

object->meth & meth2
// => // Execute meth on the object then execute meth2 and produce its value

object->meth(1, 2) & meth2()
// => // Execute meth on the object then execute meth2 and produce its value

Retarget can also be used to change the produced value of a member method call to be that of the target object. This is done by having a trailing & at the end of a method call.

targetObject->meth(1, 2) &;
// => // Execute meth, but produce targetObject

targetObject->meth(5, 7)
& meth2()
& meth3(90) &;
// => // Execute meth, meth2, meth3, and then produce targetObject