More xrefs (#133)

* Add more xrefs

* Fix some typos

* Update docs/src/index.md

Co-Authored-By: Lyndon White <oxinabox@ucc.asn.au>

Co-authored-by: Lyndon White <oxinabox@ucc.asn.au>

Author: nickrobinson251

docs/src/index.md

@@ -33,7 +33,7 @@ Knowing rules for more complicated functions speeds up the autodiff process as i
 !!! terminology "`frule` and `rrule`"
     `frule` and `rrule` are ChainRules specific terms.
     Their exact functioning is fairly ChainRules specific, though other tools have similar functions.
-    The core notion is sometimes called _custom AD primitives_, _custom adjoints_, _custom_gradients_, _custom sensitivities_.
+    The core notion is sometimes called _custom AD primitives_, _custom adjoints_, _custom gradients_, _custom sensitivities_.
 
 The rules are encoded as `frule`s and `rrule`s, for use in forward-mode and reverse-mode differentiation respectively.
 
@@ -63,7 +63,8 @@ end
 where again `y = foo(args; kwargs...)`,
 and `∂Y` is the result of propagating the derivative information forwards at that point.
 This propagation is call the pushforward.
-One could think of writing `∂Y = pushforward(Δself, Δargs)`, and often we will think of the `frule` as having the primal computation `y = foo(args...; kwargs...)`, and the push-forward `∂Y = pushforward(Δself, Δargs...)`
+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.
 
 
 !!! note "Why `rrule` returns a pullback but `frule` doesn't return a pushforward"
@@ -228,9 +229,9 @@ Similarly every `pullback` returns an extra `∂self`, which for things without
 
 ### Pullback/Pushforward and Directional Derivative/Gradient
 
-The most trivial use of the `pushforward` from within `frule` is to calculate the directional derivative:
+The most trivial use of the `pushforward` from within `frule` is to calculate the [directional derivative](https://en.wikipedia.org/wiki/Directional_derivative):
 
-If we would like to know the the directional derivative of `f` for an input change of `(1.5, 0.4, -1)`
+If we would like to know the directional derivative of `f` for an input change of `(1.5, 0.4, -1)`
 
 ```julia
 direction = (1.5, 0.4, -1) # (ȧ, ḃ, ċ)
@@ -244,7 +245,7 @@ y, ∂y_∂b = frule((Zero(), 0, 1, 0), f, a, b, c)
 y, ∂y_∂c = frule((Zero(), 0, 0, 1), f, a, b, c)
 ```
 
-Similarly, the most trivial use of `rrule` and returned `pullback` is to calculate the [Gradient](https://en.wikipedia.org/wiki/Gradient):
+Similarly, the most trivial use of `rrule` and returned `pullback` is to calculate the [gradient](https://en.wikipedia.org/wiki/Gradient):
 
 ```julia
 y, f_pullback = rrule(f, a, b, c)
@@ -259,20 +260,20 @@ And we thus have the partial derivatives ``\overline{\mathrm{self}}, = \dfrac{
 The values that come back from pullbacks or pushforwards are not always the same type as the input/outputs of the primal function.
 They are differentials, which correspond roughly to something able to represent the difference between two values of the primal types.
 A differential might be such a regular type, like a `Number`, or a `Matrix`, matching to the original type;
-or it might be one of the `AbstractDifferential` subtypes.
+or it might be one of the [`AbstractDifferential`](@ref ChainRulesCore.AbstractDifferential) subtypes.
 
 Differentials support a number of operations.
 Most importantly: `+` and `*`, which let them act as mathematical objects.
 
 The most important `AbstractDifferential`s when getting started are the ones about avoiding work:
 
- - `Thunk`: this is a deferred computation. A thunk is a [word for a zero argument closure](https://en.wikipedia.org/wiki/Thunk). A computation wrapped in a `@thunk` doesn't get evaluated until `unthunk` is called on the thunk. `unthunk` is a no-op on non-thunked inputs.
- - `One`, `Zero`: There are special representations of `1` and `0`. They do great things around avoiding expanding `Thunks` in multiplication and (for `Zero`) addition.
+ - [`Thunk`](@ref): this is a deferred computation. A thunk is a [word for a zero argument closure](https://en.wikipedia.org/wiki/Thunk). A computation wrapped in a `@thunk` doesn't get evaluated until [`unthunk`](@ref) is called on the thunk. `unthunk` is a no-op on non-thunked inputs.
+ - [`One`](@ref), [`Zero`](@ref): There are special representations of `1` and `0`. They do great things around avoiding expanding `Thunks` in multiplication and (for `Zero`) addition.
 
 ### Other `AbstractDifferential`s:
- - `Composite{P}`: this is the differential for tuples and  structs. Use it like a `Tuple` or `NamedTuple`. The type parameter `P` is for the primal type.
- - `DoesNotExist`: Zero-like, represents that the operation on this input is not differentiable. Its primal type is normally `Integer` or `Bool`.
- - `InplaceableThunk`: it is like a `Thunk` but it can do in-place `add!`.
+ - [`Composite{P}`](@ref Composite): this is the differential for tuples and  structs. Use it like a `Tuple` or `NamedTuple`. The type parameter `P` is for the primal type.
+ - [`DoesNotExist`](@ref): Zero-like, represents that the operation on this input is not differentiable. Its primal type is normally `Integer` or `Bool`.
+ - [`InplaceableThunk`](@ref): it is like a `Thunk` but it can do in-place `add!`.
 
  -------------------------------