Unexpected sensitivity to order of method definitions

General Usage
12

It can be intimidating, but being aware of the limitations of mixing keywords and multimethod features helps a lot. One more thing I can mention is stick to the best practice of keeping keywords consistent across methods; ambiguities happen for the ones with the same number of positional arguments and related types, see the example below.

julia> bar(::Float64) = 0
bar (generic function with 1 method)

julia> bar(::Int; a) = 1        # if ::String, error below would not happen
bar (generic function with 2 methods)

julia> bar(::Number; a, b) = 2  # Int<:Number causes error below
bar (generic function with 3 methods)

julia> bar(1.0; a=0, b=0) # cannot use `bar(::Float64)`
2

julia> bar(1; a=0, b=0)
ERROR: MethodError: no method matching bar(::Int64; a=0, b=0)
Closest candidates are:
  bar(::Int64; a) at REPL[2]:1 got unsupported keyword argument "b"
  bar(::Number; a, b) at REPL[3]:1
  bar(::Float64) at REPL[1]:1 got unsupported keyword arguments "a", "b"

Not sure if you also meant that you hope that keyword arguments can eventually distinguish methods by arity, type, and keyword, like how positional ones do by arity, type, and order, but just in case, that really is infeasible. At first it seems possible that keywords can be sorted by name, then it reduces to typical order-based dispatch. However, more methods that vary by keywords makes the above dispatch headaches even worse, and default values would cause combinatorial explosion. Right now, default values in positional arguments make multiple methods that scale linearly N+1 e.g. f(a=1, b=2) makes f(), f(a), f(a, b). If you apply this to keyword arguments that can be reordered, that becomes sum(factorial(N)/factorial(N-i) for i in 0:N) e.g. f(;a=1, b=2) makes f(), f(;a), f(;b), f(;a, b), f(;b, a). The only way to avoid that combinatorial explosion is to force 1 method to handle all those possibilities and disallow other methods from handling any subset of them; silver lining is that the compiler can still specialize that 1 method on the various combinations of keywords you provide calls. It’s not a coincidence that languages with more flexible keyword arguments also lack multimethods or overloaded functions.

2 Likes