remove docstring changes

clean new dispatches out

Update src/config.jl
Update src/config.jl
Update src/config.jl
Update src/config.jl
Update src/config.jl
Update src/config.jl
Update src/config.jl
Add a preferences version

Update src/config.jl
Update src/config.jl

Author: ChrisRackauckas

src/config.jl

@@ -104,12 +104,9 @@ Base.eltype(cfg::AbstractConfig) = eltype(typeof(cfg))
 @inline (chunksize(::AbstractConfig{N})::Int) where {N} = N
 
 function maketag(tagstyle::Union{Symbol,Nothing}, f, X)
-    @static if VERSION ≥ v"1.11"
+    if HASHTAG_MODE_ENABLED
         return HashTag(f, X)
     else
-        # On ≤1.10, the hash of a type cannot be computed at compile-time,
-        # making `HashTag(...)` type-unstable, so `Tag(...)` is left as
-        # as the default.
         return Tag(f, X)
     end
 end
@@ -136,22 +133,12 @@ If `f!` is `nothing` instead of the actual target function, then the returned in
 be used with any target function. However, this will reduce ForwardDiff's ability to catch
 and prevent perturbation confusion (see https://github.com/JuliaDiff/ForwardDiff.jl/issues/83).
 
-If `tag` is `:hash`, a small hash-based tag is provided. This tracks perturbation confusion
-with similar accuracy, but is much smaller than `tag = :type`, which stores the full type.
-
 This constructor does not store/modify `y` or `x`.
 """
-@inline function DerivativeConfig(f::F,
-                          y::AbstractArray{Y},
-                          x::X) where {F,X<:Real,Y<:Real}
-    T = maketag(f, X)
-    return DerivativeConfig(f,y,x,T)
-end
-
 function DerivativeConfig(f::F,
                           y::AbstractArray{Y},
                           x::X,
-                          tag::T) where {F,X<:Real,Y<:Real,T}
+                          tag::T = Tag(f, X)) where {F,X<:Real,Y<:Real,T}
     duals = similar(y, Dual{T,Y,1})
     return DerivativeConfig{T,typeof(duals)}(duals)
 end
@@ -181,22 +168,12 @@ If `f` or `tag` is `nothing`, then the returned instance can be used with any ta
 However, this will reduce ForwardDiff's ability to catch and prevent perturbation confusion
 (see https://github.com/JuliaDiff/ForwardDiff.jl/issues/83).
 
-If `tag` is `:hash`, a small hash-based tag is provided. This tracks perturbation confusion
-with similar accuracy, but is much smaller than `tag = :type`, which stores the full type.
-
 This constructor does not store/modify `x`.
 """
-@inline function GradientConfig(f::F,
-                        x::AbstractArray{V},
-                        c::Chunk{N} = Chunk(x)) where {F,V,N}
-    T = maketag(f, V)
-    return GradientConfig(f,x,c,T)
-end
-
 function GradientConfig(f::F,
                         x::AbstractArray{V},
-                        ::Chunk{N},
-                        ::T) where {F,V,N,T}
+                        ::Chunk{N} = Chunk(x),
+                        ::T = Tag(f, V)) where {F,V,N,T}
     seeds = construct_seeds(Partials{N,V})
     duals = similar(x, Dual{T,V,N})
     return GradientConfig{T,V,N,typeof(duals)}(seeds, duals)
@@ -228,22 +205,12 @@ If `f` or `tag` is `nothing`, then the returned instance can be used with any ta
 However, this will reduce ForwardDiff's ability to catch and prevent perturbation confusion
 (see https://github.com/JuliaDiff/ForwardDiff.jl/issues/83).
 
-If `tag` is `:hash`, a small hash-based tag is provided. This tracks perturbation confusion
-with similar accuracy, but is much smaller than `tag = :type`, which stores the full type.
-
 This constructor does not store/modify `x`.
 """
-@inline function JacobianConfig(f::F,
-                        x::AbstractArray{V},
-                        c::Chunk{N} = Chunk(x)) where {F,V,N}
-    T = maketag(f, V)
-    return JacobianConfig(f,x,c,T)
-end
-
 function JacobianConfig(f::F,
                         x::AbstractArray{V},
-                        ::Chunk{N},
-                        ::T) where {F,V,N,T}
+                        ::Chunk{N} = Chunk(x),
+                        ::T = Tag(f, V)) where {F,V,N,T}
     seeds = construct_seeds(Partials{N,V})
     duals = similar(x, Dual{T,V,N})
     return JacobianConfig{T,V,N,typeof(duals)}(seeds, duals)
@@ -263,24 +230,13 @@ If `f!` or `tag` is `nothing`, then the returned instance can be used with any t
 However, this will reduce ForwardDiff's ability to catch and prevent perturbation confusion
 (see https://github.com/JuliaDiff/ForwardDiff.jl/issues/83).
 
-If `tag` is `:hash`, a small hash-based tag is provided. This tracks perturbation confusion
-with similar accuracy, but is much smaller than `tag = :type`, which stores the full type.
-
 This constructor does not store/modify `y` or `x`.
 """
-@inline function JacobianConfig(f::F,
-                        y::AbstractArray{Y},
-                        x::AbstractArray{X},
-                        c::Chunk{N} = Chunk(x)) where {F,Y,X,N}
-    T = maketag(f, X)
-    return JacobianConfig(f,y,x,c,T)
-end
-
 function JacobianConfig(f::F,
                         y::AbstractArray{Y},
                         x::AbstractArray{X},
-                        ::Chunk{N},
-                        ::T) where {F,Y,X,N,T}
+                        ::Chunk{N} = Chunk(x),
+                        ::T = Tag(f, X)) where {F,Y,X,N,T}
     seeds = construct_seeds(Partials{N,X})
     yduals = similar(y, Dual{T,Y,N})
     xduals = similar(x, Dual{T,X,N})
