x = 10;                         // 'x' declared, assigned 10, type becomes 'Number' 
{                               // opening a block (entering scope) 
    x = "hello";                // previous (global) 'x, now assigned 'hello', type set as 'String' 
    print(typeof(x));           // prints type of global 'x', being 'String' 
    local x = ::x +",world";    // new local 'x' at block scope assigned the global 'x' + ',world' 
    print(typeof(x));           // prints type of local 'x' (closest one), being 'String' 
    print(typeof(::x));         // prints type of global 'x', also being 'String' 
    print(x, "\n");             // prints value of local 'x' and a new line 
    print(typeof(print));       // prints type of library func 'print' being 'LibraryFunc' 
}                               // closing the block (exiting scope)

function f (x,y)                    // definition of a named function 'f' at global scope
    { return x + y; }               // no trailing ';' is needed after func (harmless to add one)
print(typeof(f));                   // prints type of 'f' being 'ProgramFunc' string
const nl = "\n";                    // defines a constant 'nl' at global scope
print((x = f)("1", 2), nl);         // assigns 'f' to 'x', calls 'f' with '1' and 2, printing '12' 
f = x;                              // compile error, as user-defined functions are not variables 
id =                                // 'id' is a var asigned a func expression
    ( function(x){ return x; } );   // any func definition around ( ) is an expression 
print(id(id));                      // calls 'id' on itself, printing the anonymous function value 

a = [];                             // ex nihilo creation of an empty object 
a = ["one", 2, function three{}];   // make an object with three elements indexed as [0] [1] [2]
print(a[0], a[1], a[2]);            // prints 'one', 2 and the value of the 'three' function 
three();                            // notice that 'three' is a visible function at this point
a.three();                          // runtime error, functions are not indexed by name
a.three = three;                    // should add explicitly a slot with a desriable index
a = [ @three : function {} ];       // this is the way to do it in object constructors
a = [ { "x", "y" : 10, 20 } ];      // make an object with slots 'x' : 10 and 'y' : 20 
a.x = a.y = "goodbye, world";       // write 'x' and 'y' slots with the same 'String' value 
print(typeof(a), typeof([]));       // prints 'Object' twice, as the type of all objects is 'Object' 
a = [
    method move (dx, dy) {          // methods are allowed only inside object expressions 
        self.x += dx;               // 'self' is a keyword referring to the method owner object  
        self.y += dy;               // slots are late bound, requested upon method invocation
    },
    { "$1" : method{} }             // alternative syntax if the method name is not an identifier
]; 
a.x = a.y = 30;                     // here we actually set the 'x' and 'y' slots of 'a'
a.move(-10, -10);                   // and we invoke a method by its name
a."move"(-10, -10);                 // this syntax is also possible
a."$1"();                           // it is usefull to access methods with non-identifier names
a["$1"]();                          // this is the traditional style and applies too
print(a.x == nil);                  // will print 'false'
a.x = nil;                          // will remove 'x' slot
print(a.x == nil);                  // now will print 'true'
print(a[nil]);                      // runtime error: nil is forbidden as a key

if (foo) 
    print("true"); 
else 
    print("false"); 
while (bar) {
    print("still true"); 
    if (foo) 
        break; 
    else 
        continue; 
} 
for (local i = 0; i < N; ++i) 
    (function{})();                     // invoke an anonymous function
foreach (x, [0, 1, 2, 3, 4])            // iteration order in objects is undefined
    print(x); 
foreach (f, [function{}, function{}])   // the object slots are two anonymous functions
    f();

