Question about "polymorphic type from parameter" determination and unions of procedures

[rmc-coma]

Hi,

I've recently discovered Odin and wanted to try out how good the genericity was, but I noticed a few things.

First, optional parameters for procedures aren't a thing, and I don't know if they ever will be since golang seems to have been a significant source of inspiration and it does not allow these, please correct me if you have information about that but despite looking through the documentation and searching for an answer I have not found anything suggesting any particular stance of the creator(s) towards any response to that question

Second, the documentation, unless I'm mistaken, does not mention unions of procedures, but the checker during my tests hasn't prevented me from declaring some so I figured I might as well try to do something with them, particularly circumvent the aforementioned lack of optional parameters

So I went and tried to do a basic generic forEach procedure taking a generic slice as a first argument, and a generic second argument that specializes into a union of a procedure that either takes two arguments, one for value one for index, or just one for value, as so to allow to iterate on a slice and run callbacks, with prototypes varying depending on the needs, on each values.
However, the checker didn't like it, here is the code :

package slicesutils

import "core:fmt"

forEach :: proc(slice: []$T, callbackfn: $U/union{proc(T), proc(T, int)}) {
	for i in 0 ..< len(slice) {
		callbackfn.?(slice[i], i)
	}
}

main :: proc() {
	forEach([]string{"a", "b", "c"}, proc(v: string) {fmt.print(v)})
}

And the error is on the callback passed to the forEach in the main and is "Cannot determine polymorphic type from parameter: 'proc(string)' to '$U/union {proc(string), proc(string, int)}'(checker)".

I then started to wonder if this was unallowed by design or if could be a missing "feature" in the current state of the language, so I also rewrote the same function using explicit overloading to figure out the answer :

package slicesutils

import "core:fmt"


forEach1 :: proc(slice: []$T, callbackfn: proc(T)) {
	for i in 0 ..< len(slice) {
		callbackfn(slice[i])
	}
}

forEach2 :: proc(slice: []$T, callbackfn: proc(T, int)) {
	for i in 0 ..< len(slice) {
		callbackfn(slice[i], i)
	}
}

forEach :: proc{forEach1, forEach2}

main :: proc() {
	forEach([]string{"0", "1", "2"}, proc(v: string) {fmt.println(v)})
}

And it turns out that it works, the program outputting "1\n2\n3\n" just as intended.

So to conclude I suppose that this kind of pattern that allows to have polymorphic callback parameters is not "forbidden" by design, and I am therefore wondering if I am completely mistaken about the syntax of my first implementation, or if I may have found some kind of bug

I have already done extensive research and couldn't find anything regarding this kind of issue, and would be very grateful if anyone could provide an answer

Thank you for your time

[Beefster09]

First, optional parameters for procedures aren't a thing

I'm not sure where you're getting this idea, because Odin not only supports them, but they're even required in some cases (e.g. after a vararg)

I guess you mean that Odin doesn't like polymorphic parameters with defaults?

[rmc-coma]

You can indeed have parameters with a default value, but there isn't a type, to my knowledge, for "parameters with default value"

That means that if you're writing a higher-order function that takes a function as an argument, you can't type the parameter function so that it has "optional"/default arguments, maybe you could try stuff with variadic parameters, but that would only apply if all the arguments you expect are of the same type, all optional, order does not matter and so on, which is not what I am trying to achieve here