Covariance support for @NamedTuple

[o314]

With @NamedTuple, one can code

using Test
@test (a=1,b=true) isa NamedTuple{(:a,:b),Tuple{Int,Bool}}

by shortening it with

@test (a=1,b=true) isa @NamedTuple{a::Int, b::Bool}

but this fails with, for example, a nullable type

@test_broken (a=1,b=true) isa @NamedTuple{a::Int, b::Union{Bool,Nothing}}
# logical since it expands to :
@test_broken (a=1,b=true) isa NamedTuple{(:a,:b),Tuple{Int,Union{Bool,Nothing}}}
# namedtuple covariance is not handled. this is what we are looking for
@test (a=1,b=true) isa NamedTuple{(:a,:b),<:Tuple{Int,Union{Bool,Nothing}}}

This PR propose to make it work, by adding a <: recognition

@test (a=1,b=true) isa @NamedTuple{<:(a::Int, b::Union{Bool,Nothing})}

nota i do not code the @NamedTuple <: begin ... end form since i consider it less natural.

[JeffBezanson]

I see the need for the feature, but I don't like the notation <:( ... ). In fact you can do this currently with e.g. @NamedTuple{a::T} where T<:Integer, so we may not need new syntax.

[o314]

May be a bit clumsy for the core lang; true. After reviewing #24990 and #29875 i play with different underscore form to get @NamedTuple{a::(_<:Integer)} or even may be its unary form @NamedTuple{a::(<:Integer)}

• it parses correctly as of v1.6 "@NamedTuple{a::(_<:Integer)}" |> Meta.parse
• it is not that much disruptive with the current form implemented :

julia> :(@NamedTuple{a::Int}) |> Meta.show_sexpr
(:macrocall, Symbol("@NamedTuple"), :(#= REPL[22]:1 =#), (:braces, (:(::), :a, :Int)))

julia> :(@NamedTuple{a::(_<:Integer)}) |> Meta.show_sexpr
(:macrocall, Symbol("@NamedTuple"), :(#= REPL[23]:1 =#), (:braces, (:(::), :a, (:<:, :_, :Integer))))

• it does not shake too much the symbolic payload, associativity around instance, type, typevar otherwise (personal opinion ?)
  like
  :(@NamedTuple{a::_<:Integer}) # bad readability, assoc impedance
  :(@NamedTuple{a::_{<:Integer}}) # typevar syntax hijacking
  :(@NamedTuple{a::{<:Integer}}) # is it good ? better ?

EDIT: add the unary form

[o314]

May be, not of those are goods enough now. Simply updating the doc of @NamedTuple to suggest how to covariant it with @NamedTuple{a::T} where T<:Integer may be enough.

[JeffBezanson]

@NamedTuple{a::(<:Integer)} is good, since we already have a rule that <:X inside curly braces means T plus where T<:X added outside. In fact, you can already write this syntax, but it does the wrong thing, since the <: is "captured" by the Tuple{ } expression. That is arguably a bug that should be fixed!

[o314]

OK I Understand. FWIW

julia> mapfoldl(append!, (Core,Meta,Base); init=[]) do m
    [(m,nm) for nm in names(m; all=true) if
        occursin("Tuple", string(nm)) && let a=getfield(m,nm); a isa Type && a <: Tuple end]
end
4-element Vector{Any}:
(Core, :NTuple)
(Core, :Tuple)
(Base, :NTuple)
(Base, :VerTuple)

julia> mapfoldl(append!, (Core,Meta,Base); init=[]) do m
    [(m,nm) for nm in names(m; all=true) if
        occursin("Tuple", string(nm)) && let a=getfield(m,nm); a isa Type && !(a <: Tuple) end]
end
3-element Vector{Any}:
(Core, :NamedTuple)
(Base, Symbol("#@NamedTuple"))
(Base, :AbstractVecOrTuple)

lending one day covariance to tuplesomething may not be so contagious.

---

One or two examples in doc could be helpful and enough .
No pb to code them