Start with the generic part on actions.

Author: kellertuer

src/plans/debug.jl

@@ -27,7 +27,7 @@ The original options can still be accessed using the [`get_state`](@ref) functio
 # Fields
 
 * `options`:         the options that are extended by debug information
-* `debugDictionary`: a `Dict{Symbol,DebugAction}` to keep track of Debug for different actions
+* `debug_dictionary`: a `Dict{Symbol,DebugAction}` to keep track of Debug for different actions
 
 # Constructors
     DebugSolverState(o,dA)
@@ -40,7 +40,7 @@ construct debug decorated options, where `dD` can be
 """
 mutable struct DebugSolverState{S <: AbstractManoptSolverState} <: AbstractManoptSolverState
     state::S
-    debugDictionary::Dict{Symbol, <:DebugAction}
+    debug_dictionary::Dict{Symbol, <:DebugAction}
     function DebugSolverState{S}(
             st::S, dA::Dict{Symbol, <:DebugAction}
         ) where {S <: AbstractManoptSolverState}
@@ -75,10 +75,10 @@ end
 """
     set_parameter!(ams::DebugSolverState, ::Val{:Debug}, args...)
 
-Set certain values specified by `args...` into the elements of the `debugDictionary`
+Set certain values specified by `args...` into the elements of the `debug_dictionary`
 """
 function set_parameter!(dss::DebugSolverState, ::Val{:Debug}, args...)
-    for d in values(dss.debugDictionary)
+    for d in values(dss.debug_dictionary)
         set_parameter!(d, args...)
     end
     return dss
@@ -96,17 +96,19 @@ function get_parameter(dss::DebugSolverState, v::Val{T}, args...) where {T}
 end
 
 function status_summary(dst::DebugSolverState)
-    if length(dst.debugDictionary) > 0
+    if length(dst.debug_dictionary) > 0
         s = ""
-        for (k, v) in dst.debugDictionary
+        for (k, v) in dst.debug_dictionary
             s = "$s\n    :$k = $(status_summary(v))"
         end
         return "$(status_summary(dst.state))\n\n## Debug$s"
     else # if the dictionary has no entries, there is no actual debug in pretty print
         return status_summary(dst.state)
     end
 end
-
+function show(io::IO, dst::DebugSolverState)
+    return print(io, "DebugSolverState($(dst.state), $(dst.debug_dictionary))")
+end
 
 dispatch_state_decorator(::DebugSolverState) = Val(true)
 
@@ -391,7 +393,7 @@ end
 function show(io::IO, di::DebugDivider)
     return print(io, "DebugDivider(; divider=\"$(escape_string(di.divider))\", at_init=$(di.at_init))")
 end
-status_summary(di::DebugDivider) = "\"$(escape_string(di.divider))\""
+status_summary(di::DebugDivider; inline = true) = (inline ? "\"$(escape_string(di.divider))\"" : "A Debug printing the String “$(escape_string(di.divider))” as a divider.")
 
 @doc """
     DebugEntry <: DebugAction

src/plans/solver_state.jl

