Fix indents

Author: abhro

docs/src/design/changing_the_primal.md

@@ -148,8 +148,8 @@ x̄ = pullback_at(f, x, y, ȳ, intermediates)
 ```
 ```julia
 function augmented_primal(::typeof(sin), x)
-  y, cx = sincos(x)
-  return y, (; cx=cx)  # use a NamedTuple for the intermediates
+    y, cx = sincos(x)
+    return y, (; cx=cx)  # use a NamedTuple for the intermediates
 end
 
 pullback_at(::typeof(sin), x, y, ȳ, intermediates) = ȳ * intermediates.cx
@@ -163,9 +163,9 @@ pullback_at(::typeof(sin), x, y, ȳ, intermediates) = ȳ * intermediates.cx
 ```
 ```julia
 function augmented_primal(::typeof(σ), x)
-  ex = exp(x)
-  y = ex / (1 + ex)
-  return y, (; ex=ex)  # use a NamedTuple for the intermediates
+    ex = exp(x)
+    y = ex / (1 + ex)
+    return y, (; ex=ex)  # use a NamedTuple for the intermediates
 end
 
 pullback_at(::typeof(σ), x, y, ȳ, intermediates) = ȳ * y / (1 + intermediates.ex)
@@ -189,8 +189,8 @@ And storing all these things on the tape — inputs, outputs, sensitivities, int
 What if we generalized the idea of the `intermediate` named tuple, and had `augmented_primal` return a struct that just held anything we might want put on the tape.
 ```julia
 struct PullbackMemory{P, S}
-  primal_function::P
-  state::S
+    primal_function::P
+    state::S
 end
 # convenience constructor:
 PullbackMemory(primal_function; state...) = PullbackMemory(primal_function, state)
@@ -211,8 +211,8 @@ which is much cleaner.
 ```
 ```julia
 function augmented_primal(::typeof(sin), x)
-  y, cx = sincos(x)
-  return y, PullbackMemory(sin; cx=cx)
+    y, cx = sincos(x)
+    return y, PullbackMemory(sin; cx=cx)
 end
 
 pullback_at(pb::PullbackMemory{typeof(sin)}, ȳ) = ȳ * pb.cx
@@ -226,9 +226,9 @@ pullback_at(pb::PullbackMemory{typeof(sin)}, ȳ) = ȳ * pb.cx
 ```
 ```julia
 function augmented_primal(::typeof(σ), x)
-  ex = exp(x)
-  y = ex / (1 + ex)
-  return y, PullbackMemory(σ; y=y, ex=ex)
+    ex = exp(x)
+    y = ex / (1 + ex)
+    return y, PullbackMemory(σ; y=y, ex=ex)
 end
 
 pullback_at(pb::PullbackMemory{typeof(σ)}, ȳ) = ȳ * pb.y / (1 + pb.ex)
@@ -256,8 +256,8 @@ x̄ = pb(ȳ)
 ```
 ```julia
 function augmented_primal(::typeof(sin), x)
-  y, cx = sincos(x)
-  return y, PullbackMemory(sin; cx=cx)
+    y, cx = sincos(x)
+    return y, PullbackMemory(sin; cx=cx)
 end
 (pb::PullbackMemory{typeof(sin)})(ȳ) = ȳ * pb.cx
 ```
@@ -271,9 +271,9 @@ end
 ```
 ```julia
 function augmented_primal(::typeof(σ), x)
-  ex = exp(x)
-  y = ex / (1 + ex)
-  return y, PullbackMemory(σ; y=y, ex=ex)
+    ex = exp(x)
+    y = ex / (1 + ex)
+    return y, PullbackMemory(σ; y=y, ex=ex)
 end
 
 (pb::PullbackMemory{typeof(σ)})(ȳ) = ȳ * pb.y / (1 + pb.ex)
@@ -295,16 +295,16 @@ Let's go back and think about the changes we would have make to go from our orig
 To rewrite that original formulation in the new pullback form we have:
 ```julia
 function augmented_primal(::typeof(sin), x)
-  y = sin(x)
-  return y, PullbackMemory(sin; x=x)
+    y = sin(x)
+    return y, PullbackMemory(sin; x=x)
 end
 (pb::PullbackMemory)(ȳ) = ȳ * cos(pb.x)
 ```
 To go from that to:
 ```julia
 function augmented_primal(::typeof(sin), x)
-  y, cx = sincos(x)
-  return y, PullbackMemory(sin; cx=cx)
+    y, cx = sincos(x)
+    return y, PullbackMemory(sin; cx=cx)
 end
 (pb::PullbackMemory)(ȳ) = ȳ * pb.cx
 ```
