Operators

Every operator in one place, including the two OSL rules that surprise people: left-to-right maths and loose string equality.

You've met most operators along the way. This lesson collects them, and spells out the two places where OSL deliberately differs from other languages.

Arithmetic, left to right#

OSL evaluates mixed arithmetic from left to right. It doesn't do multiplication before addition:

log 10 + 2 * 3

That line prints 36, because it means (10 + 2) * 3, and it also earns a PrecedenceWarning from the compiler. Write the grouping out and the warning goes away:

log (10 + 2) * 3
log 10 + (2 * 3)

The first line of the unbracketed version is (10 + 2) * 3. This is a deliberate choice: one simple rule instead of a precedence table to remember. The compiler warns whenever you mix operators without brackets, so you're never caught out silently. Bracket what you mean.

Joining#

log "n = " ++ 4
log [1, 2] ++ [3]
log {a: 1} ++ {b: 2}

Comparison#

Loose equality compares strings without case, and lets numbers and numeric text meet. Strict equality wants the same type and the same characters:

log "Yes" == "yes"
log "Yes" === "yes"
log [1, 2] == [1, 2]
log 3 in [1, 2, 3]
log "b" in "abc"

Arrays and objects compare by their contents. Class instances compare by identity: two different instances are never equal, even if their fields match.

Logic#

and and or stop as soon as they know the answer, so the right side may never run. When you mix and and or, bracket them; the compiler warns if you don't.

Assignment#

Every arithmetic and joining operator has an assigning form: +=, -=, *=, /=, %=, ^= and ++=. x++ and x-- add or take one. Two more deal with null:

string? name = null
name ??= "guest"
log name

string? stored = "kept"
string? edit = null
stored =?? edit
log stored

• a ??= b sets a to b only if a is null.
• a =?? b sets a to b only if b is not null, which is handy for applying optional changes.

Ranges, choices and pipes#

Bits#

& and, | or, ^^ exclusive or, << and >> shift. These work on whole numbers.

log 12 & 10
log 12 | 10
log 12 ^^ 10
log 1 << 4

Pointers#

@name makes a pointer to a variable, so a function can change the variable itself. std:ptr reads and writes through it. This is rare in everyday code and mostly matters when working with Go libraries:

import "std:ptr"

def bump(*int n) (
  ptr.set(n, ptr.deref(n) + 1)
)

int count = 1
bump(@count)
log count

number pi = 3.14159
number outer = 5
number inner = 3

log round(((pi * outer) ^ 2) - ((pi * inner) ^ 2))

number pi = 3.14159
number outer = 5
number inner = 3

log round(((pi * outer) ^ 2) - ((pi * inner) ^ 2))

50