// Reification of an operator in a type-safe language
// -has a name
// -has 0 or more arguments
//   -each argument has a type and can have a name (otherwise it gets some default name like "argument 1")
// -has an optional return type (or return type null for no return value)
//   -to return multiple values, use a struct type

// T is the meta-type for argument and return types
persistable sclass GOperator<T> extends GAbstractOperator<T> {
  gettable L<Argument> arguments;
  gettable T returnType;
  
  record noeq Argument(int index, S name, T type) {
    T type() { ret type; }
    
    S shortToString() {
      ret type + " " + name;
    }
  }
  
  *(S *name) {}
  
  // add argument
  selfType arg(T type, S name default makeDefaultArgumentName()) {
    arguments = createOrAdd(arguments, new Argument(l(arguments), name, type));
    this;
  }
  
  selfType returns(T type) {
    returnType = type;
    this;
  }
  
  S makeDefaultArgumentName() {
    ret "arg" + (l(arguments)+1);
  }
  
  public S toString aka toStringWithArgumentNames() {
    ret name + ": " + joinWithCommaOr("()", lmapMethod shortToString(arguments))
      + " -> " + or(returnType, "void");
  }
  
  S toStringWithoutArgumentNames() {
    ret name + ": " + joinWithComma(map(arguments, a -> a.type))
      + " -> " + or(returnType, "void");
  }
}