Operators and expressions

let magazineSize = 30
let roundsFired = 7

// integer / integer truncates toward zero, it does not round
let fullReloads = magazineSize / roundsFired
println("fullReloads =", fullReloads)

// mix in a float and the result promotes to float
let secondsPerRound = 1.5
println("roundsFired * secondsPerRound =", roundsFired * secondsPerRound)

// % keeps the sign of the left operand, like C
println("-roundsFired % 3 =", -roundsFired % 3)

// DEPRECATED:
// + is the one arithmetic operator that also does string concat:
// a string operand makes + stringify and join instead of adding
println("rounds left: " + (magazineSize - roundsFired))

fullReloads = 4
roundsFired * secondsPerRound = 10.5
-roundsFired % 3 = -1
rounds left: 23

let squads = [
  { name = "bravo", strength = 9 },
  { name = "alpha", strength = 4 },
  { name = "charlie", strength = 6 },
]

// == != < <= > >= all return a real bool
println("squads[0].strength > squads[1].strength =", squads[0].strength > squads[1].strength)

// <=> returns an int: negative, zero or positive, not just a bool,
// which is exactly what sort() wants from its comparator
squads.sort(@(a, b) a.strength <=> b.strength)
foreach (squad in squads)
  println($"{squad.name}: {squad.strength}")

// the ternary picks one of two expressions, not two statements
let weakest = squads[0]
println("weakest.strength > 5 =", weakest.strength > 5 ? "combat ready" : "needs reinforcement")

squads[0].strength > squads[1].strength = true
alpha: 4
charlie: 6
bravo: 9
weakest.strength > 5 = needs reinforcement

// only null, false, integer 0 and float 0.0 are falsy;
// "" and [] and {} are truthy, unlike some other scripting languages
println("[] =", [] ? "truthy" : "falsy")
println("0 =", 0 ? "truthy" : "falsy")

// && and || return one of their OPERANDS, not necessarily a bool,
// and short-circuit: the second side is not even evaluated
function ammoBelt() {
  println("ammoBelt() evaluated")
  return "belt_762"
}
let preferredAmmo = null
println("preferredAmmo && ammoBelt() =", preferredAmmo && ammoBelt())
println("preferredAmmo || ammoBelt() =", preferredAmmo || ammoBelt())

// ! always returns a real bool
let hitPoints = 0
println("!hitPoints =", !hitPoints)
println("typeof !hitPoints =", typeof !hitPoints)

[] = truthy
0 = falsy
preferredAmmo && ammoBelt() = null
ammoBelt() evaluated
preferredAmmo || ammoBelt() = belt_762
!hitPoints = true
typeof !hitPoints = bool

let vehicle = { turretAngle = 0.0, gunner = null }

// ?? only tests for null, unlike a truthy check: a real 0.0 survives it
println("vehicle.turretAngle ?? 45.0 =", vehicle.turretAngle ?? 45.0)

// a plain || default would get this wrong: 0.0 is falsy, so it falls
// through to 45.0 even though 0.0 is a legitimate angle
println("vehicle.turretAngle || 45.0 =", vehicle.turretAngle || 45.0)

// ?. stops a missing/null step from throwing, and once it fires the
// rest of the chain (.,  [], ()) is null-safe too, without repeating ?.
println("vehicle.gunner?.rank.tostring() =", vehicle.gunner?.rank.tostring())

// ?[ ] is the null-safe form of the index operator
let squad = null
println("squad?[\"leader\"] =", squad?["leader"])

vehicle.turretAngle ?? 45.0 = 0
vehicle.turretAngle || 45.0 = 45
vehicle.gunner?.rank.tostring() = null
squad?["leader"] = null

let loadout = { rifle = "ak74", helmet = "ssh68" }
println("\"rifle\" in loadout =", "rifle" in loadout)
println("\"boots\" not in loadout =", "boots" not in loadout)

// on an array 'in' tests the INDEX, not the value: it asks
// "is there a slot at this position", not "does this value occur"
let ammoBelt = [30, 30, 20]
println(1 in ammoBelt)     // index 1 exists
println(20 in ammoBelt)    // 20 is a value in the array, but not a valid index

class Vehicle {}
class Tank(Vehicle) {}
let myTank = Tank()
println("myTank instanceof Vehicle =", myTank instanceof Vehicle)
println("myTank instanceof Tank =", myTank instanceof Tank)

println("typeof myTank =", typeof myTank)
println("typeof ammoBelt =", typeof ammoBelt)

"rifle" in loadout = true
"boots" not in loadout = true
true
false
myTank instanceof Vehicle = true
myTank instanceof Tank = true
typeof myTank = instance
typeof ammoBelt = array

let squad = { name = "alpha" }
println("squad.$len() =", squad.$len())      // the built-in table method

// a slot can carry the same name as a method, and then it wins
let shadowed = { name = "bravo", len = "a field, not a method" }
println("shadowed.len =", shadowed.len)
println("shadowed.$len() =", shadowed.$len())  // $ never sees the slot

try { shadowed.len() } catch (e) { println("shadowed.len() throws:", e) }

squad.$len() = 1
shadowed.len = a field, not a method
shadowed.$len() = 2
shadowed.len() throws: attempt to call 'string'

let loadoutTemplate = { weaponName = "ak74", ammoBelt = [30, 30] }

