Does standard prohibit inclusion of additional keyword-only arguments?

[mdhaber]

The "Conformance" section states:

A conforming implementation of the array API standard must provide and support all the functions, arguments, data types, syntax, and semantics described in this specification.

A conforming implementation of the array API standard may provide additional values, objects, properties, data types, and functions beyond those described in this specification.

This seems to leave a bit of gray area. For instance, can implementations of functions defined in the standard accept additional arguments not defined by the standard (as long as the default behavior complies with the standard)?

Let's take numpy.asarray as an example implementation of asarray.

I know that the fact that the positional arguments are not positional-only is non-conformant: "When a function signature includes a /, positional parameters must be positional-only parameters." Likewise, dtype should be keyword only. That aside....

Is NumPy's inclusion of an additional positional argument order considered non-conformant? How about the keyword-only argument like?

[rgommers]

Extra optional positional arguments and keywords can always be added by an implementation, that is perfectly fine and every existing implementation except for array-api-strict does that. If the text needs to be clearer, let's amend it. I think you want to add "and function arguments" to the quoted list above?

Is NumPy's inclusion of an additional positional argument order considered non-conformant? How about the keyword-only argument like?

So those are both fine.

[mdhaber]

I think you want to add "and function arguments" to the quoted list above?

Yup! I will submit a PR to add exactly that.

This came up in mdhaber/marray#6 (comment).

[mdhaber]

Would this be ok to make it explicit that the list is not comprehensive?

A conforming implementation of the array API standard may provide additional
features (e.g. values, objects, properties, data types, functions, and function
arguments) beyond those described in this specification.

Or is that too flexible?

[rgommers]

That sounds perfectly fine to me.

[asmeurer]

Code written against the strictest implementations of the standard should work. That means that additional optional keyword arguments are fine, because even though most code won't reference them, they will have default values. But additional required positional or keyword arguments are not OK, because those will require the code to be updated. So for example, if the standard defines

def f(x, /, y=1):
    ...

an implementation could define

def f(x, /, y=1, z=2):
    ...

but it would not be OK for an implementation to define

def f(x, z, /, y=1):
    ...

or

def f(x, /, *, z, y=1):
    ...

because code written against the standard like f(x) or f(x, y=2) would give errors for those implementations.