// use option without ? or an or block in places where it is not allowed

fn foo() ? {
    println('foo is called')
}

fn bar[T](v T) ?T {
    return none
}

const const_value = bar(0)

struct Data {
    f fn (int) = unsafe { nil }
mut:
    value int  = bar(0)
    opt   ?int = bar(0)
}

fn (mut v Data) add(n int) {
    v.value += n
}

fn twice(n int) int {
    return n * 2
}

fn main() {
    // call fn
    foo()
    _ := bar(0)
    println(twice(bar(0)))

    // anon fn
    fn (_ int) {}(bar(0))

    // assert
    assert bar(true)

    // struct
    mut v := Data{
        f:     fn (_ int) {}
        value: bar(0)
        opt:   bar(0)
    }
    v.add(bar(0)) // call method
    v.f(bar(0)) // call fn field

    // array
    mut arr := [1, 2]
    arr << bar(0)
    // init
    _ := [bar(0)]
    _ := []int{len: 1, init: bar(0)}
    _ := [bar(0)]!
    _ := [1]int{init: bar(0)}
    // index
    println(arr[bar(0)])
    // array builtin methods
    arr.insert(0, bar(0))
    arr.prepend(bar(0))
    arr.contains(bar(0))
    arr.index(bar(0))
    println(arr.map(bar(0)))
    println(arr.filter(bar(true)))
    println(arr.any(bar(true)))
    println(arr.all(bar(true)))

    match bar(0) {
        0 {}
        else {}
    }
}