pub struct Vec[T] {
mut:
    data &T    @[required]
    cap  usize @[required]
    len  usize @[required]
}

pub fn new[T]() Vec[T] {
    return Vec[T]{
        data: unsafe { nil }
        cap:  0
        len:  0
    }
}

pub fn (ar &Vec[T]) iter() Iter[T] {
    return Iter[T]{
        v: unsafe { ar }
    }
}

pub struct Iter[T] {
mut:
    v   &Vec[T] @[required]
    pos usize
}

pub fn (mut iter Iter[T]) next() ?&T {
    if iter.pos >= iter.v.len {
        return none
    }
    defer {
        iter.pos++
    }
    return unsafe { &iter.v.data[iter.pos] }
}

fn test_generics_for_in_iterate() {
    mut goods := new[int]()
    goods.call_generic_fn(fn (a &int) bool {
        return *a > 1
    })
    assert true
}

fn (arr Vec[T]) call_generic_fn(cb fn (&T) bool) {
    for val in arr.iter() {
        println(cb(val))
    }
}