Function overloading

[MeAmAnUsername]

Allow overloading functions, i.e. have functions with the same names

code generation

1. no code generation, all functions with less parameters get desugared to calls with default parameters
2. generate to same task. May be possible by creating an abstract Input class that has subtypes for the possible input types. Could apply strategy pattern in subclasses to implement different behavior for each input type.

class someTask implements TaskDef<someTask.Input, Output> {
  <I extends Input<I>> private static interface Input<I> extends Serializable {
    // private so that other classes can't implement this and provide something else
    // can be made public?
    Output exec(ExecContext context, I input);
  }

  public static class Input1 extends TupleX implements someTask.Input<someTask.Input1> {
    public Input1(...args...) {
      ... assign fields ...
    }
    
    public Output exec(ExecContext context, Input1 input) { ... }
  }
  
  public exec(ExecContext context, Input input) {
    return input.exec(context, input);
  }
}

3. generate to different tasks. Each task takes only one input and has a distinct name.

Options

Easy: default parameters

last parameters can have defaults. Generate functions that pass the default values.
Code generation: 1, 2 or 3.

Medium: user-defined implementation, one function per arity

allow each overload to have its own implementation. Each function combined with its number of parameters must be unique.
Code generation: 2 or 3

Hard: user defined implementations, arbitrary overloads

Allow arbitrary overloads. They are basically completely separate functions except that they have the same name.
Requires some way to choose which function to use when they have the same arity. Use most specific signature? Follows Java semantics, but don't know if that works in NaBL2.
Code generation: 2 or 3