Derivatives of constant functions return nothing.

[MasonProtter]

I've tested this on Zygote#master and latest release:

julia> using Zygote

julia> (x -> 1)'(1) == nothing
true

Probably this should give false or something like that instead of nothing.

[MikeInnes]

This is currently the expected behaviour; we use nothing as a "generalised zero". We could potentially replace this with a Zero type, or something, instead. false is a bit problematic because we can't dispatch on it, and this needs to work not just on numeric types but also on things like structs and symbols.

[MasonProtter]

we use nothing as a "generalised zero"

This is problematic because nothing doesn't actually have any of the properties of zero.

julia> g(f, x) = f'(x) + x
g (generic function with 1 method)

julia> g(x -> 2, 1)
ERROR: MethodError: no method matching +(::Nothing, ::Int64)

Yeah, I think some sort of Zero type would be preferable and then we just define some basic relations:

struct Zero end
Base.:(+)(z::Zero, x) = x
Base.:(+)(x, z::Zero) = x

Base.:(-)(z::Zero, x) = -x
Base.:(-)(x, z::Zero) =  x

Base.:(*)(z::Zero, x) = z
Base.:(*)(x, z::Zero) = z

Base.:(/)(z::Zero, x) = z

Base.:(^)(z::Zero, x) = z
Base.:(^)(x, z::Zero) = one(x)

etc.

This could actually potentially go into Base.LinearAlgebra as the zero analogue of UniformScaling.

[MikeInnes]

It's an option, but note that this (or false) can easily end up giving you the reverse issue: + will throw an error if the gradient is actually non-zero (e.g. because it's a gradient of a struct).

The current recommended way to deal with this is to just use something(f'(x), 0); you can pretty easily wrap the gradient function to do this automatically if you want as well.

[baggepinnen]

For reference, ChainRules.jl is making use of some Zero type, but I believe it has been questioned at some point
https://github.com/JuliaDiff/ChainRules.jl/search?utf8=%E2%9C%93&q=Zero&type=