Coming from Python

Most of Python carries over: dynamic types, closures, generators, exceptions, iteration over a container, and classes whose methods receive the instance. The syntax changes. Blocks use braces, indentation has no meaning, a statement ends at the end of the line, and every name is declared before it is read.

Two differences change what a program does without an error message: // is a comment, and "", [] and {} are true. Read the traps even if you skip the tables.

Values and bindings

Python	Quirrel
`x = 1`, rebindable	`local x = 1` - rebindable; `let x = 1` - binds once
`MAX = 10` by convention	`const MAX = 10 * 5`, folded at compile time
`None`, `True`, `False`	`null`, `true`, `false`
int and float are separate types	the same two, `integer` and `float`
`7 // 2`	`7 / 2`; two integers divide as integers
`7 / 2`	`7 / 2.0`; one float makes the answer a float
`2 ** 3`	`pow(2, 3)` from math
`round(2.5)` gives `2`	`round(2.5)` gives `3`; a half goes away from zero
`x if c else y`	`c ? x : y`
`f"{n} left"`	`$"{n} left"`
`"a" + b`	`$"a{b}"`, or concat; `+` joins too, and the analyzer flags it as `w264`
`"""two lines"""`	`@"two lines"`, a verbatim string with no escapes
`str(x)`, `int(s)`, `float(s)`	`x.tostring()`, `s.tointeger()`, `s.tofloat()`
`len(s)`	`s.len()`
`type(x).__name__`	`type(x)`, or `typeof x`
`x is None`	`x == null`
`a and b`, `a or b`, `not a`	`a && b`, `a \|\| b`, `!a`, and they keep the operand value
`1_000_000`	`1_000_000`
`0b1010`	no binary literal; only decimal `123` or hex `0xF2`
`# comment`	`// comment` or `/* ... */`

Containers

Python	Quirrel
`[1, 2, 3]` list	`[1, 2, 3]` array
`{"a": 1}` dict	`{ a = 1 }`, a table, with `=` inside
a key that is not a name	`{ [123] = 1 }`, any expression in the brackets
`d["k"] = v` on a new key	`d.k <- v`; plain `=` writes a slot that is already there
`d["k"]` on a missing key	it throws, as in Python; `d?[k]` gives `null`, and `??` fills in
`d.get(k, 0)`	`d?[k] ?? 0`
`del d[k]`	`d.$rawdelete(k)`
`k in d`	`k in d`
`v in items`	`items.contains(v)`; `in` on an array asks about an index
`d.keys()`, `d.values()`, `d.items()`	`d.keys()`, `d.values()`, `d.topairs()`
`items.append(v)`	`items.append(v)`, and it takes several values
`a + b` for lists	`a.extend(b)`; `+` does not join two arrays
`a[1:3]`, `a[-2:]`	`a.slice(1, 3)`, `a.slice(-2)`
`s[0]`	`s.slice(0, 1)`; `s[0]` is the character code
`",".join(parts)`	`",".join(parts)`
`s.split(",")`, `s.strip()`	`s.split(",")`, `s.strip()`
`s.replace(a, b)`	`s.replace(a, b)`, and it replaces every match
`s.find(sub)`	`s.indexof(sub)`, and `null` when the text is not there
`sorted(a)`	`let b = clone a` then `b.sort()`; `a.sort()` sorts in place
`[f(x) for x in a if p(x)]`	`a.filter(@(v) p(v)).map(@(v) f(v))`
`{a, b}`	`{ ...a, ...b }`, or `a.__merge(b)`; both return a new table
`copy.copy(a)`	`clone a`, one level deep

Control flow

Python	Quirrel
`if a: elif b: else:`	`if (a) { } else if (b) { } else { }`
`for v in seq:`	`foreach (v in seq)`
`for i, v in enumerate(seq):`	`foreach (i, v in seq)`
`for k, v in d.items():`	`foreach (k, v in d)`
`for i in range(n):`	`for (local i = 0; i < n; i++)`; there is no `range`
`while c:`	`while (c) { }`
`break`, `continue`	the same
`match`	`if (a) ... else if (b) ...`; `switch` is deprecated and off by default, see control flow
`try / except E as e / finally`	`try { } catch (e) { }`; no exception classes, and no `finally`
`raise ValueError(m)`	`throw m`; any value can be thrown, and `catch` takes them all
`assert c, m`	`assert(c, m)`
`with open(p) as f:`	no `with`; close the file yourself
`yield v`	`yield v`
`next(it)`	`resume it`
`pass`	`{ }`

