Document the explicit FunctionWrappersWrapper{FW, P, CS}(fw, cs) constructor

`FunctionWrappersWrapper` is exported, so its inner constructor was already
reachable as public API, but it carried no docstring — the only constructor of
the type that did not. Downstream solver stacks construct through exactly this
method, because supplying `FW`, `P` and `CS` directly keeps the wrapper type
inferrable without relying on constant propagation through a keyword-argument
frame, which the `argtypes`/`rettypes` and tuple constructors do.

The docstring is attached with `@doc` on the method signature after the struct;
a docstring written inside the struct body does not attach to the type's
binding, so Documenter would never render it.

Co-Authored-By: Chris Rackauckas <accounts@chrisrackauckas.com>

Author: ChrisRackauckas

Project.toml

@@ -1,7 +1,7 @@
 name = "FunctionWrappersWrappers"
 uuid = "77dc65aa-8811-40c2-897b-53d922fa7daf"
 authors = ["Chris Elrod <elrodc@gmail.com> and contributors"]
-version = "1.11.0"
+version = "1.11.1"
 
 [deps]
 FunctionWrappers = "069b7b12-0de2-55c6-9aab-29f3d0a68a2e"

src/FunctionWrappersWrappers.jl

@@ -225,6 +225,50 @@ end
 
 TruncatedStacktraces.@truncate_stacktrace FunctionWrappersWrapper
 
+@doc """
+    FunctionWrappersWrapper{FW, P, CS}(fw, cs) -> FunctionWrappersWrapper{FW, P, CS}
+
+Create a `FunctionWrappersWrapper` from an already-built wrapper tuple and cache storage,
+with every type parameter fixed by the caller.
+
+This is the fully explicit form. Prefer it when the result type must be inferrable from
+type parameters alone: `FW`, `P` and `CS` are given directly rather than derived from
+argument values, so nothing rests on constant propagation through a keyword-argument
+frame. Solver stacks that wrap a type-erased callable — where the wrapper type, and every
+cache built from it, must stay concrete — construct through this method.
+
+The caller is responsible for consistency: `fw` must match `FW`, and `cs` must be the
+storage type `P`'s fallback path expects — [`NoCacheStorage`](@ref),
+[`SingleCacheStorage`](@ref), or [`DictCacheStorage`](@ref), matching the intended cache
+mode.
+
+# Arguments
+- `fw`: Tuple of `FunctionWrappers.FunctionWrapper`s, tried in order on call.
+- `cs`: Cache storage instance used by the fallback path.
+
+# Type Parameters
+- `FW`: Tuple type of the wrapped `FunctionWrapper`s.
+- `P`: Fallback policy type, such as `Strict`, `AllowAll`, or `AllowNonIsBits`.
+- `CS`: Cache storage type, matching `typeof(cs)`.
+
+# Returns
+- `FunctionWrappersWrapper{FW, P, CS}`: A callable wrapper around `fw`.
+
+# Examples
+```jldoctest
+julia> using FunctionWrappers: FunctionWrapper
+
+julia> fw = (FunctionWrapper{Float64, Tuple{Float64, Float64}}(+),);
+
+julia> cs = FunctionWrappersWrappers.SingleCacheStorage();
+
+julia> fww = FunctionWrappersWrapper{typeof(fw), AllowNonIsBits, typeof(cs)}(fw, cs);
+
+julia> fww(1.0, 2.0)
+3.0
+```
+""" FunctionWrappersWrapper{FW, P, CS}(fw::FW, cs::CS) where {FW, P, CS}
+
 """
     FunctionWrappersWrapper{FW, P, CS}(f) -> FunctionWrappersWrapper{FW, P, CS}