`select_problems` dispatch relies on `Pair`'s questionable promotion behavior

[adienes]

in JuliaLang/julia#58836, triage desires to remove the promote_rule defined for Pair (and Some) as to make it consistent with every other container type in the language

I am going through the results of the Nanosoldier run so as to avoid as much potential downstream impact as possible.

I noticed that the implementation here relies on the fact that Pair promotes pretending to be covariant (like Tuple is) when in fact it is not.

looking at the code, my first impression is that it would suffice here to set
const SubSet = Pair as a bare alias rather than Pair{<:Integer,<:AbstractVector{<:Integer}} , do you have any thoughts on that approach?

[kagalenko-m-b]

Would

const SubSet = Pair{T,S} where {T<:Integer,S<:AbstractVector{<:Integer}}

work ?

[adienes]

I think that's equivalent to the original one

[kagalenko-m-b]

I think that's equivalent to the original one

Then my understanding of type declarations is deficient. I assumed that declaration should match any Pair where T is a subtype of Integer and S is a subtype of AbstractVector .

[adienes]

this is what I'm going off of:

julia> S = Pair{<:Integer,<:AbstractVector{<:Integer}}
Pair{<:Integer, <:AbstractVector{<:Integer}}

julia> T = (Pair{T,S} where {T<:Integer,S<:AbstractVector{<:Integer}})
Pair{T, S} where {T<:Integer, S<:(AbstractVector{<:Integer})}

julia> (S == T) && (S <: T) && (T <: S)
true

I assumed that declaration should match any Pair where T is a subtype of Integer and S is a subtype of AbstractVector

it does, they both do 🙂

[kagalenko-m-b]

I assumed that declaration should match any Pair where T is a subtype of Integer and S is a subtype of AbstractVector

it does, they both do 🙂

Does the covariance enter into it, though? I thought that covariance would be to expect that

Int[]::Vector{Integer}

which is false

[adienes]

what I meant by that was that promote_type on pairs kind of pretends like Pair is covariant (which it is not)

i.e., currently

julia> promote_type(Pair{Int16, Float16}, Pair{Int64, Float64})
Pair{Int64, Float64}

but after JuliaLang/julia#58836

julia> promote_type(Pair{Int16, Float16}, Pair{Int64, Float64})
Pair

[kagalenko-m-b]

I see, those are delicate design issues.
I wonder whether it makes sense to keep the SubSet alias if it's just Pair. Perhaps some future development of types in Julia?

[adienes]

up to you I suppose. it could make sense to retain const SubSet = Pair in the case that it makes it easier to refactor in the future to its own type struct SubSet ... end without having to change all your other code or pirate methods of Pair

[kagalenko-m-b]

So if “covariance” you speak of relates to promotion, rather than function arguments type checking, what are the potential issues for this package, ProblemSet.jl?

[adienes]

I see, probably the easiest fix at the moment is the one you suggest. Should I trigger package version update, as well?

[adienes]

@kagalenko-m-b I think you are inadvertently editing my comments rather than replying with a new comment 🙂 (please don't do that)