Type stability in promote spaces (#124)

* type stability in promote spaces

* Add tests

Author: jishnub

src/Operators/Operator.jl

@@ -9,7 +9,7 @@ export domainspace,rangespace
 abstract type Operator{T} end #T is the entry type, Float64 or Complex{Float64}
 
 eltype(::Operator{T}) where {T} = T
-eltype(::Type{Operator{T}}) where {T} = T
+eltype(::Type{<:Operator{T}}) where {T} = T
 eltype(::Type{OT}) where {OT<:Operator} = eltype(supertype(OT))
 
 

src/Operators/spacepromotion.jl

@@ -47,24 +47,12 @@ rangespace(S::SpaceOperator) = S.rangespace
 
 
 ##TODO: Do we need both max and min?
-function findmindomainspace(ops::AbstractVector)::Any
-    sp = UnsetSpace()
-
-    for op in ops
-        sp = union(sp,domainspace(op))
-    end
-
-    sp
+function findmindomainspace(ops::AbstractVector)
+    mapreduce(domainspace, union, ops, init = UnsetSpace())
 end
 
-function findmaxrangespace(ops::AbstractVector)::Any
-    sp = UnsetSpace()
-
-    for op in ops
-        sp = maxspace(sp,rangespace(op))
-    end
-
-    sp
+function findmaxrangespace(ops::AbstractVector)
+    mapreduce(rangespace, maxspace, ops, init = UnsetSpace())
 end
 
 
@@ -80,31 +68,31 @@ promoterangespace(P::Operator,sp::Space) = promoterangespace(P,sp,rangespace(P))
 promotedomainspace(P::Operator,sp::Space) = promotedomainspace(P,sp,domainspace(P))
 
 
-promoterangespace(P::Operator,sp::Space,cursp::Space)::Any =
+promoterangespace(P::Operator,sp::Space,cursp::Space) =
     (sp==cursp) ? P : Conversion(cursp,sp)*P
-promotedomainspace(P::Operator,sp::Space,cursp::Space)::Any =
+promotedomainspace(P::Operator,sp::Space,cursp::Space) =
     (sp==cursp) ? P : P*Conversion(sp,cursp)
 
 
 
 
 
 function promoterangespace(ops::AbstractVector{O}) where O<:Operator
-    isempty(ops) && return ops
+    isempty(ops) && return convert(Vector{Operator{eltype(O)}}, ops)
     k=findmaxrangespace(ops)
     #TODO: T might be incorrect
     T=mapreduce(eltype,promote_type,ops)
     Operator{T}[promoterangespace(op,k) for op in ops]
 end
 function promotedomainspace(ops::AbstractVector{O}) where O<:Operator
-    isempty(ops) && return ops
+    isempty(ops) && return convert(Vector{Operator{eltype(O)}}, ops)
     k=findmindomainspace(ops)
     #TODO: T might be incorrect
     T=mapreduce(eltype,promote_type,ops)
     Operator{T}[promotedomainspace(op,k) for op in ops]
 end
 function promotedomainspace(ops::AbstractVector{O},S::Space) where O<:Operator
-    isempty(ops) && return ops
+    isempty(ops) && return convert(Vector{Operator{eltype(O)}}, ops)
     k=conversion_type(findmindomainspace(ops),S)
     #TODO: T might be incorrect
     T=promote_type(mapreduce(eltype,promote_type,ops),prectype(S))

test/SpacesTest.jl

@@ -131,4 +131,14 @@ import ApproxFunBase: PointSpace, HeavisideSpace, PiecewiseSegment, dimension, V
         f = Fun(2)
         @test (@inferred convert(Fun{typeof(space(f))}, 2)) == f
     end
+
+    @testset "promotion" begin
+        M = Multiplication(Fun(PointSpace(1:3), [1:3;]));
+        D = Derivative()
+        for v in Any[[M, M], [D, D], [D, M]]
+            @test (@inferred ApproxFunBase.promotedomainspace(v)) == v
+            @test (@inferred ApproxFunBase.promoterangespace(v)) == v
+            @test (@inferred ApproxFunBase.promotespaces(v)) == v
+        end
+    end
 end