;; Operators
  - * / % --                  ;; arithmetical (float)
** %% //                      ;; power, unsigned mod, flooring div
& | ^ ~ >> <<                 ;; binary (integer)
<<< >>>                       ;; rotate left, right
&& || !                       ;; logical
> >= < <= == !=               ;; comparisons (boolean)
?: ?                          ;; conditions
x[i] x[]                      ;; member access, length
a..b a.. ..b ..               ;; ranges
|> #                          ;; pipe/loop, map
./ ../ /                      ;; continue/skip, break/stop, return
~ ~/ ~*                       ;; clamp, normalize, lerp
* ^                           ;; static, defer

;; Numbers
16, 0x10, 0b0;                ;; int, hex or binary
16.0, .1, 2e-3;               ;; float
1k = 1000; 1pi = 3.1415926;   ;; units
1s = 44100; 1m = 60s;         ;; eg: sample indexes
10.1k, 2pi, 1m30s;            ;; 10100, 6.283..., 66150

;; Variables
foo=1, bar=2.0;               ;; declare vars
AbC, $0, Δx, x@1, A#;         ;; 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 && a < 10
a ~ 0..10;                    ;; clamp(a, 0, 10);
a ~/ 0..10;                   ;; normalize(a, 0, 10)
a ~* 0..10;                   ;; lerp(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

;; 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]]];         ;; 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

;; Conditions
a ? b;                        ;; if a then b (else nan)
sign = a < 0 ? -1 :  1;       ;; ternary conditional
(2 2 >= 4) ? log(1) :         ;; multiline/switch
  3 <= 1..2 ? log(2) :        ;; else if
  log(3);                     ;; else
a && b || c;                  ;; (a and b) or c

;; 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=1,b=1; x()=(a=2;b=2); x();  ;; a==1, b==2: first statement declares locals

;; Static vars
a() = ( *i=0;   i );          ;; i keeps value between calls
a(), a();                     ;; 1,2
a1() = ( *copy=a; copy() );   ;; clone function
a(), a(); a1(), a1();         ;; 3,4; 1,2;
f() = ( *t=0; ^t  ; t*2 );    ;; defer: t   called after return
x(a[], f()) = f(a[0]);        ;; array, func args

;; Export
x, y, z;                      ;; exports last statement