how to serialize subtypes of an abstract type such that deserialization works?

[rapus95]

abstract type AbstractT end
struct ConcreteT <: AbstractT end
StructTypes.StructType(::Type{AbstractT}) = StructTypes.AbstractType()
StructTypes.StructType(::Type{ConcreteT}) = StructTypes.Struct()
StructTypes.subtypes(::Type{AbstractT}) = (conc=ConcreteT,)
StructTypes.subtypekey(::Type{AbstractT}) = :subt
JSON3.write(ConcreteT()) #-> "{}"

[quinnj]

If your ConcreteT is defined as StructTypes.Struct, then you'll need to define the struct like:

struct ConcreteT <: AbstractT
    subt::String
end

Then you would do JSON3.write(CocnreteT("conc")) and be able to read it back in via JSON3.read(json, AbstractT)

[rapus95]

but shouldn't it be possible to extend the interface in such a way that this happens automatically w/o having to implement the type field as an implicit and redundant waste of memory?
Like

StructTypes.supertype(::AbstractT) = AbstractT

which then can loop back into the mechanism by doing a reverse-lookup via isa of the identifier in the subtypes list and serializing it into a field as defined by subtypekey. Default implementation should define StructTypes.supertype(_) = nothing which indicates that no such field shall be serialized.

EDIT: The invariant (which won't be checked) should be:

if StructTypes.StructType(T) == StructTypes.AbstractType()
  all(values(StructTypes.subtypes(T))) do S
    StructTypes.supertype(S) == T
  end
end

[quinnj]

I'm not quite sure I follow the suggestion here; if you could give a more complete example, that would help to see exactly what you're proposing. It seems to me, from what I understand, that we'd still want the current machinery because some types do want an explicit field, and there are many cases where the deserialized identifier doesn't match one-to-one with the name of a concrete subtype, so we need an explicit mapping of deserialized identifier -> concrete subtype.

[rapus95]

#new function to extend

"Returns a parent type T for which StructType(T)==AbstractType() and for which deserialization is supported or nothing if no such type exists"
function supertype end
supertype(x::Type{T}) where T = nothing
supertype(x::T) where T = supertype(T)

#helper function
@inline find_type_identifier(suptyp::Type{S}, elemtyp::Type{T}) where {S,T} = findfirst(==(T), StructTypes.subtypes(S))


#a complete definition for de/serialization:
StructTypes.StructType(::Type{AbstractPlugin}) = StructTypes.AbstractType()
StructTypes.StructType(::Type{T}) where {T<:AbstractPlugin} = StructTypes.UnorderedStruct()
StructTypes.subtypekey(::Type{AbstractPlugin}) = :plugin
StructTypes.subtypes(::Type{AbstractPlugin}) = (p1=Plugin1, p2=Plugin2, p3=Plugin3)
StructTypes.supertype(::Type{T}) where {T<:AbstractPlugin} = AbstractPlugin


#how JSON3 could use that:
@inline function JSON3.write(::Union{StructTypes.Struct, StructTypes.Mutable}, buf, pos, len, x::T; kw...) where {T}
    JSON3.@writechar '{'
    c = JSON3.WriteClosure(buf, pos, len, false, values(kw))
  
    #this is new
    suptyp = supertype(T)
    if suptyp!==nothing && StructTypes.StructType(suptyp) isa StructTypes.AbstractType
        c(0, StructTypes.subtypekey(suptyp), Symbol, find_type_identifier(suptyp, T))
    end

    StructTypes.foreachfield(c, x)
    buf = c.buf
    pos = c.pos
    len = c.len
    JSON3.@writechar '}'
    return buf, pos, len
end

EDIT: that new part should be augmented for checking if x already has an explicit field named the same as the subtypekey