Remove ndims/eltype, and simplify parent type queries.

Project.toml

@@ -1,6 +1,6 @@
 name = "Adapt"
 uuid = "79e6a3ab-5dfb-504d-930d-738a2a938a0e"
-version = "3.7.2"
+version = "4.0.0"
 
 [deps]
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"

src/wrappers.jl

@@ -5,26 +5,26 @@ using LinearAlgebra
 permutation(::PermutedDimsArray{T,N,perm}) where {T,N,perm} = perm
 
 
-export WrappedArray
+export WrappedArray, parent_type, unwrap_type
 
 adapt_structure(to, A::SubArray) =
- SubArray(adapt(to, Base.parent(A)), adapt(to, parentindices(A)))
+ SubArray(adapt(to, parent(A)), adapt(to, parentindices(A)))
 function adapt_structure(to, A::PermutedDimsArray)
  perm = permutation(A)
  iperm = invperm(perm)
- A′ = adapt(to, Base.parent(A))
- PermutedDimsArray{Base.eltype(A′),Base.ndims(A′),perm,iperm,typeof(A′)}(A′)
+ A′ = adapt(to, parent(A))
+ PermutedDimsArray{eltype(A′),ndims(A′),perm,iperm,typeof(A′)}(A′)
 end
 adapt_structure(to, A::Base.ReshapedArray) =
- Base.reshape(adapt(to, Base.parent(A)), size(A))
+ Base.reshape(adapt(to, parent(A)), size(A))
 @static if isdefined(Base, :NonReshapedReinterpretArray)
  adapt_structure(to, A::Base.NonReshapedReinterpretArray) =
- Base.reinterpret(Base.eltype(A), adapt(to, Base.parent(A)))
+ Base.reinterpret(eltype(A), adapt(to, parent(A)))
  adapt_structure(to, A::Base.ReshapedReinterpretArray) =
- Base.reinterpret(reshape, Base.eltype(A), adapt(to, Base.parent(A)))
+ Base.reinterpret(reshape, eltype(A), adapt(to, parent(A)))
 else
  adapt_structure(to, A::Base.ReinterpretArray) =
- Base.reinterpret(Base.eltype(A), adapt(to, Base.parent(A)))
+ Base.reinterpret(eltype(A), adapt(to, parent(A)))
 end
 @eval function adapt_structure(to, A::Base.LogicalIndex{T}) where T
  # prevent re-calculating the count of booleans during LogicalIndex construction
@@ -33,23 +33,23 @@ end
 end
 
 adapt_structure(to, A::LinearAlgebra.Adjoint) =
- LinearAlgebra.adjoint(adapt(to, Base.parent(A)))
+ LinearAlgebra.adjoint(adapt(to, parent(A)))
 adapt_structure(to, A::LinearAlgebra.Transpose) =
- LinearAlgebra.transpose(adapt(to, Base.parent(A)))
+ LinearAlgebra.transpose(adapt(to, parent(A)))
 adapt_structure(to, A::LinearAlgebra.LowerTriangular) =
- LinearAlgebra.LowerTriangular(adapt(to, Base.parent(A)))
+ LinearAlgebra.LowerTriangular(adapt(to, parent(A)))
 adapt_structure(to, A::LinearAlgebra.UnitLowerTriangular) =
- LinearAlgebra.UnitLowerTriangular(adapt(to, Base.parent(A)))
+ LinearAlgebra.UnitLowerTriangular(adapt(to, parent(A)))
 adapt_structure(to, A::LinearAlgebra.UpperTriangular) =
- LinearAlgebra.UpperTriangular(adapt(to, Base.parent(A)))
+ LinearAlgebra.UpperTriangular(adapt(to, parent(A)))
 adapt_structure(to, A::LinearAlgebra.UnitUpperTriangular) =
- LinearAlgebra.UnitUpperTriangular(adapt(to, Base.parent(A)))
+ LinearAlgebra.UnitUpperTriangular(adapt(to, parent(A)))
 adapt_structure(to, A::LinearAlgebra.Diagonal) =
- LinearAlgebra.Diagonal(adapt(to, Base.parent(A)))
+ LinearAlgebra.Diagonal(adapt(to, parent(A)))
 adapt_structure(to, A::LinearAlgebra.Tridiagonal) =
  LinearAlgebra.Tridiagonal(adapt(to, A.dl), adapt(to, A.d), adapt(to, A.du))
 adapt_structure(to, A::LinearAlgebra.Symmetric) =
- LinearAlgebra.Symmetric(adapt(to, Base.parent(A)))
+ LinearAlgebra.Symmetric(adapt(to, parent(A)))
 
 
 # we generally don't support multiple layers of wrappers, but some occur often