// clone is a shallow copy: top-level slots are copied, nested
// containers (like ammoBelt here) are shared with the original
let squadLoadout = clone loadoutTemplate
squadLoadout.weaponName = "svd"
squadLoadout.ammoBelt.append(20)

println("loadoutTemplate.weaponName =", loadoutTemplate.weaponName)
println("squadLoadout.weaponName =", squadLoadout.weaponName)
println("loadoutTemplate.ammoBelt.len() =", loadoutTemplate.ammoBelt.len())

loadoutTemplate.weaponName = ak74
squadLoadout.weaponName = svd
loadoutTemplate.ammoBelt.len() = 3

let mission = {}

// <- adds a field that did not exist before
mission.name <- "capture_the_flag"
mission["reward"] <- 500

// once the slot exists, <- behaves exactly like a plain assignment
mission.reward <- 750
println("mission.reward =", mission.reward)

// = never creates a slot: writing an unknown field throws
try {
  mission.duration = 300
} catch (e) {
  println("caught:", e)
}

mission.reward = 750
caught: the index 'duration' (type='string') does not exist

let squad = { strength = 4 }
squad.strength += 3
squad.strength *= 2
println("squad.strength =", squad.strength)

local reloadSeconds = 3
// post: yields the old value, THEN steps; pre: steps first, yields the new one
println("reloadSeconds-- =", reloadSeconds--)
println("--reloadSeconds =", --reloadSeconds)

// compound assignment still requires the slot to already exist
try {
  squad.readiness += 1
} catch (e) {
  println("caught:", e)
}

squad.strength = 14
reloadSeconds-- = 3
--reloadSeconds = 1
caught: the index 'readiness' (type='string') does not exist

class MyPoint2 {
  x = 0
  y = 0
  constructor(ax, ay) { this.x = ax; this.y = ay }

  // getclass() rather than the class name: the name is not in scope inside the
  // body, and this keeps working for a subclass
  function _add(other) { return this.getclass()(this.x + other.x, this.y + other.y) }
  function _sub(other) { return this.getclass()(this.x - other.x, this.y - other.y) }
  function _mul(k)     { return this.getclass()(this.x * k, this.y * k) }
  function _unm()      { return this.getclass()(-this.x, -this.y) }
  // one _cmp drives <, <=, >, >= and == at once
  function _cmp(other) { return (this.x * this.x + this.y * this.y)
                             <=> (other.x * other.x + other.y * other.y) }
  function _tostring() { return $"({this.x}, {this.y})" }
  function _typeof()   { return "MyPoint2" }
}

let muzzle = MyPoint2(3, 4)
let recoil = MyPoint2(1, 2)

println("muzzle + recoil =", muzzle + recoil)
println("muzzle - recoil =", muzzle - recoil)
println("muzzle * 2 =", muzzle * 2)
println("-muzzle =", -muzzle)
println("muzzle > recoil =", muzzle > recoil)
println("muzzle == recoil =", muzzle == recoil)
println("typeof muzzle =", typeof muzzle)
println("type(muzzle) =", type(muzzle))

muzzle + recoil = (4, 6)
muzzle - recoil = (2, 2)
muzzle * 2 = (6, 8)
-muzzle = (-3, -4)
muzzle > recoil = true
muzzle == recoil = false
typeof muzzle = MyPoint2
type(muzzle) = instance

local built = 0

function palette() {
  built++
  return { sky = "#8ec5ff", ground = "#6b5a3e" }
}

function draw() {
  let colors = static palette()
  return colors.sky
}

println(draw())
println(draw())
println($"palette() ran {built} time(s)")

// The cached container is frozen, so no caller can corrupt it for the rest.
let colors = static palette()
try {
  colors.sky = "#000000"
} catch (e) {
  println($"write: {e}")
}

// One cache per code location, not per evaluation: the loop body caches on its
// first pass and reuses that value for every later one.
function tally() {
  let before = built
  for (local i = 0; i < 3; i++) {
    let c = static palette()
    c.sky
  }
  return built - before
}
println($"three passes through the loop called palette() {tally()} time(s)")

#8ec5ff
#8ec5ff
palette() ran 1 time(s)
write: trying to modify immutable 'table'
three passes through the loop called palette() 1 time(s)

let ammoLeft = 0

// trap: ?? binds LOOSER than comparisons, so this is ammoLeft ?? (ammoLeft > 0),
// not (ammoLeft ?? ammoLeft) > 0
println("ammoLeft ?? ammoLeft > 0 =", ammoLeft ?? ammoLeft > 0)

// trap: shifts bind TIGHTER than comparisons
println("1 << 2 == 4 =", 1 << 2 == 4)

// trap: && binds tighter than ||, so this is (squadReady && hasFuel) || override
let squadReady = true
let hasFuel = false
let override = true
println("squadReady && hasFuel || override =", squadReady && hasFuel || override)

ammoLeft ?? ammoLeft > 0 = 0
1 << 2 == 4 = true
squadReady && hasFuel || override = true

let activeMissions = { capture_flag = true, defend_base = true }

// the 'delete' operator is forbidden by default (see below); use rawdelete
println("activeMissions.rawdelete(\"capture_flag\") =", activeMissions.rawdelete("capture_flag"))
println("\"capture_flag\" in activeMissions =", "capture_flag" in activeMissions)
println("\"defend_base\" in activeMissions =", "defend_base" in activeMissions)

activeMissions.rawdelete("capture_flag") = true
"capture_flag" in activeMissions = false
"defend_base" in activeMissions = true