Changing operator overloading to be more like Python

[waywardgeek]

I'm going to change operator overloading to be more like Python, now that I better understand why Python is the way it is.

The current operator overloading attempts to be more general than Python, but the current scheme causes problems. For example, currently, in Rune, I can write:

overload + (a, b) {
  throw "All addition overloading is banned!"
}

If Rune finds a built-in operator, it goes with that, but if it would otherwise be a compile-time error, it checks for overloaded operators, attempting to match each function until one matches. The function above always matches addition operators because it has no type constraints.

This turns out to be waaaaay to slow. Let's say we have an overloaded function like this:

operator == (a, b: typeof(a)) -> bool {
  typeswitch typeof(a) {
    case Class {
      return <u32>a == <u32>b
    }
  }
}

Binding this recursively first must bind the type constraints. The old binder binds them left to right, so typeof(a) is valid as a constraint for b. This binding isn't done just once. Instead, it is done every time an addition operator is matched against this function. This significantly slows down the old binder.

In the new binder, we only bind things once, including type constraint expressions. In general, the new binder first looks up a function by its name and signature, and if the signature is new for that function, it makes a copy of the function, and binds the copy to the signature of the parameters passed in. Type constraints are bound in the context of the signature, so the following will be legal with the new binder:

func compare(a: typeof(b), b: typeof(a)) -> bool {
  ...
}

This is fast because we first lookup the function being called, and verify we're calling it with a new signature, before doing an expensive function copy. For overloaded operators, using the old scheme, we would have to make a function copy and attempt to bind it for every overloaded operator function for the given operator. This is simply too slow.

The new scheme is like Python. Only one operator overload is allowed in any given scope. The function is uniquely identified by its name, so we can efficiently bind even though we make a copy of that function for each unique signature.

Like Python, we need right-hand-side operators, so I'm thinking of using keywords "operator" and "roperator".

[0dminnimda]

Only one operator overload is allowed in any given scope

Does it mean that the same calling a function with two differently typed arguments is not possible?
Something like

make_int(3)
make_int("4")

wouldn't be possible?

[waywardgeek]

Like Python, the function "makeInt" is a single function, not overloaded, but it can check the type of the parameters to achieve the correct behavior:

func makeInt(val: Int | Uint | string) -> Int | Uint {
  typeswitch val {
    case Int | Uint {
      return val
    }
    case string {
      return atoi(val)
    }
  }
}

func atoi(val: string) -> u64 {
  res = 0
  for c in val {
    if c < '0' || c > '9' {
      throw "Invalid digit passed to atoi"
    }
    res = res * 10 + <res>(c - '0')
  }
  return res
}

println makeInt(3)
println makeInt("4")

[0dminnimda]

OK, now it makes more sence.