# Operators
+ - * / % -- ++               # arithmetical (float)
** %% //                      # power, unsigned mod, flooring div
& | ^ ~ >> <<                 # binary (integer)
<<< >>>                       # rotate left, right
&& || !                       # logical
> >= < <= == !=               # comparisons (boolean)
?:                            # condition, switch
x[i] x[]                      # member access, length
a..b a.. ..b ..               # ranges
|> #                          # pipe/loop/map, topic reference
./ ../ .../                   # continue/skip, break/stop, root return
>< <>                         # inside, outside
-< -/ -*                      # clamp, normalize, lerp
# Numbers
16, 0x10, 0o755, 0b0;         # int, hex, oct or binary
16.0, .1, 2e-3;               # float
π, ∞;                         # constants
1k=1000; 1s=44100; 1m=60s;    # units
10.1k, 2π, 1m30s;             # 10100, 6.283..., 66150
# Variables
foo=1, bar=2.0;               # declare vars
AbC, $0, Δx, x_1;             # names permit alnum, unicodes, _$@
foo == Foo, bar == bAr;       # case-insensitive
default=1, eval=fn, else=0;   # no reserved words
true = 0b1, false = 0b0;      # eg: alias bools
inf = 1/0, nan = 0/0;         # eg: alias infinity, NaN
# Ranges
0..10;                        # from 1 to 9 (10 exclusive)
0.., ..10, ..;                # open ranges
10..1;                        # reverse range
1.08..108.0;                  # float range
(a-1)..(a+1);                 # computed range
0..3 * 2;                     # mapped range: 0*2, 1*2, 2*2
(a,b,c) = 0..3 * 2;           # destructure: a=0, b=2, c=4
a >< 0..10, a <> 0..10;       # inside(a, 0, 10), outside(a, 0, 10);
a -< 0..10, a -<= 0..10;      # clamp(a, 0, 10), a = clamp(a, 0, 10)
a -< ..10, a -< 10..;         # min(a, 10), max(a, 10)
a -* 0..10, a -/ 0..10;       # lerp(a, 0, 10), normalize(a, 0, 10)
# Groups
(a,b,c) = (1,2,3);            # assign: a=1, b=2, c=3
(a,b) = (b,a);                # swap
(a,b,c) = d;                  # duplicate: a=d, b=d, c=d
(a,,b) = (c,d,e);             # skip: a=c, b=e
(a,b) + (c,d);                # group binary: a+c, b+d
(a, b, c)++;                  # group unary: a++, b++, c++
(a,b)[1] = c[2,3];            # props: a[1]=c[2], b[1]=c[3]
(a,..,z) = (1,2,3,4);         # pick: a=1, z=4
a = (b,c,d);                  # pick first: a=b; see loops
(a,(b,(c))) == (a,b,c);       # groups are always flat
# Arrays
m = [..10];                   # array of 10 elements
m = [..10 |> 2];              # filled with 2
m = [1,2,3,4];                # array of 4 elements
m = [n[..]];                  # copy n
m = [1, 2..4, 5];             # mixed definition
m = [1, [2, 3, [4, m]]];      # nested arrays (tree)
m = [0..4 |> $ ** 2];         # list comprehension
(a, z) = (m[0], m[-1]);       # get by index
(b, .., z) = m[1, 2..];       # get multiple values
length = m[];                 # get length
m[0] = 1;                     # set value
m[2..] = (1, 2..4, n[1..3]);  # set multiple values from offset 2
m[1,2] = m[2,1];              # swap
m[0..] = m[-1..];             # reverse
m[0..] = m[1..,0];            # rotate
# Strings
hi="Hello";                   # creates static array
string="$<hi>, world!";       # interpolate: "hello world"
string[1, 3..5, -2];          # pick elements: 'e', 'lo', 'd'
string[0..5];                 # substring: 'Hello'
string[-1..0];                # reversed: '!dlrow ,olleH'
string[];                     # length: 13
# Conditions
a ? b : c;                    # if a then b else c
a ? b;                        # if a then b (else 0)
a ?: b;                       # if (a then 0) else b
val = (                       # switch
  a == 1 ? ./1;               # if a == 1 then val = 1
  a >< 2..4 ? ./2;            # if a in 2..4 then val = 2
  3                           # otherwise 3
);
a ? ./b;                      # early return: if a then return b
# Loops
(a, b, c) |> f($);            # for each item in a, b, c do f(item)
(i = 10..) |> (               # descend over range
  i < 5 ? ./a;                # if item < 5 skip (continue)
  i < 0 ? ../a;               # if item < 0 stop (break)
);
x[..] |> f($) |> g($);        # pipeline sequence
(i = 0..w) |> (               # nest iterations
  (j = 0..h) |> f(i, j);      # f(x,y)
);
((a,b) = 0..10) |> a+b;       # iterate pairs
(x,,y) = (a,b,c) |> $ * 2;    # capture result x = a*2, y = c*2;
.. |> i < 10 ? i++ : ../;     # while i < 10 i++
# Functions
double(n) = n*2;              # define a function
times(m = 1, n -< 1..) = (    # optional, clamped arg
  n == 0 ? ./n;               # early return
  m * n;                      # returns last statement
);
times(3,2);                   # 6
times(4), times(,5);          # 4, 5: optional, skipped arg
dup(x) = (x,x);               # return multiple
(a,b) = dup(b);               # destructure
a,b; x()=(a=1;b=1); x();      # first expr declares locals, last returns
fn() = ( x ;; log(x) );       # defer: log(x) after returning x
f(a, cb) = cb(a[0]);          # array, func args
# State vars
a() = ( *i=0; i++ );          # i persists value
a(), a();                     # 0, 1
a.i = 0;                      # reset state
*a1 = a;                      # clone function
a(), a(); a1(), a1();         # 0, 1; 0, 1;
f() = ( *i=0;; i++; ... );    # couples with defer
# Export
x, y, z;                      # exports last statement