@@ -313,6 +313,11 @@ for example within the [`DebugSolverState`](@ref) or within the [`RecordSolverSt
 """
 abstract type AbstractStateAction end
 
+status_summary(asa::AbstractStateAction; inline = true) = repr(asa)
+status_summary(io::IO, asa::AbstractStateAction; inline = true) = show(io, status_summary(asa; inline = inline))
+
+Base.show(io::IO, ::MIME"text/plain", asa::AbstractStateAction) = status_summary(io::IO, asa; inline = false)
+
 mutable struct StorageRef{T}
     x::T
 end

src/solvers/debug_solver.jl

@@ -26,9 +26,9 @@ Extend the `i`th step of the solver by a hook to run debug prints,
 that were added to the `:BeforeIteration` and `:Iteration` entries of the debug lists.
 """
 function step_solver!(amp::AbstractManoptProblem, dss::DebugSolverState, k)
-    get(dss.debugDictionary, :BeforeIteration, DebugDivider(""))(amp, get_state(dss), k)
+    get(dss.debug_dictionary, :BeforeIteration, DebugDivider(""))(amp, get_state(dss), k)
     step_solver!(amp, dss.state, k)
-    get(dss.debugDictionary, :Iteration, DebugDivider(""))(amp, get_state(dss), k)
+    get(dss.debug_dictionary, :Iteration, DebugDivider(""))(amp, get_state(dss), k)
     return dss
 end
 

src/solvers/gradient_descent.jl

@@ -103,7 +103,7 @@ function Base.show(io::IO, gds::GradientDescentState)
     )
 end
 
-function status_summary(gds::GradientDescentState)
+function status_summary(gds::GradientDescentState; inline = false)
     i = get_count(gds, :Iterations)
     Iter = (i > 0) ? "After $i iterations\n" : ""
     Conv = indicates_convergence(gds.stop) ? "Yes" : "No"
@@ -117,7 +117,8 @@ function status_summary(gds::GradientDescentState)
     $(gds.stepsize)
 
     ## Stopping criterion
-    $(status_summary(gds.stop))
+    $(status_summary(gds.stop; inline = true))
+
     This indicates convergence: $Conv"""
     return s
 end

test/plans/test_debug.jl

@@ -8,6 +8,8 @@ function ManifoldsBase.default_inverse_retraction_method(::TestPolarManifold)
 end
 
 struct TestDebugAction <: DebugAction end
+Base.show(io::IO, ::TestDebugAction) = print(io, "TestDebugAction()")
+
 
 struct TestMessageState <: AbstractManoptSolverState end
 Manopt.get_message(::TestMessageState) = "DebugTest"
@@ -34,18 +36,25 @@ Manopt.get_parameter(d::TestDebugParameterState, ::Val{:value}) = d.value
         )
         f(M, q) = distance(M, q, p) .^ 2
         grad_f(M, q) = -2 * log(M, q, p)
-        # summary fallback to show
+        tda = TestDebugAction()
+        # summary fallback to show - inherited from AbstractStateAction(s)
         @test Manopt.status_summary(TestDebugAction()) === "TestDebugAction()"
+        show(io, tda)
+        @test String(take!(io)) === "TestDebugAction()"
         mp = DefaultManoptProblem(M, ManifoldGradientObjective(f, grad_f))
         a1 = DebugDivider("|"; io = io)
-        @test Manopt.dispatch_state_decorator(DebugSolverState(st, a1)) === Val{true}()
+        dst = DebugSolverState(st, a1)
+        @test Manopt.dispatch_state_decorator(dst) === Val{true}()
         # constructors
-        @test DebugSolverState(st, a1).debugDictionary[:Iteration] == a1
-        @test DebugSolverState(st, [a1]).debugDictionary[:Iteration].group[1] == a1
-        @test DebugSolverState(st, Dict(:A => a1)).debugDictionary[:A] == a1
-        @test DebugSolverState(st, ["|"]).debugDictionary[:Iteration].divider == a1.divider
-        @test endswith(repr(DebugSolverState(st, a1)), "\"|\"")
-        @test repr(DebugSolverState(st, Dict{Symbol, DebugAction}())) == repr(st)
+        @test DebugSolverState(st, a1).debug_dictionary[:Iteration] == a1
+        @test DebugSolverState(st, [a1]).debug_dictionary[:Iteration].group[1] == a1
+        @test DebugSolverState(st, Dict(:A => a1)).debug_dictionary[:A] == a1
+        @test DebugSolverState(st, ["|"]).debug_dictionary[:Iteration].divider == a1.divider
+        @test endswith(Manopt.status_summary(dst), "\"|\"")
+        @test Manopt.status_summary(a1; inline = true) == "\"|\""
+        @test Manopt.status_summary(a1; inline = false) == "A Debug printing the String “|” as a divider."
+        empty_dbg = Dict{Symbol, DebugAction}()
+        @test repr(DebugSolverState(st, empty_dbg)) == "DebugSolverState($(repr(st)), $(repr(empty_dbg)))"
         # Passthrough
         dss = DebugSolverState(st, a1)
         Manopt.set_parameter!(dss, :StoppingCriterion, :MaxIteration, 20)