struct Foo {}

fn (f Foo) foo() string {
    return 'foo'
}

fn (f Foo) bar() string {
    return 'bar'
}

struct NamedFoo {
    name string
}

fn (f NamedFoo) foo() string {
    return 'foo ${f.name}'
}

fn (f NamedFoo) bar() string {
    return 'bar ${f.name}'
}

fn test_main() {
    f := Foo{}
    mut results := []string{}
    $for method in Foo.methods {
        x := fn [method, f] () string {
            return f.$method()
        }
        results << x()
    }
    assert results[0] == 'foo'
    assert results[1] == 'bar'
}

fn test_comptime_method_value() {
    f := NamedFoo{'rabbit'}
    mut results := []string{}
    $for method in NamedFoo.methods {
        x := f.$(method)
        results << x()
    }
    assert results[0] == 'foo rabbit'
    assert results[1] == 'bar rabbit'
}

@[heap]
struct MethodMapApp {
    prefix string
}

fn (app &MethodMapApp) alpha() string {
    return '${app.prefix}:alpha'
}

fn (app &MethodMapApp) beta() string {
    return '${app.prefix}:beta'
}

fn build_method_map[T](app &T) map[string]fn () string {
    mut syms := map[string]fn () string{}
    $for method in T.methods {
        syms[method.name] = app.$(method.name)
    }
    return syms
}

fn test_comptime_method_value_map() {
    app := MethodMapApp{'ctx'}
    syms := build_method_map(app)
    assert syms['alpha']() == 'ctx:alpha'
    assert syms['beta']() == 'ctx:beta'
}