@@ -317,17 +317,17 @@ end
 ```
 ```julia
 function augmented_primal(::typeof(σ), x)
-  y = σ(x)
-  return y, PullbackMemory(σ; y=y, x=x)
+    y = σ(x)
+    return y, PullbackMemory(σ; y=y, x=x)
 end
 (pb::PullbackMemory{typeof(σ)})(ȳ) = ȳ * pb.y * σ(-pb.x)
 ```
 to get to:
 ```julia
 function augmented_primal(::typeof(σ), x)
-  ex = exp(x)
-  y = ex/(1 + ex)
-  return y, PullbackMemory(σ; y=y, ex=ex)
+    ex = exp(x)
+    y = ex/(1 + ex)
+    return y, PullbackMemory(σ; y=y, ex=ex)
 end
 (pb::PullbackMemory{typeof(σ)})(ȳ) = ȳ * pb.y/(1 + pb.ex)
 ```
@@ -356,9 +356,9 @@ Replacing `PullbackMemory` with a closure that works the same way lets us avoid
 ```
 ```julia
 function augmented_primal(::typeof(sin), x)
-  y, cx = sincos(x)
-  pb = ȳ -> cx * ȳ  # pullback closure. closes over `cx`
-  return y, pb
+    y, cx = sincos(x)
+    pb = ȳ -> cx * ȳ  # pullback closure. closes over `cx`
+    return y, pb
 end
 ```
 ```@raw html
@@ -370,10 +370,10 @@ end
 ```
 ```julia
 function augmented_primal(::typeof(σ), x)
-  ex = exp(x)
-  y = ex / (1 + ex)
-  pb = ȳ -> ȳ * y / (1 + ex)  # pullback closure. closes over `y` and `ex`
-  return y, pb
+    ex = exp(x)
+    y = ex / (1 + ex)
+    pb = ȳ -> ȳ * y / (1 + ex)  # pullback closure. closes over `y` and `ex`
+    return y, pb
 end
 ```
 ```@raw html

src/rule_definition_tools.jl

@@ -124,11 +124,11 @@ end
     _normalize_scalarrules_macro_input(call, maybe_setup, partials)
 
 returns (in order) the correctly escaped:
-    - `call` with out any type constraints
-    - `setup_stmts`: the content of `@setup` or `[]` if that is not provided,
-    -  `inputs`: with all args having the constraints removed from call, or
-        defaulting to `Number`
-    - `partials`: which are all `Expr{:tuple,...}`
+- `call` with out any type constraints
+- `setup_stmts`: the content of `@setup` or `[]` if that is not provided,
+-  `inputs`: with all args having the constraints removed from call, or
+    defaulting to `Number`
+- `partials`: which are all `Expr{:tuple,...}`
 """
 function _normalize_scalarrules_macro_input(call, maybe_setup, partials)
     # Setup: normalizing input form etc
@@ -286,7 +286,7 @@ Returns the expression for the propagation of
 the input gradient `Δs` though the partials `∂s`.
 Specify `_conj = true` to conjugate the partials.
 Projector `proj` is a function that will be applied at the end;
-    for `rrules` it is usually a `ProjectTo(x)`, for `frules` it is `identity`
+for `rrules` it is usually a `ProjectTo(x)`, for `frules` it is `identity`
 """
 function propagation_expr(Δs, ∂s, _conj=false, proj=identity)
     # This is basically Δs ⋅ ∂s

src/rules.jl

@@ -169,7 +169,7 @@ note: when the text below says methods `==` it actually means:
 
 To decide if should opt-out using this mechanism.
  - find the most specific method of `rrule` and `no_rule` e.g with `Base.which`
-  - if the method of `no_rrule` `==` the method of `rrule`, then should opt-out
+ - if the method of `no_rrule` `==` the method of `rrule`, then should opt-out
 
 To just ignore the fact that rules can be opted-out from, and that some rules thus return
 `nothing`, then filter the list of methods of `rrule` to remove those that are `==` to ones