Apply suggestions from code review

Co-authored-by: willtebbutt <wt0881@my.bristol.ac.uk>
Co-authored-by: Nick Robinson <npr251@gmail.com>

Author: 3 people

docs/src/autodiff/operator_overloading.md

@@ -1,17 +1,17 @@
 # Operator Overloading
 
-The principle interface for using the operator overload generation method is [`on_new_rule`](@ref).
+The principal interface for using the operator overload generation method is [`on_new_rule`](@ref).
 This function allows one to register a hook to be run every time a new rule is defined.
 The hook receives a signature type-type as input, and generally will use `eval` to define
-and overload of AD systems overloaded type.
-For example, using the signature type `Tuple{typeof(+), Real, Real}` to define 
-`+(::DualNumber, ::DualNumber)` as calling the `frule` for `+`.
+an overload of an AD system's overloaded type.
+For example, using the signature type `Tuple{typeof(+), Real, Real}` to make 
+`+(::DualNumber, ::DualNumber)` call the `frule` for `+`.
 A signature type tuple always has the form:
 `Tuple{typeof(operation), typeof{pos_arg1}, typeof{pos_arg2...}}`, where `pos_arg1` is the
 first positional argument.
-One can dispatch on the signature type, to make rules with argument types your AD does not support not call `eval`;
+One can dispatch on the signature type to make rules with argument types your AD does not support not call `eval`;
 or more simply you can just use conditions for this.
-The the hook is automatically triggered whenever a package is loaded.
+The hook is automatically triggered whenever a package is loaded.
 
 `refresh_rules`(@ref) is used to manually trigger the hook function on any new rules.
 This is useful for example if new rules are define in the REPL, or if a package defining rules is modified.
@@ -45,4 +45,3 @@ $(read(joinpath(@__DIR__,"../../../test/demos/reversediffzero.jl"), String))
 ```
 """)
 ````
-

docs/src/autodiff/overview.md

@@ -1,22 +1,22 @@
-# Using ChainRules in your AutoDiff system
+# Using ChainRules in your AD system
 
 This section is for authors of AD systems.
-It assumes a pretty solid understanding of Julia, and of automatic differentiation.
-It explains how to make use of ChainRule's rule sets,
+It assumes a pretty solid understanding of both Julia and automatic differentiation.
+It explains how to make use of ChainRule's "rulesets" ([`frule`](@ref)s, [`rrule`](@ref)s,)
 to avoid having to code all your own AD primitives / custom sensitives.
 
 There are 3 main ways to access ChainRules rule sets in your AutoDiff system.
 
 1. [Operation Overloading Generation](operator_overloading.html)
-    - This is primarily intended for operator overloading based AD systems which will generate overloads for primal function based for their overloaded types based on the existance of an `rrule`/`frule`.
+    - This is primarily intended for operator overloading based AD systems which will generate overloads for primal functions based for their overloaded types based on the existence of an `rrule`/`frule`.
     - A source code generation based AD can also use this by overloading their transform generating function directly so as not to recursively generate a transform but to just return the rule.
     - This does not play nice with Revise.jl, adding or modifying rules in loaded files will not be reflected until a manual refresh, and deleting rules will not be reflected at all.
 2. Source code tranform based on inserting branches that check of `rrule`/`frule` return `nothing`
-    - if the `rrule`/`frule` returns a rule result then use it, if it return `nothing` then do normal AD path 
+    - If the `rrule`/`frule` returns a rule result then use it, if it returns `nothing` then do normal AD path.
     - In theory type inference optimizes these branchs out; in practice it may not.
     - This is a fairly simple Cassette overdub (or similar) of all calls, and is suitable for overloading based AD or source code transformation.
 3. Source code transform based on `rrule`/`frule` method-table
-    - Always use `rrule`/`frule` iff and only if use the rules that exist, else generate normal AD path.
+    - If an applicable `rrule`/`frule` exists in the method table then use it, else generate normal AD path.
     - This avoids having branches in your generated code.
-    - This requires maintaining your own back-edges
+    - This requires maintaining your own back-edges.
     - This is pretty hard-code even by the standard of source code tranformations

src/ruleset_loading.jl

@@ -16,11 +16,11 @@ _hook_list(::typeof(frule)) = NEW_FRULE_HOOKS
 Register a `hook` function to run when new rules are defined.
 The hook receives a signature type-type as input, and generally will use `eval` to define
 and overload of AD systems overloaded type.
-For example, using the signature type `Tuple{typeof(+), Real, Real}` to define 
-`+(::DualNumber, ::DualNumber)` as calling the `frule` for `+`.
+For example, using the signature type `Tuple{typeof(+), Real, Real}` to make
+`+(::DualNumber, ::DualNumber)` call the `frule` for `+`.
 A signature type tuple always has the form:
 `Tuple{typeof(operation), typeof{pos_arg1}, typeof{pos_arg2...}}`, where `pos_arg1` is the
-first positional argument
+first positional argument.
 
 The hooks are automatically run on new rules whenever a package is loaded.
 They can be manually triggered by [`refresh_rules`](@ref).
@@ -74,7 +74,7 @@ last_refresh(::typeof(rrule)) = LAST_REFRESH_RRULE
 This triggers all [`on_new_rule`](@ref) hooks to run on any newly defined rules.
 It is *automatically* run when ever a package is loaded.
 It can also be manually called to run it directly, for example if a rule was defined
-in the REPL or with-in the same file as the AD function.
+in the REPL or within the same file as the AD function.
 """
 refresh_rules() = (refresh_rules(frule); refresh_rules(rrule))
 function refresh_rules(rule_kind)

test/demos/reversediffzero.jl

@@ -71,7 +71,7 @@ function define_tracked_overload(sig)
             y, y_pullback = rrule(args...; kwargs...)
             the_tape = get_tape(tracked_args)
             y_tracked = Tracked(y, the_tape) do ȳ
-                # pull this partial back and propagate it to the inputs partial stores
+                # pull this partial back and propagate it to the input's partial store
                 _, ārgs = Iterators.peel(y_pullback(ȳ))
                 accum!.(tracked_args, ārgs)
             end