Function overloading in Dart

Question

The following code:

class Tools {
  static int roll(int min, int max) {
    // IMPLEMENTATION
  }

  static int roll(List pair) {
    // IMPLEMENTATIO         


        

Answer 1

What your code demonstrates is function overloading and not related to polymorphism.

Function overloading is not supported in Dart at all.

You can either use different names for the methods or optional named or unnamed parameters

// optional unnamed
void foo(int a, [String b]);
...
foo(5);
foo(5, 'bar');

// optional named
void foo(int a, {String b});
...
foo(5);
foo(5, b :'bar');

Optional parameters can also have default values. Optional named and unnamed parameters can not be used toghether (only one or the other for a single function)

Polymorphism and static methods:

Static methods can only be accessed without the class name as prefix from inside the class where they are defined. When called from subclasses, the name of the superclass needs to be used as prefix.

Answer 2

All right, this is quite old. But this is an approach that could help someone in the future. Relies a lot in generics, so in order to perceive the beauty you should be very familiar with that concept.

This is a very useless and absurd example:

// these are the overloads
class RollArguments { }
class FromMinAndMax extends RollArguments {
  int min;
  int max;
}
class FromList extends RollArguments {
  List<int> pair;
}

// this is the function
int roll<T extends RollArguments> (T r) {
  var min = 0;
  var max = 0;

  if (r is FromMinAndMax) {
    min = r.min;
    max = r.max;
  }
  else if (r is FromList) {
    min = r.pair[0];
    max = r.pair[1];
  }

  print("min = $min; max = $max");

  return 1;
}

usage of the function would be something like this:

roll(FromMinAndMax()
  ..min = 0
  ..max = 100
);

roll(FromList()
  ..pair = [0, 200]
);

The major downside of this approach is that you can not control whether the parameters are optional or not.

Maybe you could think that the overload name of the functions are in the derived types, and it is too verbose. But you could reuse a bit of code if you implement it correctly and improve readability in some cases too.

Anyway, this is just another way to achieve function overloading, there are many more ways for different cases.