struct TEST {
    a int
    b i64
}

fn static_arrays() (int, int, i64) {
    a := [8]int{}
    b := [10, 12, 150]!
    c := [TEST{}, TEST{
        b: 10
    }]!

    return a[2], b[1], c[1].b
}

fn index_expression() {
    b := [10, 12, 150]!

    a := b[2]
    c := 'hello'[4]
    d := unsafe { c'hello'[2] }

    println(a)
    println(c)
    println(d)
}

fn test_this(index int) int {
    a := 'hello'
    if index < a.len && index >= 0 {
        return a[index]
    }
    return 10
}

struct AA {
    a [10]&int
}

struct IndexedWrite {
mut:
    idx   u8
    frame [4]u8
}

fn test_stuff() &int {
    a := AA{}

    mut b := &int(unsafe { nil })
    b = a.a[2]

    return b
}

fn selector_index_assign() {
    mut app := IndexedWrite{}
    app.idx = 1
    app.frame[app.idx] = 123

    println(app.frame[0])
    println(app.frame[1])
    println(app.frame[app.idx])
}

fn main() {
    println('--- static_arrays()')
    a, b, c := static_arrays()
    println(a)
    println(b)
    println(c)

    println('--- index_expression()')
    index_expression()

    println('--- test_this()')
    println(test_this(2))
    println(test_this(10))
    println(test_this(-1))

    println('--- test_stuff()')
    v := test_stuff()
    println(v)

    println('--- selector_index_assign()')
    selector_index_assign()
}