missing convert method

[johnnychen94]

convert(Vector, 1:5)
convert(OffsetVector, 1:5) # doesn't work

Will it be type piracy if we define convert(::Type{T}, x) where {T<:OffsetArray}?

[chriselrod]

No, because OffsetArray is defined here. Although defining new convert methods tends to cause huge numbers of invalidations.

[chriselrod]

What about something like

function Base.convert(::Type{T}, A::AbstractArray{<:Any,N}) where {N, T <: OffsetArray{<:Any,N}}
    OffsetArray(A, ntuple(zero, Val(N))...)
end

?

[jishnub]

Related to this conversion is the constructor (::Type{<:OffsetArray})(::Array), which might resolve this issue with DistributedArrays.jl. The offending line appears to be
https://github.com/JuliaParallel/DistributedArrays.jl/blob/b98875d16c6810d33498405d5d852a3acee19b38/src/darray.jl#L66, where, given a type A, the function tries to construct an empty object of that type through

empty_localpart(T,N,A) = A(Array{T}(undef, ntuple(zero, N)))

I wonder if it's worth adding the constructor as well? Although if this conversion is added, it might be possible for DistributedArrays to use that instead of the constructor, as ultimately this operation is a conversion of an Array to an object of the type A

[jishnub]

What about something like

function Base.convert(::Type{T}, A::AbstractArray{<:Any,N}) where {N, T <: OffsetArray{<:Any,N}}
    OffsetArray(A, ntuple(zero, Val(N))...)
end

?

We'll perhaps need to convert or constrain the eltype too to avoid cases like

julia> convert(OffsetArray{Float32,2}, rand(2,2))
2×2 OffsetArray(::Array{Float64,2}, 1:2, 1:2) with eltype Float64 with indices 1:2×1:2:
 0.580097  0.655686
 0.406192  0.0662347

Whether or not we allow the eltype to change is subject to how we view this conversion. If it is simply viewed as an identity map applied to the indices of the parent array then the element type should remain the same. On the other hand constraining the element type might make the conversion too narrow in scope, and it might be worth passing on the eltype conversion to the parent.

[GregPlowman]

Not sure if this is the same issue, but I think I want a more narrow convert.

I would like to convert between OffsetArrays where the backing AbstractArray can be converted.

Base.convert(::Type{OffsetArray{T,N,A}}, x::OffsetArray{S,N}) where {T,N,A,S} = OffsetArray(convert(A, x.parent), x.offsets)

One scenario for this:

using OffsetArrays

struct Foo1
    a::Array{Float64,1}
end

struct Foo2
    o::OffsetArray{Float64,1,Array{Float64,1}}
end

A = zeros(Int, 3)
O = zeros(Int, 0:2)

Foo1(A)  # converts on construction
Foo2(O)  # errors without the extra convert method defined

[jishnub]

Perhaps a combination of

julia> function Base.convert(::Type{OffsetArray{T,N,AA}}, A::AbstractArray{<:Any,N}) where {T, N, AA}
           OffsetArray{T,N,AA}(convert(AA, A), ntuple(zero, Val(N)))
       end
              
julia> function Base.convert(::Type{OffsetArray{T,N,AA}}, A::OffsetArray{<:Any,N}) where {T, N, AA}
           OffsetArray{T,N,AA}(convert(AA, A.parent), A.offsets)
       end

might help with conversions where all the type parameters are specified? With these, both the constructors work:

julia> Foo2(A)
Foo2([0.0, 0.0, 0.0])

julia> Foo2(O)
Foo2([0.0, 0.0, 0.0])

We might need other method for more general conversions such as in the top post. Not sure what's the best way to go about these.