# -- null
#0 -- false
#1 -- true

1_ -- минус один
0.5_ -- минус ноль целых пять десятых

1 + 2 => x

x = [1 2 3] -- массив
y = x #implode ", "
-- y = "1, 2, 3"

[1 2 3] => array #implode ' ' #dump #0
-- выдаст: "1 2 3"

a `_and b
a `_xor b
a `_or b

a `and b
a `xor b
a `or b

// precedence
enum n_prec {
    prec_leaf,        // (leaf)
    prec_x_then,    //    ? `each `for    (if-then, loop)
    prec_member,    //    a.key a[key]
    prec_rtx_assign,//    => +=> -=> *=> /=> %=> %%=> ??=>
    prec_x_assign,    //    = += -= *= /= %= %%= ??=
    prec_invoke,    //    ! &                (fn call, fn ref)
    prec_mult,        //    * / `mod
    prec_plus,        //    + - % %% &user_fn #native_fn
    prec_cmp,        //    <=>
    prec_less,        //    < <= > >=
    prec_eq,        //    == <>
    prec_and_,        //    `_and            (bitwise)
    prec_xor_,        //    `_xor
    prec_or_,        //    `_or
    prec_throw,        //    `throw
    prec_and,        //    `and            (logical)
    prec_xor,        //    `xor
    prec_or,        //    `or
    prec_nullc,        //    ??                (null coalescing)
    prec_assign,    //    = += -= *= /= %= %%= ??=
    prec_rt_assign,    //    => +=> -=> *=> /=> %=> %%=> ??=>
    prec_then,        //    ? `each `for    (if-then, loop)
    prec_pair,        //    :                (key-value pair)
    prec_root,        //    (top)
};

2 + 2 `_and 1 #dump #0
-- Это выражение на данный момент аналогично выражению:
(2 + 2) `_and (1 #dump #0)
-- вывод на экран: 1

-- И тогда:
2 + 2 `_and 1 #dump #0
-- будет аналогично выражению:
(2 + (2 `_and 1) ) #dump #0
-- что выдаст: 2

a < b < c < d -- выражение 1
-- не идентичный аналог:
(a < b) `and (b < c) `and (c < d) -- выражение 2

a == b <> c
-- аналог:
a == b `and b <> c

a < b == c < d
-- на данный момент будет аналогично:
(a < b) == (c < d)
-- ведь у оператора < и == разные приоритеты.

-- тогда выражение:
a < b == c < d
-- будет аналогично выражению:
(a < b) `and (b == c) `and (c < d)

let r = (/) ((*) ((+) 1 2) 3) 2;;
val r : int = 4

AA>let r = (/) ((*) ((+) 1 2) 3) 2;;
AA>val r : int = 4
AA>

x = (+ a b c d)
str = (?? #, pt.x, "hello")

// precedence
enum n_prec {
    prec_leaf,        // (ast leaf)
    prec_x_then,    //    _right_operand_: ? `each `for    (if-then, loop)
    prec_member,    //    a.key a[key]
    prec_xrt_assign,//    _right_operand_: => +=> -=> *=> /=> %=> %%=> `and=> `or=> `xor=> ??=> `_and=> `_or=> `_xor=>
    prec_assign,    //    = += -= *= /= %= %%= `and= `or= `xor= ??= `_and= `_or= `_xor=
    prec_invoke,    //    ! &                (fn call, fn ref)
    prec_mult,        //    * / `mod
    prec_and_,        //    `_and            (bitwise)
    prec_xor_,        //    `_xor
    prec_or_,        //    `_or
    prec_plus,        //    + - % %% &user_fn #native_fn
    prec_cmp,        //    <=>
    prec_eq,        //    == <> < <= > >=
    prec_throw,        //    `throw
    prec_and,        //    `and            (logical)
    prec_xor,        //    `xor
    prec_or,        //    `or
    prec_nullc,        //    ??                (null coalescing)
    prec_x_assign,    //    _right_operand_: = += -= *= /= %= %%= `and= `or= `xor= ??= `_and= `_or= `_xor=
    prec_rt_assign,    //    => +=> -=> *=> /=> %=> %%=> `and=> `or=> `xor=> ??=> `_and=> `_or=> `_xor=>
    prec_then,        //    ? `each `for    (if-then, loop)
    prec_pair,        //    :                (key-value pair)
    prec_root,        //    (ast top)
};