Don't try and convert to FloatX except if Integer or AbstractFloat

Author: oxinabox

Project.toml

@@ -1,6 +1,6 @@
 name = "ChainRulesCore"
 uuid = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4"
-version = "1.0.1"
+version = "1.0.2"
 
 [deps]
 Compat = "34da2185-b29b-5c13-b0c7-acf172513d20"

src/projection.jl

@@ -135,13 +135,44 @@ ProjectTo(::Real) = ProjectTo{Real}()
 ProjectTo(::Complex) = ProjectTo{Complex}()
 ProjectTo(::Number) = ProjectTo{Number}()
 for T in (Float16, Float32, Float64, ComplexF16, ComplexF32, ComplexF64)
-    # Preserve low-precision floats as accidental promotion is a common perforance bug
+    # Preserve low-precision floats as accidental promotion is a common perforance bug    
     @eval ProjectTo(::$T) = ProjectTo{$T}()
 end
 ProjectTo(x::Integer) = ProjectTo(float(x))
 ProjectTo(x::Complex{<:Integer}) = ProjectTo(float(x))
-(::ProjectTo{T})(dx::Number) where {T<:Number} = convert(T, dx)
-(::ProjectTo{T})(dx::Number) where {T<:Real} = convert(T, real(dx))
+
+# Preserve low-precision floats as accidental promotion is a common perforance bug
+(::ProjectTo{T})(dx::AbstractFloat) where T<:AbstractFloat = convert(T, dx)
+(::ProjectTo{T})(dx::Integer) where T<:AbstractFloat = convert(T, dx)
+
+
+# We asked for a number/real and they gave use one. We did ask for a particular concrete
+# type, but that is just for the preserving low precision floats, which is handled above.
+# Any Number/Real actually occupies the same subspace, so we can trust them.
+# In particular, this makes weirder Real subtypes that are not simply the values like
+# ForwardDiff.Dual and Symbolics.Sym work, because we stay out of their way.
+(::ProjectTo{<:Number})(dx::Number) where {T<:Number} = dx
+(::ProjectTo{<:Real})(dx::Real) = dx
+
+(::ProjectTo{T})(dx::Complex) where T<:Real = ProjectTo(zero(T))(real(dx))
+
+# Complex 
+function (proj::ProjectTo{<:Complex{<:AbstractFloat}})(
+    dx::Complex{<:Union{AbstractFloat,Integer}}
+)   
+    # in this case we can just convert as we know we are dealing with 
+    # boring floating point types or integers
+    return convert(project_type(proj), dx)
+end
+# Pass though non-AbstractFloat to project each component
+function (::ProjectTo{<:Complex{T}})(dx::Complex) where T
+    project = ProjectTo(zero(T))
+    return Complex(project(real(dx)), project(imag(dx)))
+end
+function (::ProjectTo{<:Complex{T}})(dx::Real) where T
+    project = ProjectTo(zero(T))
+    return Complex(project(dx), project(zero(dx)))
+end
 
 # Arrays
 # If we don't have a more specialized `ProjectTo` rule, we just assume that there is

test/projection.jl

@@ -2,6 +2,15 @@ using ChainRulesCore, Test
 using LinearAlgebra, SparseArrays
 using OffsetArrays, BenchmarkTools
 
+# Like ForwardDiff.jl's Dual
+struct Dual{T<:Real} <: Real
+    value::T
+    partial::T
+end
+Base.real(x::Dual) = x
+Base.float(x::Dual) = Dual(float(x.value), float(x.partial))
+Base.zero(x::Dual) = Dual(zero(x.value), zero(x.partial))
+
 @testset "projection" begin
 
     #####
@@ -12,14 +21,28 @@ using OffsetArrays, BenchmarkTools
         # real / complex
         @test ProjectTo(1.0)(2.0 + 3im) === 2.0
         @test ProjectTo(1.0 + 2.0im)(3.0) === 3.0 + 0.0im
+        @test ProjectTo(2.0+3.0im)(1+1im) === 1.0+1.0im
+        @test ProjectTo(2.0)(1+1im) === 1.0
+        
 
         # storage
-        @test ProjectTo(1)(pi) === Float64(pi)
+        @test ProjectTo(1)(pi) === pi
         @test ProjectTo(1 + im)(pi) === ComplexF64(pi)
         @test ProjectTo(1//2)(3//4) === 3//4
         @test ProjectTo(1.0f0)(1 / 2) === 0.5f0
         @test ProjectTo(1.0f0 + 2im)(3) === 3.0f0 + 0im
         @test ProjectTo(big(1.0))(2) === 2
+        @test ProjectTo(1.0)(2) === 2.0
+    end
+
+    @testset "Dual" begin # some weird Real subtype that we should basically leave alone
+        @test ProjectTo(1.0)(Dual(1.0, 2.0)) isa Dual
+        @test ProjectTo(1.0)(Dual(1, 2)) isa Dual
+        @test ProjectTo(1.0 + 1im)(Dual(1.0, 2.0)) isa Complex{<:Dual}
+        @test ProjectTo(1.0 + 1im)(
+            Complex(Dual(1.0, 2.0), Dual(1.0, 2.0))
+        ) isa Complex{<:Dual}
+        @test ProjectTo(1.0)(Complex(Dual(1.0, 2.0), Dual(1.0, 2.0))) isa Dual
     end
 
     @testset "Base: arrays of numbers" begin