struct V2
    x : float = -1.0f
    y : float

struct V3: V2
    z = 3.0f

[export]
def main
    let a : V3
    print("a = {a}\n")

    let b = V3()
    print("b = {b}\n")

    let c = [[V3 y = 2.0f]]
    print("c = {c}\n")

    let d = [[V3() y = 2.0f]]
    print("d = {d}\n")

    let e = [[V3() y = 2.0f, x = 1.0f]]
    print("e = {e}\n")

    //
    let pd = new [[V3() y = 2.0f]]
    print("pd = {pd}\n")

//Output:
a = [[ 0.000000000; 0.000000000; 0.000000000]]
b = [[ -1.000000000; 0.000000000; 3.000000000]]
c = [[ 0.000000000; 2.000000000; 0.000000000]]
d = [[ -1.000000000; 2.000000000; 3.000000000]]
e = [[ 1.000000000; 2.000000000; 3.000000000]]
pd = [[ -1.000000000; 2.000000000; 3.000000000]]

//where clause: post init function
let f = [[V3 where $(var self) {
    self.x = 11.0f;
    self.y = 11.0f;
    self.z = 11.0f;
}]]

//array initialization, g_arr: V3[2]
let g_arr = [[V3 
    x=1.0f, y=1.0f, z=1.0f;
    x=2.0f, y=2.0f, z=2.0f
]]

//array comprehesion, h_arr : iterator<V3>
let h_iter <- [[ for i in range(0, 10); [[V3 x=float(i), y=float(i), z=float(i)]]; where (i&1)==1 ]]
let g_iter <- [[ for i in range(0, 10); invoke({ let fi = float(i); return [[V3 x=fi, y=fi, z=fi]]; }); where (i&1)==1 ]] // same

var d = [[V3() y = 2.0f]]
print("d = {d}\n")
delete d
print("d = {d}\n")

var pd = new [[V3() y = 2.0f]]
print("pd = {pd}\n")
unsafe { delete pd; }
print("pd = {pd}\n")

//Output
d = [[ -1.000000000; 2.000000000; 3.000000000]]
d = [[ 0.000000000; 0.000000000; 0.000000000]]
pd = [[ -1.000000000; 2.000000000; 3.000000000]]
pd = null

options persistent_heap = true

var pd = new [[V3() y = 2.0f]]
var pd2 = pd
unsafe
    print("addr(pd) = {reinterpret<uint>(pd)}\n")
    print("addr(pd2) = {reinterpret<uint>(pd2)}\n")
    delete pd
pd2.x = 33.0f
print("pd2 = {pd2}\n")

//Output
addr(pd) = 0xf1909e10
addr(pd2) = 0xf1909e10
pd2 = [[ 33.000000000; -431602080.000000000; -431602080.000000000]] //мусор

var pd = new [[V3() y = 2.0f]]
var pd2 = pd
unsafe { delete pd; }
var pd3 = new [[V3() x = 33.0f, y = 33.0f, z = 33.0f]]
pd2.x = -100.0f // <----- kaboom!
print("pd2 = {pd2}\n")
print("pd3 = {pd3}\n")

//Output
pd2 = [[ -100.000000000; 33.000000000; 33.000000000]]
pd3 = [[ -100.000000000; 33.000000000; 33.000000000]]

def finalize(var v : V2)
    print("kill V2 {v}\n")

var d = [[ V3 x = 11.0f, y = 22.0f, z = 33.0f]]
delete d
print("d = {d}\n")

//Output
kill V2 [[ 11.000000000; 22.000000000]]
d = [[ 11.000000000; 22.000000000; 33.000000000]]

def finalize(var v : V2 explicit)
    print("kill V2 {v}\n")

def finalize(var v : V3 explicit)
    finalize(cast<V2> v)
    print("kill V3 {v}\n")

[export]
def main
    var d = [[ V3 x = 11.0f, y = 22.0f, z = 33.0f]]
    delete d
    print("d = {d}\n")
//Output
kill V2 [[ 11.000000000; 22.000000000]]
kill V3 [[ 11.000000000; 22.000000000; 33.000000000]]
d = [[ 11.000000000; 22.000000000; 33.000000000]]

struct V2
    x : float
    y : float
    set = @@set

var a = V2()
a |> set(1.0f, 2.0f) //call function via pipe syntax
invoke(a.set, a, 1.0f, 2.0f)  // exactly same thing as above
a->set(1.0f, 2.0f)  // this one can call something else, if overridden in derived class.

struct V2
    x : float
    y : float
    set = @@set
struct V3: V2
    z : float
    override set = cast<auto> @@set_v3
    
def set(var thisV: V2; X, Y: float)
    with thisV
        x = X
        y = Y

def set_v3(var thisV: V3; X, Y: float)
    set(cast<V2> thisV, X, Y)
    with thisV
        z = 3.0f

[export]
def main
    var a = V3()
    a |> set_v3(1.0f, 2.0f) //non virtual call
    invoke(a.set, a, 1.0f, 2.0f)  // exactly same thing as above
    a->set(1.0f, 2.0f)  // this one can call something else, if overridden in derived class.

struct V2
    x : float
    y : float
    set = @@<(var thisV: V2; X, Y: float):void> set
struct V3: V2
    z : float
    override set = cast<auto> @@<(var thisV: V3; X, Y: float):void> set //<------ cast
    
def set(var thisV: V2 explicit; X, Y: float)
    with thisV
        x = X
        y = Y

