Remove custom printing (#332)

Author: gdalle

DifferentiationInterface/docs/src/backends.md

@@ -9,7 +9,6 @@ We support all dense backend choices from [ADTypes.jl](https://github.com/SciML/
 
 ```@setup backends
 using DifferentiationInterface
-using DifferentiationInterface: backend_str
 import Markdown
 
 import Diffractor
@@ -25,21 +24,21 @@ import Tapir
 import Tracker
 import Zygote
 
-const backend_examples = (
-    "AutoDiffractor()",
-    "AutoEnzyme(; mode=Enzyme.Forward)",
-    "AutoEnzyme(; mode=Enzyme.Reverse)",
-    "AutoFastDifferentiation()",
-    "AutoFiniteDiff()",
-    "AutoFiniteDifferences(; fdm=FiniteDifferences.central_fdm(3, 1))",
-    "AutoForwardDiff()",
-    "AutoPolyesterForwardDiff(; chunksize=1)",
-    "AutoReverseDiff()",
-    "AutoSymbolics()",
-    "AutoTapir(; safe_mode=false)",
-    "AutoTracker()",
-    "AutoZygote()",
-)
+backend_examples = [
+    AutoDiffractor(),
+    AutoEnzyme(; mode=Enzyme.Forward),
+    AutoEnzyme(; mode=Enzyme.Reverse),
+    AutoFastDifferentiation(),
+    AutoFiniteDiff(),
+    AutoFiniteDifferences(; fdm=FiniteDifferences.central_fdm(3, 1)),
+    AutoForwardDiff(),
+    AutoPolyesterForwardDiff(; chunksize=1),
+    AutoReverseDiff(),
+    AutoSymbolics(),
+    AutoTapir(; safe_mode=false),
+    AutoTracker(),
+    AutoZygote(),
+]
 
 checkmark(x::Bool) = x ? '✅' : '❌'
 unicode_check_available(backend) = checkmark(check_available(backend))
@@ -49,12 +48,11 @@ unicode_check_twoarg(backend)    = checkmark(check_twoarg(backend))
 io = IOBuffer()
 
 # Table header 
-println(io, "| Backend | Availability | Two-argument functions | Hessian support | Example |")
-println(io, "|:--------|:------------:|:----------------------:|:---------------:|:--------|")
+println(io, "| Backend | Availability | Two-argument functions | Hessian support |")
+println(io, "|:--------|:------------:|:----------------------:|:---------------:|")
 
-for example in backend_examples
-    b = eval(Meta.parse(example)) # backend
-    join(io, [backend_str(b), unicode_check_available(b), unicode_check_twoarg(b), unicode_check_hessian(b), "`$example`"], '|')
+for b in backend_examples
+    join(io, [string(b), unicode_check_available(b), unicode_check_twoarg(b), unicode_check_hessian(b)], '|')
     println(io, '|' )
 end
 backend_table = Markdown.parse(String(take!(io)))

DifferentiationInterface/docs/src/overloads.md

@@ -22,7 +22,7 @@ The cells can have three values:
 ```@setup overloads
 using ADTypes: AbstractADType
 using DifferentiationInterface
-using DifferentiationInterface: backend_str, twoarg_support, TwoArgSupported
+using DifferentiationInterface: twoarg_support, TwoArgSupported
 using Markdown: Markdown
 
 using Diffractor: Diffractor

DifferentiationInterface/ext/DifferentiationInterfaceEnzymeExt/DifferentiationInterfaceEnzymeExt.jl

@@ -43,8 +43,6 @@ end
 
 ADTypes.mode(backend::AutoDeferredEnzyme) = ADTypes.mode(AutoEnzyme(backend.mode))
 
-DI.backend_package_name(::AutoDeferredEnzyme) = "DeferredEnzyme"
-
 DI.nested(backend::AutoEnzyme) = AutoDeferredEnzyme(backend.mode)
 
 const AnyAutoEnzyme{M} = Union{AutoEnzyme{M},AutoDeferredEnzyme{M}}

DifferentiationInterface/src/misc/differentiate_with.jl

@@ -54,5 +54,7 @@ Call the underlying function `dw.f` of a [`DifferentiateWith`](@ref) wrapper.
 
 function Base.show(io::IO, dw::DifferentiateWith)
     @compat (; f, backend) = dw
-    return print(io, "$f differentiated with $(backend_str(backend))")
+    return print(
+        io, DifferentiateWith, "(", repr(f; context=io), ",", repr(backend; context=io), ")"
+    )
 end

DifferentiationInterface/src/misc/sparsity_detector.jl

@@ -73,7 +73,15 @@ end
 
 function Base.show(io::IO, detector::DenseSparsityDetector{method}) where {method}
     @compat (; backend, atol) = detector
-    return print(io, "DenseSparsityDetector{:$method}($backend; atol=$atol)")
+    return print(
+        io,
+        DenseSparsityDetector,
+        "(",
+        repr(backend; context=io),
+        "; atol=$atol, method=",
+        repr(method; context=io),
+        ")",
+    )
 end
 
 function DenseSparsityDetector(

DifferentiationInterface/src/second_order/second_order.jl

@@ -22,7 +22,15 @@ struct SecondOrder{ADO<:AbstractADType,ADI<:AbstractADType} <: AbstractADType
 end
 
 function Base.show(io::IO, backend::SecondOrder)
-    return print(io, "SecondOrder($(outer(backend)) / $(inner(backend)))")
+    return print(
+        io,
+        SecondOrder,
+        "(",
+        repr(outer(backend); context=io),
+        ", ",
+        repr(inner(backend); context=io),
+        ")",
+    )
 end
 
 """

DifferentiationInterface/src/utils/exceptions.jl

@@ -3,13 +3,13 @@ struct MissingBackendError <: Exception
 end
 
 function Base.showerror(io::IO, e::MissingBackendError)
-    println(io, "failed to use $(backend_str(e.backend)) backend.")
+    println(io, "MissingBackendError: Failed to use $(e.backend).")
     if !check_available(e.backend)
         print(
             io,
-            """Backend package is not loaded. To fix, run
+            """Backend package is probably not loaded. To fix this, try to run
 
-              import $(backend_package_name(e.backend))
+                import $(package_name(e.backend))
             """,
         )
     else

DifferentiationInterface/src/utils/printing.jl

@@ -1,40 +1,11 @@
-backend_package_name(b::AbstractADType) = strip(string(b), ['(', ')'])
-backend_package_name(b::AutoSparse) = backend_package_name(dense_ad(b))
-
-backend_package_name(::AutoChainRules) = "ChainRules"
-backend_package_name(::AutoDiffractor) = "Diffractor"
-backend_package_name(::AutoEnzyme) = "Enzyme"
-backend_package_name(::AutoFastDifferentiation) = "FastDifferentiation"
-backend_package_name(::AutoFiniteDiff) = "FiniteDiff"
-backend_package_name(::AutoFiniteDifferences) = "FiniteDifferences"
-backend_package_name(::AutoForwardDiff) = "ForwardDiff"
-backend_package_name(::AutoPolyesterForwardDiff) = "PolyesterForwardDiff"
-backend_package_name(::AutoSymbolics) = "Symbolics"
-backend_package_name(::AutoTapir) = "Tapir"
-backend_package_name(::AutoTracker) = "Tracker"
-backend_package_name(::AutoZygote) = "Zygote"
-backend_package_name(::AutoReverseDiff) = "ReverseDiff"
-
-backend_package_name(::AF) where {AF<:AutoForwardFromPrimitive} = string(AF)
-backend_package_name(::AR) where {AR<:AutoReverseFromPrimitive} = string(AR)
-
-function backend_str(backend::AbstractADType)
-    bs = backend_package_name(backend)
-    if mode(backend) isa ForwardMode
-        return "$bs (forward)"
-    elseif mode(backend) isa ReverseMode
-        return "$bs (reverse)"
-    elseif mode(backend) isa SymbolicMode
-        return "$bs (symbolic)"
-    elseif mode(backend) isa ForwardOrReverseMode
-        return "$bs (forward or reverse)"
+function package_name(b::AbstractADType)
+    s = string(b)
+    k = findfirst('(', s)
+    if isnothing(k)
+        throw(ArgumentError("Cannot parse backend into package"))
     else
-        error("Unknown mode")
+        return s[5:(k - 1)]
     end
 end
 
-backend_str(backend::AutoSparse) = "Sparse $(backend_str(dense_ad(backend)))"
-
-function backend_str(backend::SecondOrder)
-    return "$(backend_str(outer(backend))) / $(backend_str(inner(backend)))"
-end
+package_name(b::AutoSparse) = package_name(dense_ad(b))

DifferentiationInterface/test/Internals/display.jl

@@ -0,0 +1,18 @@
+using ADTypes
+using DifferentiationInterface
+using Test
+
+backend = SecondOrder(AutoForwardDiff(), AutoZygote())
+@test startswith(string(backend), "SecondOrder(")
+@test endswith(string(backend), ")")
+
+detector = DenseSparsityDetector(AutoForwardDiff(); atol=1e-23)
+@test startswith(string(detector), "DenseSparsityDetector(")
+@test endswith(string(detector), ")")
+
+diffwith = DifferentiateWith(exp, AutoForwardDiff())
+@test startswith(string(diffwith), "DifferentiateWith(")
+@test endswith(string(diffwith), ")")
+
+@test DifferentiationInterface.package_name(AutoForwardDiff()) == "ForwardDiff"
+@test DifferentiationInterface.package_name(AutoZygote()) == "Zygote"

DifferentiationInterface/test/Internals/second_order.jl

@@ -5,6 +5,5 @@ using Test
 backend = SecondOrder(AutoForwardDiff(), AutoZygote())
 
 @test ADTypes.mode(backend) isa ADTypes.ForwardMode
-@test startswith(string(backend), "SecondOrder")
 @test DifferentiationInterface.outer(backend) isa AutoForwardDiff
 @test DifferentiationInterface.inner(backend) isa AutoZygote