Make DoesNotExist more clearly like Zero (#86)

* Make DoesNotExist more clearly like Zero

* Update src/differentials/does_not_exist.jl

Co-Authored-By: willtebbutt <wt0881@my.bristol.ac.uk>

* Fix use of Zero vs Zero() in tests

Co-authored-by: willtebbutt <wt0881@my.bristol.ac.uk>

Author: oxinabox

src/differential_arithmetic.jl

@@ -8,23 +8,12 @@ Thus we can avoid any ambiguities.
 
 Notice:
     The precedence goes:
-    `Zero, DoesNotExist, One, AbstractThunk, Composite, Any`
-    Thus each of the @eval loops creating definitions of + and *
+    `DoesNotExist, Zero, One, AbstractThunk, Composite, Any`
+    Thus each of the @eval loops create most definitions of + and *
     defines the combination this type with all types of  lower precidence.
     This means each eval loops is 1 item smaller than the previous.
 ==#
 
-Base.:+(::Zero, b::Zero) = Zero()
-Base.:*(::Zero, ::Zero) = Zero()
-for T in (:DoesNotExist, :One, :AbstractThunk, :Any)
-    @eval Base.:+(::Zero, b::$T) = b
-    @eval Base.:+(a::$T, ::Zero) = a
-
-    @eval Base.:*(::Zero, ::$T) = Zero()
-    @eval Base.:*(::$T, ::Zero) = Zero()
-end
-
-
 Base.:+(::DoesNotExist, ::DoesNotExist) = DoesNotExist()
 Base.:*(::DoesNotExist, ::DoesNotExist) = DoesNotExist()
 for T in (:One, :AbstractThunk, :Any)
@@ -34,6 +23,24 @@ for T in (:One, :AbstractThunk, :Any)
     @eval Base.:*(::DoesNotExist, ::$T) = DoesNotExist()
     @eval Base.:*(::$T, ::DoesNotExist) = DoesNotExist()
 end
+# `DoesNotExist` and `Zero` have special relationship,
+# DoesNotExist wins add, Zero wins *. This is (in theory) to allow `*` to be used for
+# selecting things.
+Base.:+(::DoesNotExist, ::Zero) = DoesNotExist()
+Base.:+(::Zero, ::DoesNotExist) = DoesNotExist()
+Base.:*(::DoesNotExist, ::Zero) = Zero()
+Base.:*(::Zero, ::DoesNotExist) = Zero()
+
+
+Base.:+(::Zero, b::Zero) = Zero()
+Base.:*(::Zero, ::Zero) = Zero()
+for T in (:One, :AbstractThunk, :Any)
+    @eval Base.:+(::Zero, b::$T) = b
+    @eval Base.:+(a::$T, ::Zero) = a
+
+    @eval Base.:*(::Zero, ::$T) = Zero()
+    @eval Base.:*(::$T, ::Zero) = Zero()
+end
 
 
 Base.:+(a::One, b::One) = extern(a) + extern(b)

src/differentials/does_not_exist.jl

@@ -2,8 +2,29 @@
     DoesNotExist()
 
 This differential indicates that the derivative Does Not Exist (D.N.E).
-This is not the cast that it is not implemented, but rather that it mathematically
-is not defined.
+It is the differential for a Primal type that is not differentiable.
+Such an Integer, or Boolean (when not being used as a represention of a valid that normally
+would be a floating point.)
+The only valid way to pertube such a values is to not change it at all.
+As such, `DoesNotExist` is functionally identical to `Zero()`,
+but provides additional semantic information.
+
+If you are adding this differential to a primal then something is wrong.
+A optimization package making use of this might like to check for such a case.
+
+!!! note:
+    This does not indicate that the derivative it is not implemented,
+    but rather that mathematically it is not defined.
+
+This mostly shows up as the deriviative with respect to dimension, index, or size
+arguments.
+```
+    function rrule(fill, x, len::Int)
+        y = fill(x, len)
+        fill_pullback(ȳ) = (NO_FIELDS, @thunk(sum(Ȳ)), DoesNotExist())
+        return y, fill_pullback
+    end
+```
 """
 struct DoesNotExist <: AbstractDifferential end
 
@@ -15,4 +36,3 @@ Base.Broadcast.broadcastable(::DoesNotExist) = Ref(DoesNotExist())
 
 Base.iterate(x::DoesNotExist) = (x, nothing)
 Base.iterate(::DoesNotExist, ::Any) = nothing
-

test/differentials/does_not_exist.jl

@@ -0,0 +1,22 @@
+@testset "DoesNotExist" begin
+    dne = DoesNotExist()
+    @test_throws Exception extern(dne)
+    @test dne + dne == dne
+    @test dne + 1 == 1
+    @test 1 + dne == 1
+    @test dne * dne == dne
+    @test dne * 1 == dne
+    @test 1 * dne == dne
+
+    @test Zero() + dne == dne
+    @test dne + Zero() == dne
+
+    @test Zero() * dne == Zero()
+    @test dne * Zero() == Zero()
+
+    for x in dne
+        @test x === dne
+    end
+    @test broadcastable(dne) isa Ref{DoesNotExist}
+    @test conj(dne) == dne
+end

test/runtests.jl

@@ -10,6 +10,7 @@ using Base.Broadcast: broadcastable
 @testset "ChainRulesCore" begin
     @testset "differentials" begin
         include("differentials/zero.jl")
+        include("differentials/does_not_exist.jl")
         include("differentials/one.jl")
         include("differentials/thunks.jl")
         include("differentials/composite.jl")