Extend convert_eltype(T,X::Type) for more types X

Author: emmt

src/TypeUtils.jl

@@ -911,6 +911,8 @@ convert_eltype(::Type{T}, ::Type{X}) where {T,X} =
 
 convert_eltype(::Type{T}, A::AbstractArray{T}) where {T} = A
 convert_eltype(::Type{T}, A::AbstractArray) where {T} = as(AbstractArray{T}, A)
+convert_eltype(::Type{T}, ::Type{<:Array{<:Any,N}}) where {T,N} = Array{T,N}
+convert_eltype(::Type{T}, ::Type{<:AbstractArray{<:Any,N}}) where {T,N} = AbstractArray{T,N}
 
 # Convert element type for numbers.
 convert_eltype(::Type{T}, ::Type{<:Number}) where {T} = T
@@ -930,11 +932,13 @@ convert_eltype(::Type{T}, A::Union{OneTo,UnitRange}) where {T} =
     as(convert_eltype(T, typeof(A)), A)
 
 # Convert element type for AbstractUnitRange{T} <: OrdinalRange{T,T}.
+convert_eltype(::Type{T}, ::Type{<:AbstractUnitRange}) where {T} = AbstractUnitRange{T}
 convert_eltype(::Type{T}, A::AbstractUnitRange{T}) where {T} = A
 convert_eltype(::Type{T}, A::AbstractUnitRange) where {T} =
     as(T, first(A)):as(T, last(A))
 
 # Convert element type for other range types.
+convert_eltype(::Type{T}, ::Type{<:AbstractRange}) where {T} = AbstractRange{T}
 convert_eltype(::Type{T}, A::AbstractRange{T}) where {T} = A
 convert_eltype(::Type{T}, A::AbstractRange) where {T} =
     as(T, first(A)):as(T, step(A)):as(T, last(A))

test/runtests.jl

@@ -338,62 +338,73 @@ same_value_and_type(x::T, y::T) where {T} = (x === y) || (x == y)
     @testset "convert_eltype()" begin
         # Numbers.
         let A = rand(Float64), B = @inferred convert_eltype(Float32, A)
-            @test convert_eltype(eltype(A), A) === A
+            @test A === @inferred convert_eltype(eltype(A), A)
             @test B isa Float32
             @test B == Float32.(A)
+            @test typeof(B) === @inferred convert_eltype(eltype(B), typeof(A))
         end
         # Abstract arrays.
         let A = rand(Float64, 2, 3), B = @inferred convert_eltype(Float32, A)
-            @test convert_eltype(eltype(A), A) === A
+            @test A === @inferred convert_eltype(eltype(A), A)
             @test B isa AbstractArray{Float32,ndims(A)}
             @test B == Float32.(A)
+            @test typeof(B) === @inferred convert_eltype(eltype(B), typeof(A))
+            @test AbstractArray{UInt8,2} === @inferred convert_eltype(UInt8, typeof(view(A,:,1:2:3)))
         end
         # Base.OneTo
         let A = OneTo{Int32}(7), B = @inferred convert_eltype(Int16, A)
-            @test convert_eltype(eltype(A), A) === A
+            @test A === @inferred convert_eltype(eltype(A), A)
             @test B isa OneTo{Int16}
             @test B == Int16.(A)
+            @test typeof(B) === @inferred convert_eltype(eltype(B), typeof(A))
         end
         let A = OneTo(7), B = @inferred convert_eltype(Float32, A)
-            @test convert_eltype(eltype(A), A) === A
+            @test A === @inferred convert_eltype(eltype(A), A)
             @test B isa AbstractRange{Float32}
             @test B == Float32.(A)
+            @test typeof(B) === @inferred convert_eltype(eltype(B), typeof(A))
         end
         # UnitRange
         let A = 2:8, B = @inferred convert_eltype(Float32, A)
-            @test convert_eltype(eltype(A), A) === A
+            @test A === @inferred convert_eltype(eltype(A), A)
             @test B isa AbstractRange{Float32}
             @test B == Float32.(A)
+            @test typeof(B) === @inferred convert_eltype(eltype(B), typeof(A))
         end
         # OrdinalRange
         let A = 2.0:3.0:11.0, B = @inferred convert_eltype(Float32, A)
-            @test convert_eltype(eltype(A), A) === A
+            @test A === @inferred convert_eltype(eltype(A), A)
             @test B isa AbstractRange{Float32}
             @test B == Float32.(A)
+            @test typeof(B) <: @inferred convert_eltype(eltype(B), typeof(A))
         end
         # LinRange
         let A = LinRange(-2.0, 3.0, 5), B = @inferred convert_eltype(Float32, A)
-            @test convert_eltype(eltype(A), A) === A
+            @test A === @inferred convert_eltype(eltype(A), A)
             @test B isa LinRange{Float32}
             @test B == Float32.(A)
+            @test typeof(B) <: @inferred convert_eltype(eltype(B), typeof(A))
         end
         # Tuples.
         let A = (1, 2, 3) #= NTuple =#, B = @inferred convert_eltype(Float32, A)
-            @test convert_eltype(eltype(A), A) === A
-            @test B isa NTuple{<:Any,Float32}
+            @test A === @inferred convert_eltype(eltype(A), A)
+            @test B isa NTuple{3,Float32}
             @test B == Float32.(A)
+            @test typeof(B) === @inferred convert_eltype(Float32, typeof(A))
         end
-        let A = (1, 2.0, 3) #= not NTuple but Tuple =#, B = @inferred convert_eltype(Float32, A)
-            @test convert_eltype(eltype(A), A) === A
-            @test B isa NTuple{<:Any,Float32}
+        let A = (1, 2.0, pi) #= not NTuple but Tuple =#, B = @inferred convert_eltype(Float32, A)
+            @test A === @inferred convert_eltype(eltype(A), A)
+            @test B isa NTuple{3,Float32}
             @test B == Float32.(A)
+            @test typeof(B) === @inferred convert_eltype(Float32, typeof(A))
         end
         # Map `convert_eltype`.
         let A = rand(Float64, 2, 3), B = reshape(1:12, 3, 4)
             f = @inferred convert_eltype(Float32)
             @test isequal(f(A), convert_eltype(Float32, A))
             @test isequal(f(B), convert_eltype(Float32, B))
         end
+        @test_throws ErrorException convert_eltype(Char, String)
     end
 
     @testset "as_eltype()" begin