@@ -119,28 +119,32 @@ const WrappedArray{T,N,Src,Dst} = Union{
 # `Union{SomeArray, WrappedArray{<:Any, <:SomeArray}}` for dispatch.
 # https://github.com/JuliaLang/julia/pull/31563
 
-# accessors for extracting information about the wrapper type
-ndims(::Type{<:Base.LogicalIndex}) = 1
-ndims(::Type{<:LinearAlgebra.Adjoint}) = 2
-ndims(::Type{<:LinearAlgebra.Transpose}) = 2
-ndims(::Type{<:LinearAlgebra.LowerTriangular}) = 2
-ndims(::Type{<:LinearAlgebra.UnitLowerTriangular}) = 2
-ndims(::Type{<:LinearAlgebra.UpperTriangular}) = 2
-ndims(::Type{<:LinearAlgebra.UnitUpperTriangular}) = 2
-ndims(::Type{<:LinearAlgebra.Diagonal}) = 2
-ndims(::Type{<:LinearAlgebra.Tridiagonal}) = 2
-ndims(::Type{<:LinearAlgebra.Symmetric}) = 2
-ndims(::Type{<:WrappedArray{<:Any,N}}) where {N} = N
-
-eltype(::Type{<:WrappedArray{T}}) where {T} = T # every wrapper has a T typevar
+
+"""
+ parent_type(W::Type{<:WrappedArray})
+
+Return the parent type of a wrapped array type. This is the type of the array that is
+wrapped by the wrapper, e.g. `parent_type(SubArray{Int, 1, Matrix{Int}}) == Matrix{Int}`.
+"""
+parent_type(::Type{<:WrappedArray{<:Any,<:Any,<:Any,Dst}}) where {Dst} = Dst
 
 for T in [:(Base.LogicalIndex{<:Any,<:Src}),
  :(PermutedDimsArray{<:Any,<:Any,<:Any,<:Any,<:Src}),
  :(WrappedReinterpretArray{<:Any,<:Any,<:Src}),
  :(WrappedReshapedArray{<:Any,<:Any,<:Src}),
  :(WrappedSubArray{<:Any,<:Any,<:Src})]
  @eval begin
- parent(::Type{<:$T}) where {Src} = Src.name.wrapper
+ parent_type(::Type{<:$T}) where {Src} = Src
  end
 end
-parent(::Type{<:WrappedArray{<:Any,<:Any,<:Any,Dst}}) where {Dst} = Dst.name.wrapper
+
+
+"""
+ unwrap_type(W::Type{<:WrappedArray})
+
+Fully unwrap a wrapped array type, i.e., returns the `parent_type` until the result is no
+longer a wrapped array type. This is useful for accessing properties of the innermost
+array type.
+"""
+unwrap_type(W::Type{<:WrappedArray}) = unwrap_type(parent_type(W))
+unwrap_type(W::Type{<:AbstractArray}) = W

test/runtests.jl

@@ -8,7 +8,6 @@ struct CustomArray{T,N} <: AbstractArray{T,N}
  arr::Array{T,N}
 end
 
-CustomArray(x::Array{T,N}) where {T,N} = CustomArray{T,N}(x)
 Adapt.adapt_storage(::Type{<:CustomArray}, xs::Array) = CustomArray(xs)
 
 Base.size(x::CustomArray, y...) = size(x.arr, y...)
@@ -58,7 +57,6 @@ AnyCustomArray{T,N} = Union{CustomArray,WrappedArray{T,N,CustomArray,CustomArray
 struct Wrapper{T}
  arr::T
 end
-Wrapper(x::T) where T = Wrapper{T}(x)
 Adapt.adapt_structure(to, xs::Wrapper) = Wrapper(adapt(to, xs.arr))
 @test_adapt CustomArray Wrapper(mat.arr) Wrapper(mat)
 
@@ -192,12 +190,13 @@ end
 
 
 @testset "type information" begin
- @test Adapt.ndims(LinearAlgebra.Transpose{Float64,Array{Float64,1}}) == 2
- @test Adapt.ndims(LinearAlgebra.Symmetric{Float64,Matrix{Float64}}) == 2
- @test Adapt.ndims(Adapt.WrappedSubArray{Float64,3,Array{Float64,3}}) == 3
+ # single wrapping
+ @test parent_type(Transpose{Int,Array{Int,1}}) == Array{Int,1}
+ @test parent_type(Transpose{Int,Transpose{Int,Array{Int,1}}}) == Transpose{Int,Array{Int,1}}
 
- @test Adapt.parent(LinearAlgebra.Transpose{Float64,Array{Float64,1}}) == Array
- @test Adapt.parent(Adapt.WrappedSubArray{Float64,3,Array{Float64,3}}) == Array
+ # double wrapping
+ @test unwrap_type(Transpose{Int,Array{Int,1}}) == Array{Int,1}
+ @test unwrap_type(Transpose{Int,Transpose{Int,Array{Int,1}}}) == Array{Int,1}
 end