Document type-stable constructors

[gdalle]

Right now, only the constructors with keyword arguments are part of the public API for ADTypes.
This is problematic because e.g. AutoForwardDiff(; chunksize, tag) is type-unstable while AutoForwardDiff{chunksize,typeof(tag)}(tag) is not.
As a result, DI (and probably other packages too) are forced to use undocumented internal API that may break without notice whenever they want to construct backends efficiently. I suggest we document type-stable variants of every constructor when possible, even if it means adding fallbacks when the number of type parameters increases. For instance, if someday there is an AutoForwardDiff{chunksize,T,whatever}, then AutoForwardDiff{chunksize,T}(tag) should still work.

Related:

• feat: add ConstructionBaseExt to allow Setfield and Functors support #94

[ChrisRackauckas]

Is this still an issue though? My understanding is that the effect system should be able to optimize out the literals these days? CC @oscardssmith

[gdalle]

Doesn't look that way: the keyword version seems to be type-unstable, at least on Julia 1.11.

julia> using Test

julia> struct MyType{A} end

julia> MyType(; A) = MyType{A}()
MyType

julia> @inferred MyType(; A=1)
ERROR: return type MyType{1} does not match inferred return type MyType
Stacktrace:
 [1] error(s::String)
   @ Base ./error.jl:35
 [2] top-level scope
   @ REPL[9]:1

[ChrisRackauckas]

using Test
struct MyType{A} end
MyType(; A) = MyType{A}()
function testf()
	MyType(; A=1)
end
@code_warntype optimize=true testf()

MethodInstance for testf()
  from testf() @ Main ~/Desktop/test.jl:128
Arguments
  #self#::Core.Const(testf)
Body::MyType{1}
1 ─     return $(QuoteNode(MyType{1}()))

Global scope.

[gdalle]

My example was ill-chosen, but what I really wanted to know was this:

julia> f1(::Val{A}) where A = MyType(; A)
f1 (generic function with 1 method)

julia> f2(::Val{A}) where A = MyType{A}()
f2 (generic function with 1 method)

julia> @inferred f1(Val(1))
MyType{1}()

julia> @inferred f2(Val(1))
MyType{1}()

I thought there would be a difference between f1 and f2, but apparently there is none

[oscardssmith]

So is there an issue?

[gdalle]

I don't think so, let's close. I'll switch in DI to use the keyword argument constructors, because I know now that there is no type inference penalty