Could we detect when this is happening, just by comparing the namespace/package of the two classes, and perform some sort of lazy updating behind the scenes? There would then be no need for something like new_external_class(). Not being familiar with how things are implemented, I'm not sure about feasibility, but I could imagine tracking some sort of timestamp or hash that minimizes the overhead of this.

We could also use the package field of the class object to do this automatically.

Regardless, we may still need some optional additional way of lazily registering classes in case you want to extend a class from a suggested package or for #250. But hopefully we can reserve new_external_class() for rare cases, like we now have for new_external_generic() .

I think the easiest way to start prototyping this is to allow parent to be a zero-argument function that you can call to dynamically get the parent class, and then see what breaks. Once that's complete we can figure out a more user friendly interface.

Ways in which the parent is currently used:

• To determine the full set of properties. I think it's ok to keep this static — if a foreign-package superclass adds new properties, you won't be able to access them until you rebuild. But the existing code can't already use them so this shouldn't affect behaviour. (Except if the superclass adds a property with the same name as your class; but that's a problem no matter what you do because adding superclass properties is a potential breaking change).
• In the default constructor. But we already branch based on whether the class is base/S3/S7 so we could easily add a new branch for a function call.
• Stored in the parent attribute, which is used only in a handful of places.

I think we want this to be purely dynamic; another option would be to somehow replace a static class definition at package load time but I think that would require either walking over every object in the package environment or replacing the parent class definition with a reference type where we could modify in one place.

Ways that a parent class might change (to help me think about the problem):

How could a parent class change?

• It could add a new property:
• It could remove a property
• It could make a property more permissive
• It could make a property more restrictive
• It could change the property class
• It could change the property default
• It could change its constructor
• It could make the validator more strict
• It could make the validator more permissive
• It could change its parent
• It could change its name/package
• It could change its abstract status