A bit of code structuring and test the new scheme with GradientDescentState.

Author: kellertuer

src/plans/objective.jl

@@ -22,6 +22,15 @@ the type `T` indicates the global [`AbstractEvaluationType`](@ref).
 """
 abstract type AbstractManifoldObjective{E <: AbstractEvaluationType} end
 
+function Base.show(io::IO, ::MIME"text/plain", amo::AbstractManifoldObjective)
+    multiline = get(io, :multiline, true)
+    if multiline
+        return status_summary(io, amo)
+    else
+        show(io, amo)
+    end
+end
+
 @doc """
     AbstractDecoratedManifoldObjective{E<:AbstractEvaluationType,O<:AbstractManifoldObjective}
 

src/plans/plan.jl

@@ -1,16 +1,19 @@
 """
+    status_summary(io, e)
     status_summary(e)
 
-Return a string reporting about the current status of `e`,
-where `e` is a type from Manopt.
+Returns a string reporting about the current status of an element `e`
+defined in `Manopt.jl`, which can also directly be printed to an `IO` stream `io`.
 
-This method is similar to `show` but just returns a string.
-It might also be more verbose in explaining, or hide internal information.
+This method should generate a human readable summary of `e`,
+
+By default, the variant with an `IO` stream dispatches to the one without to generate
+a string and prints it to the `IO` stream.
 """
-function status_summary(e)
-    a = IOBuffer()
-    Base.show(a, MIME"text/plain"(), e)
-    return String(take!(a))
+function status_summary end
+
+function status_summary(io::IO, e)
+    return print(io, status_summary(e))
 end
 
 """

src/plans/problem.jl

@@ -17,6 +17,16 @@ Usually the cost should be within an [`AbstractManifoldObjective`](@ref).
 """
 abstract type AbstractManoptProblem{M <: AbstractManifold} end
 
+function Base.show(io::IO, ::MIME"text/plain", amp::AbstractManoptProblem)
+    multiline = get(io, :multiline, true)
+    if multiline
+        return status_summary(io, amp)
+    else
+        show(io, amp)
+    end
+end
+
+
 @doc """
     DefaultManoptProblem{TM <: AbstractManifold, Objective <: AbstractManifoldObjective}
 

src/plans/solver_state.jl

@@ -15,6 +15,15 @@ $(_fields(:stopping_criterion; name = "stop"))
 """
 abstract type AbstractManoptSolverState end
 
+function Base.show(io::IO, ::MIME"text/plain", ams::AbstractManoptSolverState)
+    multiline = get(io, :multiline, true)
+    if multiline
+        return status_summary(io, ams)
+    else
+        show(io, ams)
+    end
+end
+
 """
     ClosedFormSubSolverState{E<:AbstractEvaluationType} <: AbstractManoptSolverState
 

src/solvers/gradient_descent.jl

@@ -52,7 +52,7 @@ mutable struct GradientDescentState{
     retraction_method::TRTM
 end
 function GradientDescentState(
-        M::AbstractManifold;
+        M::AbstractManifold = ManifoldsBase.DefaultManifold();
         p::P = rand(M),
         X::T = zero_vector(M, p),
         stopping_criterion::SC = StopAfterIteration(200) | StopWhenGradientNormLess(1.0e-8),
@@ -96,38 +96,27 @@ function get_message(gds::GradientDescentState)
     return get_message(gds.stepsize)
 end
 
-function Base.show(io::IO, obj::GradientDescentState)
-    return print_object(io, obj, multiline = false)
-end
-# the 3-argument show used by display(obj) on the REPL
-function Base.show(io::IO, ::MIME"text/plain", obj::GradientDescentState)
-    multiline = get(io, :multiline, true)
-    return print_object(io, obj, multiline = multiline)
+function Base.show(io::IO, gds::GradientDescentState)
+    return "GradientDescentState(; direction=$(repr(gds.direction)), p=$(repr(gds.p)), stepsize=$(repr(gds.stepsize)), stopping_criterion=$(repr(gds.stop)), retraction_method=$(repr(gds.retraction_method)), X=$(repr(gds.X)))"
 end
 
-function print_object(io::IO, gds::GradientDescentState; multiline::Bool)
-    if multiline
-        i = get_count(gds, :Iterations)
-        Iter = (i > 0) ? "After $i iterations\n" : ""
-        Conv = indicates_convergence(gds.stop) ? "Yes" : "No"
-        s = """
-        # Solver state for `Manopt.jl`s Gradient Descent
-        $Iter
-        ## Parameters
-        * retraction method: $(gds.retraction_method)
-
-        ## Stepsize
-        $(gds.stepsize)
-
-        ## Stopping criterion
-
-        $(status_summary(gds.stop))
-        This indicates convergence: $Conv"""
-        return print(io, s)
-    else
-        # write something short, or go back to default mode
-        return Base.show_default(io, gds)
-    end
+function status_summary(gds::GradientDescentState)
+    i = get_count(gds, :Iterations)
+    Iter = (i > 0) ? "After $i iterations\n" : ""
+    Conv = indicates_convergence(gds.stop) ? "Yes" : "No"
+    s = """
+    # Solver state for `Manopt.jl`s Gradient Descent
+    $Iter
+    ## Parameters
+    * retraction method: $(gds.retraction_method)
+
+    ## Stepsize
+    $(gds.stepsize)
+
+    ## Stopping criterion
+    $(status_summary(gds.stop))
+    This indicates convergence: $Conv"""
+    return s
 end
 
 _doc_gd_iterate = raw"""