I was surprised that there's no initializer for this, the caller would know the input and output types and therefore should understand the possible loss of precision (and that possibility would be documented). Is there a reason this kind of initializer is not in the Standard Library?

func foo<T: BinaryFloatingPoint>(n: some Numeric) -> T {
T(n)
}

Numeric doesnāt really offer much to go off of; thereās no way to retrieve the value for a custom implementation of the protocol. This isnāt unique to floating-point types: Even Int has separate initializers for BinaryInteger and BinaryFloatingPoint.

It would be very difficult to write such an initializer without further constraints. Numeric is a very general protocol--it models pretty much any ring with an identity and a notion of magnitude. Such a structure is guaranteed to hold something that looks like a subset of the integers, but can contain pretty arbitrary other "stuff" to, and figuring out how to convert that to a binary floating point type is non-obvious. What floating-point number should result from the matrix ((0, 1), (-1, 0))? From the Hurwitz quaternion 0 + 3i - 2j + k?

Beyond being underspecified (and partially as a consequence), it's almost impossible to implement such an initializer efficiently, because you can't say much about the value being converted or its representation.

What are you trying to do? It's likely that you're trying to do something that can naturally be more constrained and make this into a more tractable problem.

As a side note, I'm not sure that a matrix can be Numeric, as Numeric refines ExpressibleByIntegerLiteral. But even if the goal here is "extract the integer literal which produced that value", that's not always possible (as you demonstrate with the quaternion), so you're better off using BinaryInteger as the type constraint.

"Matrices" in general cannot, but square matrices of a specific size absolutely can; the ring of square matrices of any fixed dimension contains a copy of the integers (given by n -> nš).

Thanks for clarifying, makes sense that it was meant to support a more arbitrary set of types.

The intent was to take the mean of set of Numerics which would output BinaryFloatingPoint, under the assumption that the only types conforming to Numeric would be the ones specified here Numeric | Apple Developer Documentation .

To be pedantic, does it actually make sense to conform rings with zero divisors or non-commutative multiplication to Numeric though? What kind of algorithm can you write thatās generic over all such rings? (However, complex numbers are a reasonable example of something Numeric that doesnāt map into the floating point numbers in any canonical way)

This is true, but since you require your ring to have a magnitude, which presumably must satisfy some identities to allow code to be generic over it, how would you define the magnitude of a matrix so that itās ācompatibleā with the integer absolute value, like |n| = |n*I|?

An example of a rather generic ring construction that you can write algorithms over (but doesnāt belong in a standard library) is a notion of an āexactā number (so no floats) that has Euclidean division returning a quotient and remainder, and a greatest common divisor operation. This rules out non-commutative rings, zero divisors and non-unique prime factorization, but you can still construct fractions, polynomials, rational functions, power series and various other things on top of that, and they in turn will implement the same protocol.

For matrices, any of the operator norms would satisfy this requirement, as would the elementwise infinity norm. To be clear, I think we maybe shouldn't have required magnitude for Numeric, but it's definitely not a problem for square matrices.