remove reference to Rules from docstrings

Author: oxinabox

src/operations.jl

@@ -19,8 +19,8 @@ storing the result in `Δ`.
 Note: this function may not actually store the result in `Δ` if `Δ` is immutable,
 so it is best to always call this as `Δ = accumulate!(Δ, ∂)` just in-case.
 
-This function is overloadable by [`InplaceableThunk`s](@ref).
-See also: [`accumulate`](@ref), [`store!`](@ref), [`AbstractRule`](@ref)
+This function is overloadable by using a [`InplaceThunk`](@ref).
+See also: [`accumulate`](@ref), [`store!`](@ref).
 """
 function accumulate!(Δ, ∂)
     return materialize!(Δ, broadcastable(cast(Δ) + ∂))

src/rule_definition_tools.jl

@@ -151,7 +151,7 @@ is equivalent to:
 
 For examples, see ChainRulesCore' `rules` directory.
 
-See also: [`frule`](@ref), [`rrule`](@ref), [`AbstractRule`](@ref)
+See also: [`frule`](@ref), [`rrule`](@ref).
 """
 macro scalar_rule(call, maybe_setup, partials...)
     ############################################################################

src/rules.jl

@@ -4,7 +4,7 @@
 
 #=
 In some weird ideal sense, the fallback for e.g. `frule` should actually be "get
-the derivative via forward-mode AD". This is necessary to enable mixed-mode
+the derivative via forward-ode AD". This is necessary to enable mixed-mode
 rules, where e.g. `frule` is used within a `rrule` definition. For example,
 broadcasted functions may not themselves be forward-mode *primitives*, but are
 often forward-mode *differentiable*.
@@ -33,7 +33,7 @@ my_frule(args...) = Cassette.overdub(MyChainRuleCtx(), frule, args...)
 function Cassette.execute(::MyChainRuleCtx, ::typeof(frule), f, x::Number)
     r = frule(f, x)
     if isa(r, Nothing)
-        fx, df = (f(x), Rule(Δx -> ForwardDiff.derivative(f, x) * Δx))
+        fx, df = (f(x), (_, Δx) -> ForwardDiff.derivative(f, x) * Δx)
     else
         fx, df = r
     end
@@ -48,16 +48,12 @@ end
 Expressing `x` as the tuple `(x₁, x₂, ...)` and the output tuple of `f(x...)`
 as `Ω`, return the tuple:
 
-    (Ω, (rule_for_ΔΩ₁::AbstractRule, rule_for_ΔΩ₂::AbstractRule, ...))
+    (Ω, (ṡelf, ẋ₁, ẋ₂, ...) -> Ω̇₁, Ω̇₂, ...)
 
-where each returned propagation rule `rule_for_ΔΩᵢ` can be invoked as
+The second return value is the propagation rule, or the pushforward.
+It takes in differentials corresponding to the inputs (`ẋ₁, ẋ₂, ...`)
+and `ṡelf` the internal values of the function (for closures).
 
-    rule_for_ΔΩᵢ(Δx₁, Δx₂, ...)
-
-to yield `Ωᵢ`'s corresponding differential `ΔΩᵢ`. To illustrate, if all involved
-values are real-valued scalars, this differential can be written as:
-
-    ΔΩᵢ = ∂Ωᵢ_∂x₁ * Δx₁ + ∂Ωᵢ_∂x₂ * Δx₂ + ...
 
 If no method matching `frule(f, xs...)` has been defined, then return `nothing`.
 
@@ -68,12 +64,12 @@ unary input, unary output scalar function:
 ```
 julia> x = rand();
 
-julia> sinx, dsin = frule(sin, x);
+julia> sinx, sin_pushforward = frule(sin, x);
 
 julia> sinx == sin(x)
 true
 
-julia> dsin(1) == cos(x)
+julia> sin_pushforward(NamedTuple(), 1) == cos(x)
 true
 ```
 
@@ -82,19 +78,16 @@ unary input, binary output scalar function:
 ```
 julia> x = rand();
 
-julia> sincosx, (dsin, dcos) = frule(sincos, x);
+julia> sincosx, sincos_pushforward = frule(sincos, x);
 
 julia> sincosx == sincos(x)
 true
 
-julia> dsin(1) == cos(x)
-true
-
-julia> dcos(1) == -sin(x)
+julia> sincos_pushforward(NamedTuple(), 1) == (cos(x), -sin(x))
 true
 ```
 
-See also: [`rrule`](@ref), [`AbstractRule`](@ref), [`@scalar_rule`](@ref)
+See also: [`rrule`](@ref), [`@scalar_rule`](@ref)
 """
 frule(::Any, ::Vararg{Any}; kwargs...) = nothing
 
@@ -104,16 +97,11 @@ frule(::Any, ::Vararg{Any}; kwargs...) = nothing
 Expressing `x` as the tuple `(x₁, x₂, ...)` and the output tuple of `f(x...)`
 as `Ω`, return the tuple:
 
-    (Ω, (rule_for_Δx₁::AbstractRule, rule_for_Δx₂::AbstractRule, ...))
-
-where each returned propagation rule `rule_for_Δxᵢ` can be invoked as
+    (Ω, (Ω̄₁, Ω̄₂, ...) -> (s̄elf, x̄₁, x̄₂, ...))
 
-    rule_for_Δxᵢ(ΔΩ₁, ΔΩ₂, ...)
-
-to yield `xᵢ`'s corresponding differential `Δxᵢ`. To illustrate, if all involved
-values are real-valued scalars, this differential can be written as:
-
-    Δxᵢ = ∂Ω₁_∂xᵢ * ΔΩ₁ + ∂Ω₂_∂xᵢ * ΔΩ₂ + ...
+Where the second return value is the the propagation rule or pullback.
+It takes in differentials corresponding to the outputs (`x̄₁, x̄₂, ...`),
+and `s̄elf`, the internal values of the function itself (for closures)
 
 If no method matching `rrule(f, xs...)` has been defined, then return `nothing`.
 
@@ -124,12 +112,12 @@ unary input, unary output scalar function:
 ```
 julia> x = rand();
 
-julia> sinx, dx = rrule(sin, x);
+julia> sinx, sin_pullback = rrule(sin, x);
 
 julia> sinx == sin(x)
 true
 
-julia> dx(1) == cos(x)
+julia> sin_pullback(1) == (NO_FIELDS, cos(x))
 true
 ```
 
@@ -138,18 +126,15 @@ binary input, unary output scalar function:
 ```
 julia> x, y = rand(2);
 
-julia> hypotxy, (dx, dy) = rrule(hypot, x, y);
+julia> hypotxy, hypot_pullback = rrule(hypot, x, y);
 
 julia> hypotxy == hypot(x, y)
 true
 
-julia> dx(1) == (x / hypot(x, y))
-true
-
-julia> dy(1) == (y / hypot(x, y))
+julia> hypot_pullback(1) == (NO_FIELDS, (x / hypot(x, y)), (y / hypot(x, y)))
 true
 ```
 
-See also: [`frule`](@ref), [`AbstractRule`](@ref), [`@scalar_rule`](@ref)
+See also: [`frule`](@ref), [`@scalar_rule`](@ref)
 """
 rrule(::Any, ::Vararg{Any}; kwargs...) = nothing