Add headers in docstrings

Author: abhro

src/config.jl

@@ -31,15 +31,15 @@ Base.Broadcast.broadcastable(config::RuleConfig) = Ref(config)
 abstract type ReverseModeCapability end
 
 """
-HasReverseMode
+    HasReverseMode <: ReverseModeCapability
 
 This trait indicates that a `RuleConfig{>:HasReverseMode}` can perform reverse mode AD.
 If it is set then [`rrule_via_ad`](@ref) must be implemented.
 """
 struct HasReverseMode <: ReverseModeCapability end
 
 """
-NoReverseMode
+    NoReverseMode <: ReverseModeCapability
 
 This is the complement to [`HasReverseMode`](@ref). To avoid ambiguities [`RuleConfig`]s
 that do not support performing reverse mode AD should be `RuleConfig{>:NoReverseMode}`.
@@ -49,15 +49,15 @@ struct NoReverseMode <: ReverseModeCapability end
 abstract type ForwardsModeCapability end
 
 """
-HasForwardsMode
+    HasForwardsMode <: ForwardsModeCapability
 
 This trait indicates that a `RuleConfig{>:HasForwardsMode}` can perform forward mode AD.
 If it is set then [`frule_via_ad`](@ref) must be implemented.
 """
 struct HasForwardsMode <: ForwardsModeCapability end
 
 """
-NoForwardsMode
+    NoForwardsMode <: ForwardsModeCapability
 
 This is the complement to [`HasForwardsMode`](@ref). To avoid ambiguities [`RuleConfig`]s
 that do not support performing forwards mode AD should be `RuleConfig{>:NoForwardsMode}`.

src/rule_definition_tools.jl

@@ -269,10 +269,18 @@ end
 
 # For context on why this is important, see
 # https://github.com/JuliaDiff/ChainRulesCore.jl/pull/276
-"Declares properly hygenic inputs for propagation expressions"
+"""
+    _propagator_inputs(n)
+
+Declares properly hygenic inputs for propagation expressions
+"""
 _propagator_inputs(n) = [esc(gensym(Symbol(:Δ, i))) for i in 1:n]
 
-"given the variable names, escaped but without types, makes setup expressions for projection operators"
+"""
+    _make_projectors(xs)
+
+Given the variable names, escaped but without types, makes setup expressions for projection operators
+"""
 function _make_projectors(xs)
     projs = map(x -> Symbol(:proj_, x.args[1]), xs)
     setups = map((x, p) -> :($p = ProjectTo($x)), xs, projs)
@@ -393,7 +401,11 @@ macro non_differentiable(sig_expr)
     end
 end
 
-"changes `f(x,y)` into `f(x,y; kwargs....)`"
+"""
+    _with_kwargs_expr(call_expr, kwargs)
+
+Changes `f(x,y)` into `f(x,y; kwargs....)`
+"""
 function _with_kwargs_expr(call_expr::Expr, kwargs)
     @assert isexpr(call_expr, :call)
     return Expr(
@@ -584,7 +596,9 @@ function _isvararg(expr::Expr)
 end
 
 """
-splits the first arg of the `call` expression into an expression to use in the signature
+    _split_primal_name(primal_name)
+
+Splits the first arg of the `call` expression into an expression to use in the signature
 and one to use for calling that function
 """
 function _split_primal_name(primal_name)
@@ -604,15 +618,23 @@ function _split_primal_name(primal_name)
     end
 end
 
-"turn both `a` and `a::S` into `a`"
+"""
+    _unconstrain(a)
+
+Turn both `a` and `a::S` into `a`
+"""
 _unconstrain(arg::Symbol) = arg
 function _unconstrain(arg::Expr)
     Meta.isexpr(arg, :(::), 2) && return arg.args[1]  # drop constraint.
     Meta.isexpr(arg, :(...), 1) && return _unconstrain(arg.args[1])
     return error("malformed arguments: $arg")
 end
 
-"turn both `a` and `::constraint` into `a::constraint` etc"
+"""
+    _constrain_and_name(arg::Expr, _)
+
+Turn both `a` and `::constraint` into `a::constraint` etc
+"""
 function _constrain_and_name(arg::Expr, _)
     Meta.isexpr(arg, :(::), 2) && return arg  # it is already fine.
     Meta.isexpr(arg, :(::), 1) && return Expr(:(::), gensym(), arg.args[1]) # add name

src/tangent_types/abstract_tangent.jl

@@ -3,6 +3,8 @@
 #####
 
 """
+    AbstractTangent
+
 The subtypes of `AbstractTangent` define a custom \"algebra\" for chain
 rule evaluation that attempts to factor various features like complex derivative
 support, broadcast fusion, zero-elision, etc. into nicely separated parts.
@@ -40,4 +42,4 @@ Base.:+(x::AbstractTangent) = x
 @inline Base.conj(x::AbstractTangent) = x
 
 Base.:/(x::AbstractTangent, y) = x * inv(y)
-Base.:\(x, y::AbstractTangent) = inv(x) * y
+Base.:\(x, y::AbstractTangent) = inv(x) * y

src/tangent_types/thunks.jl

@@ -162,6 +162,7 @@ Base.transpose(x::AbstractThunk) = @thunk(transpose(unthunk(x)))
 
 """
     Thunk(()->v)
+
 A thunk is a deferred computation.
 It wraps a zero argument closure that when invoked returns a tangent.
 `@thunk(v)` is a macro that expands into `Thunk(()->v)`.