Functions

Python	Quirrel
`def f(a, b = 1):`	`function f(a, b = 1) { }`
`lambda x: x * 2`	`@(x) x * 2`
`def f(*args):`	`function f(...) { }`; the extra values arrive in `vargv`
`def f(**kw):`	not there; take a table
`f(b = 1)`	not there: `'=' inside 'function argument' is forbidden`
`f(*args)`	`f.acall([this, a, b])`
a nested `def` that reads an outer name	the same
`global x`	there are no implicit globals; `global` gives a `const` or `enum` to other files
a decorator	not there; wrap the function yourself

Classes

Python	Quirrel
`class Squad:`	`class Squad { }`
`class Squad(Unit):`	`class Squad(Unit) { }`, with one base class only
`def __init__(self, n):`	`constructor(n) { }`
`self`	`this`, and one method calls another as `this.other()`
`super().__init__()`	`base.constructor()`
`self.hp = 100` in `__init__`	declare `hp = 100` in the class body; an instance takes no new slots later
`__str__`	`_tostring`
`__getitem__`, `__call__`	`_get`, `_call`; see metamethods
`@property`	`_get` and `_set`
`isinstance(x, C)`	`x instanceof C`
a class attribute	`static max = 3`, one value for every instance

Modules

Python	Quirrel
`import math`	`let math = require("math")`, or `import "math"` at compile time
`from math import floor`	`from "math" import floor`
`from math import *`	`from "math" import *`
`import numpy as np`	`import "mod" as np`
a module runs once and is cached	the same, and modules says when

Traps

// is a comment. let half = total // 2 keeps total and drops the rest of the line. There is no floor division operator, because / on two integers already truncates.
It truncates, it does not floor. -7 / 2 is -3 where Python gives -4, and -7 % 3 is -1 where Python gives 2. The sign follows the left side, as in C.
Only null, false, 0 and 0.0 are false. "", [] and {} are all true, so if (!items) never fires. Test items.len() == 0.
in tests for a key. The keys of an array are its indices, so 2 in [10, 20, 30] is true and 99 in [10, 20, 30] is false. Use contains to search for a value.
s[0] is a number. Indexing a string gives the character code, 97 for "a". There is no character type.
clone is an operator, not a function. clone(a).append(9) parses as clone (a.append(9)), which appends to a. Write (clone a).append(9).
A container in a class body is one object for every instance, like a mutable class attribute in Python. Declare the slot as null and fill it in the constructor.
A default parameter value is built once, so a mutable default is shared between calls. Python has the same trap, for the same reason.
1 / 0 throws. Arithmetic never gives inf or a quiet nan.
1 < x < 3 is not a chained comparison. It compares (1 < x) with 3, and a bool against a number throws.

examples/pages/coming-from/python.nut

// // starts a comment, so a floor division quietly loses its right side
let half = 7 // 2
println(half)

// two integers divide as integers, and neither / nor % is floored
println(7 / 2)
println(-7 / 2)
println(-7 % 3)

// only null, false, 0 and 0.0 are false
println([] ? "[] is true" : "[] is false")
println("" ? "empty string is true" : "empty string is false")

// in asks about a key, and the keys of an array are its indices
println(2 in [10, 20, 30])
println(99 in [10, 20, 30])
println([10, 20, 30].contains(20))

Output:

7
3
-3
-1
[] is true
empty string is true
true
false
true

What is not there

tuples, sets, comprehensions, with, decorators, keyword arguments
exception classes: catch (e) receives the thrown value
finally, multiple inheritance, **, //
big integers: an integer is 64 bits and it wraps
a large standard library: the modules are math, string, io, iostream, datetime, debug, system and async