// Step 2.5 — contextual typing for closure literals with N (heterogeneous)
// params. An untyped lambda `(a, b, c) => ...` takes each param's type
// positionally from the expected `Closure(T0, T1, T2) -> R` signature, in both
// assignment and argument position. (Previously only the first param — or
// all-same-typed params — resolved; trailing params silently defaulted to s64.)

#import "modules/std.sx";

// argument-position: lambda typed from the parameter's closure type.
apply2 :: (f: Closure(s64, string) -> s64, x: s64, s: string) -> s64 {
    return f(x, s);
}
apply3 :: (f: Closure(s64, s64, string) -> s64, a: s64, b: s64, c: string) -> s64 {
    return f(a, b, c);
}

main :: () -> s32 {
    // assignment-position, mixed (s64, string) params — `b` is string.
    cb : Closure(s64, string) -> s64 = (a, b) => a + b.len;
    print("cb={}\n", cb(10, "hello"));     // 10 + 5 = 15

    // argument-position, 2 params.
    print("r={}\n", apply2((a, b) => a + b.len, 10, "hello"));   // 15

    // argument-position, 3 params (s64, s64, string).
    print("q={}\n", apply3((a, b, c) => a + b + c.len, 1, 2, "xyz"));  // 1+2+3 = 6
    0;
}