@@ -316,22 +272,12 @@ If `f` or `tag` is `nothing`, then the returned instance can be used with any ta
 However, this will reduce ForwardDiff's ability to catch and prevent perturbation confusion
 (see https://github.com/JuliaDiff/ForwardDiff.jl/issues/83).
 
-If `tag` is `:hash`, a small hash-based tag is provided. This tracks perturbation confusion
-with similar accuracy, but is much smaller than `tag = :type`, which stores the full type.
-
 This constructor does not store/modify `x`.
 """
-@inline function HessianConfig(f::F,
-                       x::AbstractArray{V},
-                       chunk::Chunk = Chunk(x)) where {F,V}
-    T = maketag(f, V)
-    return HessianConfig(f, x, chunk, T)
-end
-
 function HessianConfig(f::F,
                        x::AbstractArray{V},
-                       chunk::Chunk,
-                       tag) where {F,V}
+                       chunk::Chunk = Chunk(x),
+                       tag = Tag(f, V)) where {F,V}
     jacobian_config = JacobianConfig(f, x, chunk, tag)
     gradient_config = GradientConfig(f, jacobian_config.duals, chunk, tag)
     return HessianConfig(jacobian_config, gradient_config)
@@ -350,24 +296,13 @@ If `f` or `tag` is `nothing`, then the returned instance can be used with any ta
 However, this will reduce ForwardDiff's ability to catch and prevent perturbation confusion
 (see https://github.com/JuliaDiff/ForwardDiff.jl/issues/83).
 
-If `tag` is `:hash`, a small hash-based tag is provided. This tracks perturbation confusion
-with similar accuracy, but is much smaller than `tag = :type`, which stores the full type.
-
 This constructor does not store/modify `x`.
 """
-@inline function HessianConfig(f::F,
-                       result::DiffResult,
-                       x::AbstractArray{V},
-                       chunk::Chunk = Chunk(x)) where {F,V}
-    T = maketag(f, V)
-    return HessianConfig(f, result, x, chunk, T)
-end
-
 function HessianConfig(f::F,
                        result::DiffResult,
                        x::AbstractArray{V},
-                       chunk::Chunk,
-                       tag) where {F,V}
+                       chunk::Chunk = Chunk(x),
+                       tag = Tag(f, V)) where {F,V}
     jacobian_config = JacobianConfig((f,gradient), DiffResults.gradient(result), x, chunk, tag)
     gradient_config = GradientConfig(f, jacobian_config.duals[2], chunk, tag)
     return HessianConfig(jacobian_config, gradient_config)

src/prelude.jl

@@ -1,6 +1,11 @@
 const NANSAFE_MODE_ENABLED = @load_preference("nansafe_mode", false)
 const DEFAULT_CHUNK_THRESHOLD = @load_preference("default_chunk_threshold", 12)
 
+# On ≤1.10, the hash of a type cannot be computed at compile-time,
+# making `HashTag(...)` type-unstable, so `Tag(...)` is left as
+# as the default.
+const HASHTAG_MODE_ENABLED = @load_preference("hashtag_mode", VERSION ≥ v"1.11")
+
 const AMBIGUOUS_TYPES = (AbstractFloat, Irrational, Integer, Rational, Real, RoundingMode)
 
 const UNARY_PREDICATES = Symbol[:isinf, :isnan, :isfinite, :iseven, :isodd, :isreal, :isinteger]