a = [ 1, 3, 5 ];            // an object with slots <0:1, 1:3, 2:5> (first is auto key) 
print(a[0], a[1], a[2]);    // syntax to access slots of any key type is <obj>[<key>]
b = [ { #x, #y : 0 } ];     // an object <x:0, y:0> with #<id> being equivalent to "<id>"
b = [ @x : 0, @y : 0 ];     // alternative syntax with @<id> : expr same as { "<id>" : expr }
b.x = 20;                   // accessing slots of identifier keys (syntactic sugar to b["x"]) 
c = [ method f{} ];         // an object <f: method{}> 
c = [ @self ];              // '@self' (kwd) refers to the object under creation 
print(c == c[0]);           // will print 'true' 

a = [   @f : method {},         // new object on var 'a' with a method in slot 'f' 
        @g : method {}  ];      // and another method in slot 'g'
a.f();                          // invoking a method for an identifier key 
a."f"();                        // this is also valid and works for any string key
f();                            // compile error (not a callable), as methods invisible outside
b = [ method f{} ];             // this is syntactic sugar for method slots with id keys 
b.f();                          // syntactic sugar of field access applies as before 
c = [ { "$1" : method{} } ];    // methods may be stored to slots of non-id string keys
d = [ { -1 : method{} } ];      // methods may be stored to slots of any key
c["$1"]();                      // the generic syntax for slot access can be used 
c."$1"();                       // this form can be used too 
d[-1]();                        // for non-string keys the [] syntax is used
fm = a.f;                       // 'fm' is a method value, copying 'a.f' 
fm();                           // can be called directly not requiring an object 
fm = c."$1";                    // as before we get the method value
fm();                           // and we invoke it without the object
print(fm.self);                 // will print object 'c' ('self' key allowed only on methods)
print(fm.self == c);            // will print 'true'
print(fm.self.self);            // will print 'nil' (for objects 'self' is a user-defined slot)
fm.self.self = "foo";           // sets 'self' slot of 'fm' owner to 'foo'
print(fm.self.self);            // this will print 'foo'

a = [                       // 'a' is a new object 
    method add(d)           // it has a method named 'add'
        { self.val += d; }  // in methods we use 'self' to access slots
];  
a.val = 10;                 // we can introduce slots on objects dynamically
a.add(20);                  // here when 'a.add' is invoked 'self' is 'a' 

function foo                // a function with no parameters - may skip '()'
    { print("foo"); }           
function bar (f) 
    { f(); return f; }      // a function invoking and returning its argument 
bar(foo);                   // will print 'foo' 
function h(f, g, x)         // a function with function (callable) arguments 
    { return g(f(x)); } 
h(bar, bar, foo);           // will print 'foo' twice 
bar(bar(foo))();            // will print 'foo' three times
a = [ foo, bar ];           // make an object with two function slots 
a[1](a[1](a[0]))();         // this is equivalent to 'bar(bar(foo))()' 

(function foo { print("foo"); })();     // 'foo' defined and invoked directly here
print(
    function bar (f)                    // 'bar' defined and supplied as  an argument
        { f(); return f; }
); 
[ { 0 : function{} } ];                 // anonymous function as an explicitly indexed slot 
[ function g{} ];                       // named function as an automatically indexed slot 
foo(); bar(foo); g();                   // all named functions are visible at this point 

l = std::list_new(                          // make a list with a few initial elements 
        10,                                 // list elements may be of any type
        "hello", 
        "world",
        function(l)                         // an anonymous function element
            { print(l); }
    ); 
foreach(x, l) 
    (function(x) {                          // define an anonymous function
        if (typeof(x) == "ProgramFunc")     // test the type of a value dynamically
            x(l);                           // we invoke funcs passing 'l' as arg
    })();                                   // invoke the anonymous func per element
(function(f){ f(); })(                      // anonymous func invoked directly
    function{}                              // anonymous func supplied as argument
);
(f = (function{}))();                       // anonymous func assigned to 'f', then invoked

(function (cont, pred, action) {                // an anonymous function with three args
    foreach (local x, cont)                     // iterate to elements 'x' of container 'cont' 
        if (pred(x))                            // if the predicate 'pred' is satisfied on 'x' 
            action(x);                          // then invoke 'action' on 'x' 
})(                                             // we invoke directly the anonymous function 
    l,                                          // the previously defined list 'l' 
    lambda(x)                                   // a lambda function with a single arg
        { typeof(x)=="Number" and x%2==0 },     // the predicate is satisfied for even numbers 
    lambda(x)                                   // a lambda function with a single arg
        { print(x) }                            // it prints its arg
);                                              // it will print '10' 

fib =   (function(n) {  // as an anonymous function
            if (n == 0) 
                return 0; 
            else if (n == 1) 
                return 1; 
            else return @lambda(n-1) + @lambda(n-2); 
        });             // enclosing parantheses necessary

fib = lambda(n) // as a lambda function
        { ( n < 2 ? n : @lambda(n-1) + @lambda(n-2) ) }; 

function f {
    const N = 10;           // a constant local to 'f'
    function f(x,y) {
        function g { 
            local v = N;    // non-local constants are visible
            const N = 20;   // but can be redefined (shadowed)
            return f(x, y); // 'x' and 'y' visible, closure vars for 'g'
            return f(0,0);  // outer 'f' is visible
            local x;        // this is local 'x' declaration
        }
        local x;            // this will shadow the 'x' arg
        function 
            { x = 20; }     // 'x' visible, closure var for anonymous func
        function
            { ::f(); }      // global 'f' function visible
    }
}

y;                          // implicit declaration of global 'y'
{                           // a block at global space
    local x;                // 'x' is a local var (block scope)
    function {
        x = 20;             // 'x' visible, clsoure var for anonymous func
        y = 20;             // but can access directly global 'y'
    }
}

function bind1st(f, x)      // A simple binder using closures.
    { return lambda { f(x, ¦arguments¦) }; }

    
if          else        while       for     foreach     
break       continue    function    method  using       
try         trap        throw       static  local       
const       lambda      @lambda     @set    @get 
self        @self       @operator   return  assert      
onevent     arguments   nil         and     not         
or          true        false

a = [                                       // 'a' takes a reference to a new object 
    method foo                              // the new object has a 'foo' method
        { print(self.val); }                // the method prints the self 'val' slot
];
m1 = a.foo;                                 // 'm1' is a method value copying 'foo' value 
print(m1.self);                             // 'm1' self slot can be freely taken 
print(m1.self == a);                        // will print 'true'
m1.self.val = 23;                           // we can access all slots of the self object normally
m1();                                       // we invoke 'm1' directly, this will print '23' 
a = [ @val : "twenty three" ];              // we set 'a' as another new object 
m2 = m1;                                    // 'm2' is a copy of the 'm1' method value 
m1.self = a;                                // we mutate the owner of 'm1' method to be the new 'a'
m1();                                       // this will now print 'twenty three' 
m2();                                       // but this prints '23' as 'm2' has the previous onwer 
m2.self = m1.self;                          // however, we can change 'm2' owner to be that of 'm1'
m2();                                       // thus now 'm2' prints 'twenty three' as well 
a.bar = tabmethodonme(                      // this library function accepts an object ('a' here) 
            a,                              // and a method (slot [0] of new object here) and
            [ method(v) { @val = v; } ][0]  // returns a copy of the method value with owner
        );                                  // the supplied object (thus 'a')
a.bar(23);                                  // invokes the new method with self being 'a'
a.foo = tabmethodonme(a, m1);               // add 'm1' method in new 'a' object with 'foo' key
a.foo();                                    // will print '23' as 'val' slot changed by the method

method m {}                         // Orphan method definition - this 'm' is a variable.
m = [ method {}][0];                // Actually, the previous is syntactic sugar for this.
m = nil;                            // Orphan methods define vars when their name is seen first time.
function f {}                       // Function definition, this 'f' is immutable.
f = nil;                            // Thus this would cause a compile-time error.
method f {}                         // This is an error too, as we try to assign a method to immutable 'f'
m = (method {});                    // The parentheses are needed here to make method definitions be expressions.
method print_xy { print(@x, @y); }  // This method prints the 'x' and 'y' local slots / attributes.
print_xy();                         // The initial object has no 'x' or 'y' thus prints NilNil
print_xy.self.x = 10;               // Here we can even use the internal object of an orphan method.
print_xy.self.y = 20;               // And set its slots, as we do here.
print_xy();                         // This will now print 1020
print(print_xy.self[0]);            // Notice that an orphan method is stored in the [0] slot of its initial self.
print_xy.self = [ @x : 9, @y : 7 ]; // Here we change the 'self' object (owner) of 'print_xy' method
print_xy();                         // Hence, this call will now print '97'
print(print_xy.self[0]);            // This will print 'Nil' since the new self has no [0] slot.

function Point (x, y) {                 // an example of a 'Point' factory function
    return [                            // creates and returns new object everytime
        @class : #Point,                // user defined 'class' slot; #<id> same as "<id>" 
        { #x, #y : x, y },              // assignment to object slots from the arguments 
        method @operator+(l, r) {       // both arguments supplied to binary operator functions 
            assert r.class == #Point;   // a trivial form of user-defined type checking 
            return  Point(              // we return a new temp Point object
                        @x + r.x,       // @<id> is same as self.<id>  
                        @y + r.y
                    ); 
       }
    ];
} 

pt1 = Point(1,2);                       // make a sample 'Point' instance
pt2 = pt1 + Point(-1,-2);               // 'pt2' is the result of adding 'pt1' with a temp 'Point' 
print(pt1.+);                           // could also write pt1["+"]; prints the operator method 
pt2[+] = nil;                           // we remove the operator method (unoverloading) from 'pt2' 
pt3 = pt2 + pt1;                        // fails at runtime since 'pt2' does not overload '+' 
pt2.+ = Point(0,0).+;                   // we reoverload 'pt2' taking the operator from temp 'Point' 
pt2.+.self = pt2;                       // and then we set the operator method's owner to be 'pt2' 
pt3 = pt2 + pt1;                        // now the operator invocation will succeed 
tabdisableoverloading(pt2);             // we can disable overloading on 'pt2'
pt2 + pt1;                              // runtime error, overloading disabled for 'pt2'
pt1.+_ = pt1.+;                         // we allow 'pt1' overload '+' even when at RHS
pt2 + pt1;                              // here pt1.+_(pt2, pt1) is called, thus handled by 'pt1'
tabenableoverloading(pt2);              // we enable overloading on 'pt2'
pt2 + pt1;                              // now pt2.+(pt2, pt1) is called, thus handled by 'pt2'

function dot(obj, key)                  // a trivial user-defined dot calling the built-in version 
       { return tabget(obj, key); }     // 'dot' is not a reserved name, we could name it 'foo' 
function dot_assign(obj, key, val)      // a trivial user-defined dot-assign calling the built-in version 
       { tabset(obj, key, val); }       // 'dot_assign' is not a reserved name, we could name it 'bar' 
a = [];                                 // just making an empty object for our example 
a[.] = dot, a[.=] = dot_assign;         // we just overloaded the dot and dot-assign methods
print(a[.], a[.=]);                     // they are normal slots, so can be extracted and printed 
a.x = 10, a.y = 20;                     // these are now handled by the our 'dot' and 'dot_assign' functions
a[.=] = nil;                            // by removing either or both slots we return to the built-in version

function Proxy (a) { 
    return [ 
        @server : a,                                // we store the server in a slot 
        method @operator.(obj, key)                 // dot overloading syntax using operator methods
            { return tabget(obj, #server)[key]; },  // we use built-in dot to get 'server' object slot 
        method @operator.=(obj, key, val)           // here we similarly overload dot-assign 
            { tabget(obj, #server)[key] = val; }    // and again redirect dot-assign to the 'server'
       ]; 
} 
a = Proxy([]);                                      // make a proxy for an empty server object 
a.x = a.y = 20;                                     // these slots are set on the server object 
print(tabget(a, #server));                          // we may still get the server via the built-in dot
a = Proxy(a);                                       // and we can even make a proxy for a proxy object 

function const_func (c) {                   // produces functor f(x) = 'c' (i.e., constant function) 
    return [                                // make a new object everytime
        @val : c,                           // store the constant 'c' as a slot of the functor object
        method @operator()                  // a method overloading the function-call operator 
            { return @val; }                // returns the slot storing constant value 
       ]; 
} 

c_hw = const_func("hello, wolrd");          // make 'c_hw' equivalent to f(x) = 'hello, world' 
print(c_hw());                              // will print 'hello, world' 
c_23 = const_func(23);                      // make 'c_23' equivalent to f(x) = 23
print(c_23());                              // prints '23' 
c_const = const_func(const_func);           // make 'c_const' equivalent to f(x) = 'const_func' 
c_nil = c_const()(nil);                     // here 'c_const()' is equivalent to 'const_func' 
print(c_nil.());                            // prints the function-call slot of 'c_nil' 
c_23.() = nil;                              // removes the function-call slot of 'c_23' 
print(c_23());                              // fails at runtime since 'c_23' no more a callable 

function bind_1st(f,x) {                    // produces g(y) as f(x,y) 
    return [                                // we return a functor object actually 
        { #f, #x: f, x },                   // store locally 'f' and 'x' 
        method @operator()                  // binders are functors 
            { return @f(@x,...); }          // '...' passes all actual args of current func
       ]; 
} 
p_hw = bind_1st(print, "hello, world");     // a binder for the std::print
p_hw("n");                                  // will print 'hello, world' with a new line 

function bind_n (f...) {                    // '...' as a suffix of formals implies var args 
    arguments.pop_front();                  // skip the 'f' argument being the first one
    return [ 
        { #f, #args: f, arguments },        // we store the bound 'arguments' locally 
        method @operator() 
            { return @f(¦@args¦,...); }     // pass stored 'args' and all actual args 
       ]; 
} 
p_hw = bind_n(
            print, 
            "hello", ", world"              // here we bind two arguments with a signle call 
        );
p_hw();                                     // prints 'hello, world' 

a = [];                         // an empty object 
b = [ { #x, #y : 10, 20 } ];    // a simple object with two slots 'x' and 'y' 
inherit(a, b);                  // we just set 'b' as the base subobject of 'a' 
print(a.x);                     // this resolves to 'b.x' since 'b' base of 'x' 
a.x = nil;                      // here we erase 'x' from more recent owner (removes 'b.x')
print(b.x);                     // this will print 'nil' 
a.x = 10;                       // this 'x' slot is created locally at 'a' side 
b.x = -10;                      // but this also refers to 'a.x' (dot returns most recent version) 
print(a.x);                     // so this will print '-10' 
b..x = 10;                      // double dot accesses local slots thus we take 'x' at 'b' side 
print(a.x);                     // again 'a.x' is the most recent 'x' slot 
inherit(b, a);                  // runtime error, cycles are forbidden 
print(isderived(a, b));         // prints 'true' 
uninherit(a ,b);                // we break the inheritance link between 'a' and 'b' 
print(isderived(a, b));         // thus now it prints 'false' 

function New(id) 
       { return [ @id: id ]; } 
inherit(b1 = New(#b1), a2 = New(#a2)); 
inherit(b1, a1 = New(#a1)); 
inherit(b2 = New(#b2), a3 = New(#a3)); 
inherit(c = New(#c), b2); 
inherit(c, b1); 

//***************************************
// lib.dsc, playing the role of a package 
//***************************************
function foo                // a 'foo' global function, visible outside 
    { /* some code */ } 
function bar {              // a 'bar' global function, also visible outside 	
    /* some code */ 
    function f{}            // an 'f' inner function, not visible outside 
}

//***************************************
// client.dbc, playing the role of a client 
// Assume lib.dsc was compiled to lib.dbc 
//***************************************
lib_vm = vmload(            // 'vmload' is the library function to load byte code 
            "lib.dbc"       // we load 'lib.dbc' into a new vm instance 
            "lib"           // 'lib' is the supplied vm id (has to be unique) 
         ); 
vmrun(lib_vm);              // vmrun executes global code is mandatory before using a vm 
lib_vm.foo();               // invokes 'foo' implemented in 'lib.dsc' 
print(lib_vm.bar);          // all vm functions are normal functions (first-class values) 
lib_vm.f();                 // runtime error, since only global functions are visible 
lib_vm.bar.f();             // runtime error, something like this is is not supported
vm = vmget("lib");          // can get a vm instance by id from everywhere 
f = vm.foo;                 // we get 'foo' function value 
f();                        // this works fine, it invokes 'foo' of 'lib' vm 
vmunload(vm);               // with 'vmunload' we destroy a vm instance 
f();                        // runtime error, since its vm instance was destroyed 

libs::registercopied(#lib,  "lib.dbc");     // Register a copied lib (vm created on loading) from a file.
libs::registercopied(                       // Register a byte code buffer as a copied library.
    #dyn_foo,
    std::inputbuffer_new(                   // Turn it to an input buffer
        std::vmcompstringtooutputbuffer(    // Compile text code into a byte code buffer
            "function foo { throw \"foo\"; }", 
            (function(err){ print(err,"\n"); }),                
            false
        )
    )
);  
l1 = libs::import(#lib);                    // Loads and makes a new vm instances
l2 = libs::import(#dyn_foo);                // Loads only once and returns vm instance.
l3 = libs::import(#dyn_foo);
assert l2 == l3;                            // Because 'dyn_foo' is a shared library.
l4 = libs::import(#lib);                    
assert l4 != l1;                            // Because 'lib' is a copied library.
try d.foo(); trap e { print(e, "\n"); }

libs::unimport(l1);
libs::unimport(l2);
libs::unimport(l3);                         // Even when shared 'unimport' is needed (ref counted).
libs::unimport(l4);

// File 'server.dsc'
function foo {}
function bar {}
function local f {}     // Hidden outside
{ function g {} }       // Also hidden outside (non-global scope)

// File 'client.dsc'
using #server;
server::foo();          // Ok, imported function visible.
server::bar();          // Ok, imported function visible.
server::f();            // Error, function not found in 'server' function table.
vm = vmget(#server);    // We can even get the vm of the library.
vm.foo();               // Runtime lookup compared to server::foo which is at compile-time
server::foo = 10;       // Error, it is immutable.
vm.f = nil;             // Ok, just overwritten 'f' slot within vm's userdata.

function Point(x, y) { 
    return [
        @x {                            // an 'x' attribute definition
            @set method(v)              // defining the 'x' set method
                { @x = v; @xf(self); }  // which invokes self.xf callback too 
            @get method { return @x; }  // defining the 'x' get method
        }, 
        @y {                            // a 'y' attribute definition 
            @set method(v)              // defining the 'Y' set method
                { @y = v; @yf(self); }  // which invokes self.yf callback too 
            @get method { return @y; }  // defining the 'y' get method 
        },
 
        { #xf, #yf : function(pt){} },  // empty implementations of listener callbacks 
        { #x,  #y  : x, y },            // optional, but desirable, init values to 'x', 'y'

        method set_x_listener(f)        // method to set the 'x' property listener callback 
            { @xf = f; },
        method set_y_listener(f)        // method to set the 'y' property listener callback 
            { @yf = f; }
    ];
}
pt = Point(10,20); 
pt.x = 20;                              // internally invokes the set method 
pt.set_y_listener(                      // set a listere on 'y' 
    function(pt){ print(pt.y); }        // to actually print its value 
); 
pt.y = -10;                             // will set 'y' to '-10' and print '-10' 
tabredefineattribute(                   // we can redefine the set / get methods 
    pt, 
    #x, 
    function(v){},                      // setter comes first (here it is nop)
    function{ return 0; }               // getter follows (constantly returning 0).
); 

x = <<1+2>>;                        // x get a value          +
                                    // representing the     /   \ 
                                    // tree on the right   1     2
y = <<1, true, "str", [1, 2]>>;     // represents a list of items that can be used
                                    // as an argument list or as table elements
z = <<                              // represents the AST of the entire for loop
    for(i = 0; i < 5; ++i)
        std::print(i);
>>;
u = <<                              // represents the AST of the entire function
    function add(x,y)
        { return x + y; }
>>;
v = <<                              // represents a list of statements
    a = 1;
    try {
        while(a > 0) f(a--);
        assert a == 0;
    }
    trap ex { std::print(ex); }
>>;
w = << <<1+2>> >>;                  // a nested AST value (AST representing an AST)
q = <<$x = 1>>;                     // variable x will not bind to an existing x at the
                                    // insertion context, but is automatically renamed

x = <<1>>;
y = <<~x + 2>>;                     // y is <<1 + 2>>
z = <<~x + ~y * 3>>;                // z is <<1 + (1 + 2) * 3>>

function id(x) { return x; }
v = <<~(id(1)) + ~(id(2))>>;        // v is <<1 + 2>>

num = 1, str = "hello", bool = true;
w = <<~num, ~str, ~bool>>;          // escapses also support ground values, automatically
                                    // converting them to ASTs, so w is <<1, "hello", true>>

function pow(x, n) {                // will generate the AST of multiplying x with itself n times
  if (n == 0)
    return <<1>>;                   // termination: just multiply with 1 (in AST form)
  else
    return <<~x * ~(pow(x, n-1))>>; // recursion: multiply x with the result of the recursive invocation
}

pow3 = pow(<<x>>, 3);               // pow3 is <<x * x * x * 1>>

args = <<2, 3>>;
call1 = <<f(~args)>>;       // call1 is <<f(2, 3)>>
call2 = <<f(1, ~args, 4)>>; // call2 is <<f(1, 2, 3, 4)>>
call3 = << <<f(~args)>> >>; // escapes also apply for nested quotes, so call3 is << <<f(2,3)>> >>

t1 = <<[1, ~args, 4]>>;     // t2 is <<[1, 2, 3, 4]>>
empty_ast = nil;            // nil is used to denote an empty AST
t2 = <<[1, ~empty_ast, 4]>>;// escaping a nil value removes the entire node, so t2 is <<[1, 4]>>
call4 = <<f(~empty_ast)>>;  // similarly, call4 is <<f()>>

function func_generator(name, args, body)
    { return <<function ~name (~args) { ~body; }>>; }

f = func_generator(<<id>>, <<x>>, <<return x;>>);   // f is <<function id(x) { return x; }>>

a = <<$x>>;                     // the AST contains variable that will be automatically renamed
b = <<~a + ~a>>;                // such variables are preserved by escapes, so b is <<$x + $x>>

stmts = list_new(               // a list of statements as AST values.
    <<x = 1;>>,                 
    <<while(x > 1) f(--x);>>,
    <<assert x == 0;>>
);                              // to combine them into a single AST we can do the following:
code = nil;                     // initially we have no code, so code is nil
foreach(local stmt, stmts)      // iterate over all statements in the list
    code = <<~code; ~stmt;>>;   // append each statement at the end of the already existing code
                                // finally, code is <<
                                //			x = 1;
                                //			while(x > 1)
                                //				f(--x);
                                //			assert x == 0;
                                //		    >>

!(<<a = 1>>);                       // inserts the statement a = 1 directly into the program source
b = !(<<1+2>>);                     // equivalent to b = 1 + 2;
c = !(<<f()>>);                     // equivalent to c = f();
function one() { !(<<return 1;>>); }// equivalent to function one() { return 1; }

function id(x) { return x; }
!(id(<<d>>)) = !(id(<<1>>)) + !(id(<<2>>)); // equivalent to d = 1 + 2;

function func_generator(name, args, body)
    { return <<function ~name (~args) { ~body; }>>; }

!(func_generator(<<add>>, <<x, y>>, <<return x+y;>>));  // will generate the following function:
                                                        // function add(x, y) { return x + y; }
y = !(<<for(i = 0; i < 1; ++i);>>); // error, generating a statement but expecting expression

function pow(x, n) {
    if (n == 0)
        return <<1>>;
    else
        return <<~x * ~(pow(x, n - 1))>>;
}
print(!(pow(<<2>>, 3)));            // equivalent to print(2 * 2 * 2 * 1);
!(<< print(!(pow(<<2>>, 3))); >>);  // metagenerator for the above statement

function f(n) {
    if (n < 1)
        return nil;
    else
        return <<!(f(~(n - 1)))>>;  // returns an AST that when inlined will cause further staging
}
!(f(10));                           // generates !(f(9)) that will then generate !(f(8)) and so on
                                    // until the last step that eventually generates no code (nil)
                                    // it involves 10 evaluation rounds (i.e. stages) to complete
function f() { return <<!(f())>>; }
!(f());                             // repeatedly generates itself, causing endless staging

&function ExpandPower (n, x) {                      // function is available only during compilation
    if (n == 0)
        return <<1>>;
    else
        return <<~x * ~(ExpandPower(n - 1, x))>>;
}
&function MakePower (n) {                           // function is available only during compilation
    return << (
        function (x) { return ~(ExpandPower(n, <<x>>)); }
    )>>;
}
power3 = !(MakePower(3));       // generates: power3 = (function(x){ return x * x * x * 1; });
                                // all previous declarations never appear in the final program
&x = <<1>>, y = <<2>>, z = nil; // x, y, z are available during compilation (compile-time state)
&if (some_condition())          // the if statement is executed during compilation with all
    z = x;                      // compile-time state being available to it
 else                           // execute tags are also evaluated in order of appearance,
    z = y;                      // so they provide the notion of typical control-flow
print(!(z));                    // inlines are also evaluated in order and can access compile-time state
                                // the generated code depends on the result of the some_condition()
&print("hello");                // executed during compilation, prints 'hello' at compile-time
!(<<&print("hello");>>);        // metagenerator for the above statement