Fix a few typos (#603)

Author: pitmonticone

docs/src/ad_author/use_in_ad_system.md

@@ -12,12 +12,12 @@ There are 3 main ways to access ChainRules rule sets in your AutoDiff system.
     - 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`
+2. Source code transform based on inserting branches that check of `rrule`/`frule` return `nothing`
     - 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.
+    - In theory type inference optimizes these branches 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
     - 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 is pretty hardcore even by the standard of source code tranformations.
+    - This is pretty hardcore even by the standard of source code transformations.

docs/src/index.md

@@ -90,7 +90,7 @@ end
 where `y = foo(args; kwargs...)` is the primal output, and `∂Y` is the result of propagating the input tangents `Δself`, `Δargs...` forwards at the point in the domain of `foo` described by `args`.
 This propagation is called the pushforward.
 Often we will think of the `frule` as having the primal computation `y = foo(args...; kwargs...)`, and the pushforward `∂Y = pushforward(Δself, Δargs...)`,
-even though they are not present in seperate forms in the code.
+even though they are not present in separate forms in the code.
 
 For example, the `frule` for `sin(x)` is:
 ```julia
@@ -146,7 +146,7 @@ Vector, matrix, and higher rank tensor primals can be represented by vector, mat
 ChainRules defines a [`Tangent`](@ref) tangent type to represent tangents of `struct`s, `Tuple`s, `NamedTuple`s, and `Dict`s.
 
 Additionally, for signalling semantics, we distinguish between two tangent types representing a zero tangent.
-[`NoTangent`](@ref) type represent situtations in which the tangent space does not exist, e.g. an index into an array can not be perturbed.
+[`NoTangent`](@ref) type represent situations in which the tangent space does not exist, e.g. an index into an array can not be perturbed.
 [`ZeroTangent`](@ref) is used for cases where the tangent happens to be zero, e.g. because the primal argument is not used in the computation.
 
 We also define [`Thunk`](@ref)s to allow certain optimisation.

docs/src/rule_author/tangents.md

@@ -21,7 +21,7 @@ Further they often support other linear operators for convenience in writing rul
 
 ## The subtypes of AbstractTangent
 
-Not all tangents need to subtype the AbstractTangent type -- infact most don't: most are just numbers or arrays -- but ChainRulesCore does provide a number of special tangent types that can be very useful. 
+Not all tangents need to subtype the AbstractTangent type -- in fact most don't: most are just numbers or arrays -- but ChainRulesCore does provide a number of special tangent types that can be very useful. 
 
  - [`ZeroTangent`](@ref): It is a special representation of `0`. It does great things around avoiding expanding `Thunks` in addition.
  - [`NoTangent`](@ref): Zero-like, represents that the operation on this input is not differentiable. Its primal type is normally `Integer` or `Bool`.

docs/src/rule_author/writing_good_rules.md

@@ -40,7 +40,7 @@ They should be used where possible.
 However, sometimes for performance reasons this is not ideal.
 Especially, if it is to replace a scalar, and is in a type-unstable way.
 It causes problems if mapping over such pullbacks/pushforwards.
-This woull be solved once [JuliaLang/julia#38241](https://github.com/JuliaLang/julia/issues/38241) has been addressed.
+This would be solved once [JuliaLang/julia#38241](https://github.com/JuliaLang/julia/issues/38241) has been addressed.
 
 ## Use `Thunk`s appropriately
 

docs/src/videos.md

@@ -2,7 +2,7 @@
 
 For people who learn better by video we have a number of videos of talks we have given about the ChainRules project.
 Note however, that the videos are frozen in time reflecting the state of the packages at the time they were recorded.
-This documentation is the continously updated canonical source.
+This documentation is the continuously updated canonical source.
 However, we have tried to note below each video notes on its correctness.
 
 The talks that follow are in reverse chronological order (i.e. most recent video is first).