If anything, this is a simplification.
This one stays just the same as before; it's the operation that creates an s-table, a type object and ties everything together.
This partially replaces instance_of, but it only does the memory allocation portion of the work. We'll also need it for auto-boxing and cloning. The object passed is most likely a type object, but could be any instance; it's the s-table that matters usually.
Used to initialize the body of an object representing the type describe by the specified s-table. DATA points to the body. It may recursively call initialize for any flattened objects.
For the given type, copies the object data from the source memory location to the destination one. Note that it may actually be more involved than a straightforward bit of copying - what's important is that the representation knows about that. Once again, it may have to call copy_to recursively on representations of any flattened objects in its body.
Is the object, from the representation's point of view, defined (that is, an instance) or not (that is, a type object)? This also stays the same. It only makes sense to ask this of a complete object, so it need not change.
Returns the attribute value as an object. For non-flattened objects - that is, reference types - this just returns the object stored in the attribute. For the flattened case, this will auto-box (an allocate followed by a copy_to).
Gets the memory address of an attribute within an object. Anything doing this presumably knows quite a bit about the type of the attribute. This subsumes the int, num and str variants of get_attribute, and also works out well for any flattened objects. Note that any consumer of this is responsible for making sure the reference lasts no longer than the object it was obtained from.
Binds an attribute. If it's a reference type attribute, this just simply sets the value in place. If instead it's some other flattened in representation, then the value should be a boxed form of the data we want to store.
Binds a flattened in attribute to the value at the passed reference. Like with the get_attribute_ref function, presumably the thing calling this knows about the type of the attribute it is supplying data for. copy_to will be used to copy the data in to place.
Mostly the same, apart from the API changed to split it to get s-table and data, like the other attribute related operations.
Stay the same, apart from the s-table/data split as per normal. They may also delegate, but that's entirely up to the REPR. Note that these do not get merged like the attribute ones, since they may have more coercy semantics rather than pure storage ones.
Stay the same, apart from the s-table/data split as per normal. They may also delegate, but that's entirely up to the REPR.
Sometimes, a certain attribute may be flagged as the "default" one of a certain type, which can be used in boxing-ish situations but for more complex objects. In that case, this gets the address of the attribute serving as the "box target" for the type in question.
Stays pretty much as it is. Only makes sense to do to an object as a whole.
Stays the same. In some ways, by taking the s-table this kind of foretold many of the things that changed in here.
Marks what's in an object, if needed. Note that it is no longer responsible for marking the s-table and serialization context pointers.
Frees a (top-level, never a flattened in) object. If any complex objects with parts needing freeing are embedded, this will need to call gc_cleanup for them.
Responsible for freeing any resources associated with an object's body. Used to clear up when one object has another complex object flattened into it.
Renamed to say that it really does, but otherwise the same.