This looks good to me.

Actually scratch that, I just noticed a potential problem. NumPy's dtype argument to sum is documented as follows:

dtype : dtype, optional
   The type of the returned array and of the accumulator in which the
   elements are summed.  The dtype of `a` is used by default unless `a`
   has an integer dtype of less precision than the default platform
   integer.  In that case, if `a` is signed then the platform integer
   is used while if `a` is unsigned then an unsigned integer of the
   same precision as the platform integer is used.

As written here now, a uint64 array would cast to int64 by default, which would be a downcast (uint64 can represent values that don't fit in the signed int64).

OK, I think that wording makes it clearer. This does look good now.

@asmeurer I've updated the text to clarify promotion guidance.

This has been reviewed. If any further changes are necessary, we can add them in a follow-up PR.

As the quoted docs say, numpy only applies this to integers (and bool). It does not upcast floats, in particular float32. Is that part intentional, or just a typo?

@seberg Upcasting floats is intentional, as, in principle (and while not currently required by the spec), also applies to float16 (bfloat16) in accelerator libraries, where overflow/precision concerns are still valid, albeit less of common concern than, e.g., int8.

@kgryte ah OK. I have not thought much about what I would consider ideal, it is/was just a bit surprising.

@seberg Were we to make a distinction between integral and floating dtypes for how promotion is handled relative to the default dtypes, this would add complexity to user mental models in terms of when promotion occurs.

And further, the same concerns motivating promotion to the default dtype for smaller integral dtypes applies to floating dtypes. Namely, that accumulation can lead to overflow and erroneous results. For example, for float32, the maximum safe integer is less than 2e7, leading to potential user footguns when summing and/or multiplying many large positive numbers. If the default floating dtype for a specification-compliant array library is float64 and dtype is None, the library should promote to float64 to avoid overflow and/or precision errors.

When an array library's default floating dtype is float64, if a user wants to return a float32 array when providing a float32 array, they can explicitly specify via the dtype kwarg that they wish to receive an output array of the same dtype. (This same logic applies to a user who provides an int8 array and wants an int8 array in return). Whether an array library chooses to accumulate internally in float32 is, however, an implementation detail.