Functions as a first class citizens

[igor-elovikov]

Consider a simple example of higher order function:

import playground;

struct Add : IFunc<float, float, float> {
    float operator()(float arg0, float arg1) {
        return arg0 + arg1;
    }
}

float add_free_function(float arg0, float arg1) {
    return arg0 + arg1;
}

struct BindFront<F: IFunc<float, float, float>> : IFunc<float, float> {
    F fun;
    float value;

    float operator()(float arg) {
        return fun(arg, value);
    }
}

IFunc<float, float> bind_front<F: IFunc<float, float, float>>(F f, float value) {
    return BindFront<F>(f, value);
}

void printMain()
{
    let add = Add();
    printf("result: %g\n", add(1.0, 5.0)); // 6.0

    let add_five = bind_front(add, 5.0);
    printf("result: %g\n", add_five(1.0)); // 6.0


    // Below couldn't compile
    //let add_five_free = bind_front(add_free_function, 5.0); 
}

Playground Link

I think it would be better if a free function could conform to the IFunc interface, even if it requires introducing an anonymous type during specialization. Currently, add_free_function is of type (float, float) -> float according to the compilation error, but this type is not directly usable.

[jkwak-work]

IFunc is relatively new to Slang and you are discovering the limitations of the latest features.

For this specific case, the proposal document for IFunc already discussed as following,

Eventually, we should allow ordinary functions to be automatically coerceable to IFunc interfaces. But this is scoped out for the initial IFunc work, because we believe the implementation can be simpler if we support lambda function first, then implement ordinary function coercion as a special case of lambda expressions.

I guess we will have lambda and the ordinary function coercion later.