def set(var thisV: V3; X, Y: float)
    set(cast<V2> thisV, X, Y)
    with thisV
        z = 3.0f

[export]
def main
    var a = V3()
    a |> set(1.0f, 2.0f) //virtual call
    invoke(a.set, a, 1.0f, 2.0f)  // exactly same thing as above
    a->set(1.0f, 2.0f)
    print("{a}\n")

a = [[
    0x29990d19b90; //указатель на rtti информацию
    V3'__finalize/*V3'__finalize S<::V3>*/;  //указатель на функцию-финализатор
    1.000000000; //x
    2.000000000; //y
    V3`set/*V3`set S<::V3> Cf Cf*/; //указатель на виртуальную функцию set
    3.000000000 //z
]]

    unsafe
        print(
"\nsizeof(a) = {typeinfo(sizeof type<V3>)}\n
offset __rtti      = {typeinfo(offsetof<__rtti> type<V3>)} {reinterpret<uint>  addr(a.__rtti)} 
offset __finalize  = {typeinfo(offsetof<__finalize > type<V3>)} {reinterpret<uint>  addr(a.__finalize )} 
offset x           = {typeinfo(offsetof<x> type<V3>)} {reinterpret<uint>  addr(a.x)}
offset y           = {typeinfo(offsetof<y> type<V3>)} {reinterpret<uint> addr(a.y)}
offset set         = {typeinfo(offsetof<set> type<V3>)} {reinterpret<uint> addr(a.set)}
offset z           = {typeinfo(offsetof<z> type<V3>)} {reinterpret<uint> addr(a.z)}\n"
        )
Output:
sizeof(a) = 40
offset __rtti      = 0  0x4adb5f80
offset __finalize  = 8  0x4adb5f88
offset x           = 16 0x4adb5f90
offset y           = 20 0x4adb5f94
offset set1        = 24 0x4adb5f98
offset z           = 32 0x4adb5fa0

class V2
    x : float
    y : float
    def set(X, Y: float)
        x = X
        y = Y

[export]
def main
    let fn <- @@ <| ( a : int )
        return a 

    unsafe
        //inplace init syntax
        var v_customset = [[ V2() 
            set <- @@ (var self : V2; X,Y : float) {
                self.x = X * 100.0f;
                self.y = Y * 100.0f;
            }
        ]]
        v_customset->set(1.0f, 2.0f)
        print("{v_customset.x}, {v_customset.y}\n")
        //Output: 100.000000000, 200.000000000

        //reset after construction, pipe + block syntax
        v_customset.set = @@ <| (var self : V2; X,Y : float)
            self.x = X * 200.0f
            self.y = Y * 200.0f
        print("{v_customset.x}, {v_customset.y}\n")
        //Output: 200.000000000, 400.000000000

require rtti
...
var a = new V3()
print("class_info(a): {class_info(a)}\n") 
describeStructure(*class_info(a))
//Output:
//https://dascript.org/doc/stdlib/rtti.html?highlight=rtti#StructInfo
class_info(a): [[ 0x6; V3; ; (_class|heapGC); 0x28; 0x93b8d07b5cc8cee; 0xcf51414d2d20b41e]]
struct V3
    __rtti : void?
    __finalize : function<(V2):void>
    x : float
    y : float
    set1 : function<(V2;float const;float const):void>
    z : float

options rtti=true
...
class V3: V2
    [[test]] z : float
...
def describeStructure(sinfo)
    var anyAnn = false
    structure_for_each_annotation(sinfo) <| $(ann; annArgs)
        let argT = join([{for arg in annArgs; "{arg.name}{describeValue(get_annotation_argument_value(arg))}"}],",")
        print("[{ann.name}({argT})]\n")
    print("struct {sinfo.name}\n")
    for sfield in sinfo
        if sfield.annotation_arguments != null
            for arg in deref(sfield.annotation_arguments)
                print("\t[[{arg.name}]] ")
        describeVariable(sfield,"\t")
...
var a = new V3()
print("class_info(a): {class_info(a)}\n")
describeStructure(*class_info(a))

//Output:
struct V3
    __rtti : void?
    __finalize : function<(V2):void>
    x : float
    y : float
    set1 : function<(V2;float const;float const):void>
    [[test]] z : float //<-- аннотация test

class Test
    def abstract setX(X: int): void //необходимо явно определить сигнатуру метода -- тип аргументов и результата
    def sealed setY(Y: int)         //метод нельзя переопределить в потомках
        pass

//module1.das
module module1

class private V1
    w : float

class private V2
    x : float
    y : float

class public V3: V2
    v1 : V1
    z : float = 3.0
...
//main.das
require module1
//можно звать инициализацию полей, и пост-инициализацию для V3 (также открываются поля V2), но нельзя инициализировать явно поле приватного класса V1
var a = new [[V3() x=1.0f, y=2.0f, z=3.0f]]

class MyClass
    private a : int
    def private set_a(val:int)
        a = val
    def get_a
        return a
    def MyClass()
        self->set_a(42)
[export]
def main
    var f = new MyClass()
    print("f.a = {f->get_a()}\n")

class Test
    i : float
    def Test(I : float)
        i = I

def main
    var a <- new Test(33.0f)         //initializer called
    var b <- new Test()              //initializer don't called
    var c <- new [[Test() i = 2.0f]] //initializer don't called

[interface]
class ITick
    def abstract tick (dt:float) : void

[interface]
class ILogger
    def abstract log (message : string) : void

[implements(ITick), implements(ILogger)]
class Foo
    ...