Merge pull request #156 from JuliaDiff/ox/clean

format the code

Author: oxinabox

docs/make.jl

@@ -1,18 +1,14 @@
 using ChainRulesTestUtils
 using Documenter
 
-
-makedocs(
+makedocs(;
     modules=[ChainRulesTestUtils],
-    format=Documenter.HTML(prettyurls=false, assets=["assets/chainrules.css"]),
+    format=Documenter.HTML(; prettyurls=false, assets=["assets/chainrules.css"]),
     sitename="ChainRulesTestUtils",
     authors="JuliaDiff contributors",
     strict=true,
     checkdocs=:exports,
 )
 
 const repo = "github.com/JuliaDiff/ChainRulesTestUtils.jl.git"
-deploydocs(
-    repo=repo,
-    push_preview=true,
-)
+deploydocs(; repo=repo, push_preview=true)

src/ChainRulesTestUtils.jl

@@ -17,7 +17,6 @@ export TestIterator
 export check_equal, test_scalar, test_frule, test_rrule, generate_well_conditioned_matrix
 export ⊢
 
-
 include("generate_tangent.jl")
 include("data_generation.jl")
 include("iterator.jl")

src/check_result.jl

@@ -12,16 +12,16 @@ Understands things like `unthunk`ing `ChainRuleCore.Thunk`s, etc.
 All keyword arguments are passed to `isapprox`.
 """
 function check_equal(
-    actual::Union{AbstractArray{<:Number}, Number},
-    expected::Union{AbstractArray{<:Number}, Number};
-    kwargs...
+    actual::Union{AbstractArray{<:Number},Number},
+    expected::Union{AbstractArray{<:Number},Number};
+    kwargs...,
 )
     @test isapprox(actual, expected; kwargs...)
 end
 
 for (T1, T2) in ((AbstractThunk, Any), (AbstractThunk, AbstractThunk), (Any, AbstractThunk))
     @eval function check_equal(actual::$T1, expected::$T2; kwargs...)
-        check_equal(unthunk(actual), unthunk(expected); kwargs...)
+        return check_equal(unthunk(actual), unthunk(expected); kwargs...)
     end
 end
 
@@ -75,7 +75,7 @@ function check_equal(actual::AbstractArray, expected::AbstractArray; kwargs...)
     end
 end
 
-function check_equal(actual::Tangent{P}, expected::Tangent{P}; kwargs...) where P
+function check_equal(actual::Tangent{P}, expected::Tangent{P}; kwargs...) where {P}
     if _can_pass_early(actual, expected)
         @test true
     else
@@ -88,15 +88,14 @@ end
 
 function check_equal(
     ::Tangent{ActualPrimal}, expected::Tangent{ExpectedPrimal}; kwargs...
-) where {ActualPrimal, ExpectedPrimal}
+) where {ActualPrimal,ExpectedPrimal}
     # this will certainly fail as we have another dispatch for that, but this will give as
     # good error message
     @test ActualPrimal === ExpectedPrimal
 end
 
-
 # Some structual differential and a natural differential
-function check_equal(actual::Tangent{P, T}, expected; kwargs...) where {T, P}
+function check_equal(actual::Tangent{P,T}, expected; kwargs...) where {T,P}
     if _can_pass_early(actual, expected)
         @test true
     else
@@ -118,7 +117,7 @@ check_equal(::C, ::T; kwargs...) where {C<:Tangent,T<:LegacyZygoteCompTypes} = @
 check_equal(::T, ::C; kwargs...) where {C<:Tangent,T<:LegacyZygoteCompTypes} = @test T === C
 
 # Generic fallback, probably a tuple or something
-function check_equal(actual::A, expected::E; kwargs...) where {A, E}
+function check_equal(actual::A, expected::E; kwargs...) where {A,E}
     if _can_pass_early(actual, expected)
         @test true
     else
@@ -147,7 +146,7 @@ function _check_add!!_behaviour(acc, val; kwargs...)
     # e.g. if it is immutable. We do test the `add!!` return value.
     # That is what people should rely on. The mutation is just to save allocations.
     acc_mutated = deepcopy(acc)  # prevent this test changing others
-    check_equal(add!!(acc_mutated, val), acc + val; kwargs...)
+    return check_equal(add!!(acc_mutated, val), acc + val; kwargs...)
 end
 
 # Checking equality with `NotImplemented` reports `@test_broken` since the derivative has intentionally
@@ -161,7 +160,8 @@ function _check_add!!_behaviour(acc_mutated::ChainRulesCore.NotImplemented, acc;
 end
 # In this case we check for equality (messages etc. have to be equal)
 function _check_add!!_behaviour(
-    acc_mutated::ChainRulesCore.NotImplemented, acc::ChainRulesCore.NotImplemented;
+    acc_mutated::ChainRulesCore.NotImplemented,
+    acc::ChainRulesCore.NotImplemented;
     kwargs...,
 )
     return @test acc_mutated == acc

src/deprecated.jl

@@ -1,33 +1,39 @@
 # TODO remove these in version 0.6
 # We are silently deprecating them as there is no alternative we are providing
 
-Base.isapprox(a, b::Union{AbstractZero, AbstractThunk}; kwargs...) = isapprox(b, a; kwargs...)
-Base.isapprox(d_ad::AbstractThunk, d_fd; kwargs...) = isapprox(extern(d_ad), d_fd; kwargs...)
-Base.isapprox(d_ad::NoTangent, d_fd; kwargs...) = error("Tried to differentiate w.r.t. a `NoTangent`")
+function Base.isapprox(a, b::Union{AbstractZero,AbstractThunk}; kwargs...)
+    return isapprox(b, a; kwargs...)
+end
+function Base.isapprox(d_ad::AbstractThunk, d_fd; kwargs...)
+    return isapprox(extern(d_ad), d_fd; kwargs...)
+end
+function Base.isapprox(d_ad::NoTangent, d_fd; kwargs...)
+    return error("Tried to differentiate w.r.t. a `NoTangent`")
+end
 # Call `all` to handle the case where `ZeroTangent` is standing in for a non-scalar zero
-Base.isapprox(d_ad::ZeroTangent, d_fd; kwargs...) = all(isapprox.(extern(d_ad), d_fd; kwargs...))
+function Base.isapprox(d_ad::ZeroTangent, d_fd; kwargs...)
+    return all(isapprox.(extern(d_ad), d_fd; kwargs...))
+end
 
 isapprox_vec(a, b; kwargs...) = isapprox(first(to_vec(a)), first(to_vec(b)); kwargs...)
 Base.isapprox(a, b::Tangent; kwargs...) = isapprox(b, a; kwargs...)
 function Base.isapprox(d_ad::Tangent{<:Tuple}, d_fd::Tuple; kwargs...)
     return isapprox_vec(d_ad, d_fd; kwargs...)
 end
 function Base.isapprox(
-    d_ad::Tangent{P, <:Tuple}, d_fd::Tangent{P, <:Tuple}; kwargs...
-) where {P <: Tuple}
+    d_ad::Tangent{P,<:Tuple}, d_fd::Tangent{P,<:Tuple}; kwargs...
+) where {P<:Tuple}
     return isapprox_vec(d_ad, d_fd; kwargs...)
 end
 
 function Base.isapprox(
-    d_ad::Tangent{P, <:NamedTuple{T}}, d_fd::Tangent{P, <:NamedTuple{T}}; kwargs...,
-) where {P, T}
+    d_ad::Tangent{P,<:NamedTuple{T}}, d_fd::Tangent{P,<:NamedTuple{T}}; kwargs...
+) where {P,T}
     return isapprox_vec(d_ad, d_fd; kwargs...)
 end
 
-
 # Must be for same primal
-Base.isapprox(d_ad::Tangent{P}, d_fd::Tangent{Q}; kwargs...) where {P, Q} = false
-
+Base.isapprox(d_ad::Tangent{P}, d_fd::Tangent{Q}; kwargs...) where {P,Q} = false
 
 # From when primal and tangent was passed as a tuple
 @deprecate(

src/finite_difference_calls.jl

@@ -19,12 +19,11 @@ function _make_jvp_call(fdm, f, y, xs, ẋs, ignores)
     f2 = _wrap_function(f, xs, ignores)
 
     ignores = collect(ignores)
-    all(ignores) && return ntuple(_->nothing, length(xs))
+    all(ignores) && return ntuple(_ -> nothing, length(xs))
     sigargs = zip(xs[.!ignores], ẋs[.!ignores])
     return _maybe_fix_to_composite(y, jvp(fdm, f2, sigargs...))
 end
 
-
 """
     _make_j′vp_call(fdm, f, ȳ, xs, ignores) -> Tuple
 
@@ -89,10 +88,9 @@ function _wrap_function(f, xs, ignores)
     return fnew
 end
 
-
 # TODO: remove after https://github.com/JuliaDiff/FiniteDifferences.jl/issues/97
 # For functions which return a tuple, FD returns a tuple to represent the differential. Tuple
 # is not a natural differential, because it doesn't overload +, so make it a Tangent.
 _maybe_fix_to_composite(::P, x::Tuple) where {P} = Tangent{P}(x...)
-_maybe_fix_to_composite(::P, x::NamedTuple) where {P} = Tangent{P}(;x...)
+_maybe_fix_to_composite(::P, x::NamedTuple) where {P} = Tangent{P}(; x...)
 _maybe_fix_to_composite(::Any, x) = x

src/testers.jl

@@ -60,13 +60,12 @@ function test_scalar(f, z; rtol=1e-9, atol=1e-9, fdm=_fdm, fkwargs=NamedTuple(),
             Δv = one(Ω) * im
             @testset "with cotangent $Δv" begin
                 # check ∂v_∂x and (if z is complex) ∂v_∂y via reverse mode
-                test_rrule(f, z ⊢ Δx; output_tangent=Δv,  rule_test_kwargs...)
+                test_rrule(f, z ⊢ Δx; output_tangent=Δv, rule_test_kwargs...)
             end
         end
     end  # top-level testset
 end
 
-
 """
     test_frule(f, inputs...; kwargs...)
 
@@ -87,12 +86,15 @@ end
    - All remaining keyword arguments are passed to `isapprox`.
 """
 function test_frule(
-    f, inputs...;
+    f,
+    inputs...;
     output_tangent=Auto(),
     fdm=_fdm,
     check_inferred::Bool=true,
     fkwargs::NamedTuple=NamedTuple(),
-    rtol::Real=1e-9, atol::Real=1e-9, kwargs...
+    rtol::Real=1e-9,
+    atol::Real=1e-9,
+    kwargs...,
 )
     # To simplify some of the calls we make later lets group the kwargs for reuse
     isapprox_kwargs = (; rtol=rtol, atol=atol, kwargs...)
@@ -114,12 +116,12 @@ function test_frule(
         check_equal(Ω_ad, Ω; isapprox_kwargs...)
 
         # TODO: remove Nothing when https://github.com/JuliaDiff/ChainRulesTestUtils.jl/issues/113
-        ẋs_is_ignored = isa.(ẋs, Union{Nothing, NoTangent})
+        ẋs_is_ignored = isa.(ẋs, Union{Nothing,NoTangent})
         if any(ẋs .== nothing)
             Base.depwarn(
                 "test_frule(f, k ⊢ nothing) is deprecated, use " *
                 "test_frule(f, k ⊢ NoTangent()) instead for non-differentiable ks",
-                :test_frule
+                :test_frule,
             )
         end
 
@@ -132,8 +134,6 @@ function test_frule(
     end  # top-level testset
 end
 
-
-
 """
     test_rrule(f, inputs...; kwargs...)
 
@@ -154,12 +154,15 @@ end
  - All remaining keyword arguments are passed to `isapprox`.
 """
 function test_rrule(
-    f, inputs...;
+    f,
+    inputs...;
     output_tangent=Auto(),
     fdm=_fdm,
     check_inferred::Bool=true,
     fkwargs::NamedTuple=NamedTuple(),
-    rtol::Real=1e-9, atol::Real=1e-9, kwargs...
+    rtol::Real=1e-9,
+    atol::Real=1e-9,
+    kwargs...,
 )
     # To simplify some of the calls we make later lets group the kwargs for reuse
     isapprox_kwargs = (; rtol=rtol, atol=atol, kwargs...)
@@ -191,22 +194,22 @@ function test_rrule(
 
         # Correctness testing via finite differencing.
         # TODO: remove Nothing when https://github.com/JuliaDiff/ChainRulesTestUtils.jl/issues/113
-        x̄s_is_dne = isa.(accumulated_x̄, Union{Nothing, NoTangent})
+        x̄s_is_dne = isa.(accumulated_x̄, Union{Nothing,NoTangent})
         if any(accumulated_x̄ .== nothing)
             Base.depwarn(
                 "test_rrule(f, k ⊢ nothing) is deprecated, use " *
                 "test_rrule(f, k ⊢ NoTangent()) instead for non-differentiable ks",
-                :test_rrule
+                :test_rrule,
             )
         end
 
         x̄s_fd = _make_j′vp_call(fdm, (xs...) -> f(xs...; fkwargs...), ȳ, xs, x̄s_is_dne)
         for (accumulated_x̄, x̄_ad, x̄_fd) in zip(accumulated_x̄, x̄s_ad, x̄s_fd)
-            if accumulated_x̄ isa Union{Nothing, NoTangent}  # then we marked this argument as not differentiable # TODO remove once #113
+            if accumulated_x̄ isa Union{Nothing,NoTangent}  # then we marked this argument as not differentiable # TODO remove once #113
                 @assert x̄_fd === nothing  # this is how `_make_j′vp_call` works
                 x̄_ad isa ZeroTangent && error(
                     "The pullback in the rrule for $f function should use NoTangent()" *
-                    " rather than ZeroTangent() for non-perturbable arguments."
+                    " rather than ZeroTangent() for non-perturbable arguments.",
                 )
                 @test x̄_ad isa NoTangent  # we said it wasn't differentiable.
             else
@@ -224,8 +227,8 @@ end
 
 function check_thunking_is_appropriate(x̄s)
     @testset "Don't thunk only non_zero argument" begin
-        num_zeros = count(x->x isa AbstractZero, x̄s)
-        num_thunks = count(x->x isa Thunk, x̄s)
+        num_zeros = count(x -> x isa AbstractZero, x̄s)
+        num_thunks = count(x -> x isa Thunk, x̄s)
         if num_zeros + num_thunks == length(x̄s)
             @test num_thunks !== 1
         end
@@ -235,12 +238,10 @@ end
 function _ensure_not_running_on_functor(f, name)
     # if x itself is a Type, then it is a constructor, thus not a functor.
     # This also catchs UnionAll constructors which have a `:var` and `:body` fields
-    f isa Type && return
+    f isa Type && return nothing
 
     if fieldcount(typeof(f)) > 0
-        throw(ArgumentError(
-            "$name cannot be used on closures/functors (such as $f)"
-        ))
+        throw(ArgumentError("$name cannot be used on closures/functors (such as $f)"))
     end
 end