`ConstructionBase.constructorof` drops parametric type. about accessors.jl

[rafaqz]

You need to define your own method of ConstructionBase.constructorof for Implication because the parameters are not known from the fields. The problem is it can be difficult to detect which parameters should be kept - consider a much more complicated type with nested parameters.

For these simple types we could possibly detect that O isnt known from the fields, and keep it.

Implication also isnt type-stable by the way, the SVector could be a type parameter.

[jw3126]

@AIxer if overloading ConstructionBase.constructorof sounds scary to you, it is just a single line:

ConstructionBase.constructorof(::Type{Implication{O}}) where {O} = Implication{O}

[rafaqz]

Hah beat me too it, I had just written the identical code... but yes do that

[AIxer]

Thx! I'm really learned a lot from you! ❤️

[AIxer]

You need to define your own method of ConstructionBase.constructorof for Implication because the parameters are not known from the fields. The problem is it can be difficult to detect which parameters should be kept - consider a much more complicated type with nested parameters.

For these simple types we could possibly detect that O isnt known from the fields, and keep it.

Implication also isnt type-stable by the way, the SVector could be a type parameter.

Thanks! I'm gonna make it mutable. 😄

[rafaqz]

Why make it mutable? that's not really a good solution to your problem.

[AIxer]

In fact, I seldom use immutable struct, but I'd very like to use it, maybe I should learn some Haskell.
I'm rewriting Non-Axiomatic Reasoning System. The term Implication is from its formal language called Narsese. There are may terms in Narsese, such as Inheritance, Similarity, etc. they are types of Term and use Terms as their comps. The whole system never changes its terms in place, but copy then change sometimes (all operation could use immutable methods). emm, the problem is I don't know what's the best structure to represent Term, they are can't type stable. Also, I defined abstract type Term end.
So, just simply:

mutable struct Implication{O <: TemporalOrder} <: Term
    comps::Vector{T} where T <: Term
    octime::UInt
end

struct ExtSet <: Term
    comps::Vector{T} where T <: Term
end

emm, any ideas? And I'm very appreciate your help! @rafaqz @jw3126

[rafaqz]

Always use type parameters. Vetcor{T} is not type stable. You can include that limitation with the type parameter as in the first example, but I normally wouldn't bother, and just keep it simple as in the second example.

 struct Implication{O <: TemporalOrder,C <: Vector{<:Term}} <: Term
    comps::C
    octime::UInt
end
# This is so `constructorof` will still work
Implication{O}(comps::C, octime) where {O,C} = Implication{O,C}(comps, octime) 

struct ExtSet{C} <: Term
    comps::C
end

[jw3126]

@AIxer feel free to reopen, if you still have questions.