unary `+` acts differently for `Array` and `AbstractArray`

[matthias314]

(This issue is tangentially related to #58281.)

The return type of unary + with Bool argument is not the same for arrays and views:

julia> v = [true, false]; +v
2-element Vector{Int64}:
 1
 0

julia> w = view(v, :); +w
2-element view(::Vector{Bool}, :) with eltype Bool:
 1
 0

The reason is that unary + for AbstractArray is simply the identity map:

julia/base/abstractarraymath.jl

Line 285 in 748775b

+(x::AbstractArray{<:Number}) = x

Hence it misses the convention that + transforms Bool to Int.

Another consequence of this definition is that one doesn't know whether +v is identical to v for mutable v:

julia> v = [1, 2]; +v === v
false

julia> w = view(v, :); +w === w
true

In my opinion, it would be good to have a consistent answer. However, it may be to late for that.

[heliosdrm]

I suppose that the solution is what @JeffBezanson mentioned in https://discourse.julialang.org/t/negative-false-no-longer-acts-as-a-strong-zero/128506/14, i.e. replace the current definition of unary + for AbstractArray by:

+(x::AbstractArray) = broadcast_preserving_zero_d(+, A)

But this opens new questions:

1. Why the current definition is specifically for +(x::AbstractArray{<:Number}), instead of any AbstractArray? Is that specialization needed?
2. Incidentally, what's the use case of the unary multiplication *(x::AbstractArray{<:Number, 2})?

I don't know if such a change would be technically breaking. I'd say that the current inconsistency is a bug, and the unary plus should not return the same object. The manual says that unary plus is the identity operator for primitive numeric types, but arrays are not primitive types.

[matthias314]

what's the use case of the unary multiplication

I would say that this is for consistency with the definition of a product with an arbitrary number of factors. A product with one factor is just the given value (up to the discussion of whether to return a copy or not).

[adienes]

(removing label was an accident)

[heliosdrm]

I understand - as an abstraction - the concept of a product with a single factor, but I still fail to see the consistency in its actual implementation. The unary plus makes sense as the opposite of the unary minus, which is routinely used in math. But what is the opposite of the unary times? There is not such a thing in Base, if I'm not mistaken. The closest is I think inv in LinearAlgebra.

[JeffBezanson]

Let's make this change to unary +. * is a different case; if it's defined for a single abstract matrix at all, it seems to me it has to be identity.