What do you call a process which transforms objects of complex types into simple objects of primitive types? [closed]

Question

My first thought was that I'm "serializing" the complex object, but from what I understand that means I'm reducing it down to a string or binary format which could be passed over a network. While what I am actually doing is converting a complex object to more primitive types like list, dict, str, int, float, etc. The context here is python, and I'm trying to rename my function to_dict(...) to something which uses a more idiomatic/industry accepted term.

Currently I'm doing this:

class SomeComplexClass: ... my_complex_obj = SomeComplexClass(...) simple_obj = to_dict(my_complex_obj) simple_obj['foo'] = 'bar' return to_json(simple_obj) 

As you see, I'll typically do some final adjustments to the object, then pass this to a library which knows how to convert this into a JSON string, which is passed over the network as HTTP response. This function is used 608 times in our code base.

Here to_dict(...) is doing some heavy lifting, by recursively walking through the complex object and handling corner cases etc., it even supports multiple types of complex objects, even lists of objects.

It is this last part which makes me question the name to_dict(...), because I at some time extended it to support lists as the top level object type. It feels a little silly to do list_of_simple_objects = to_dict(my_list_of_complex_objects), because it then returns a list of dicts.

Answer 1

As blunova writes, "descriptive" is good, but depending on what perspective you have on your objects, the description might turn out very different!

For instance: if you perform this action only as a prerequisite to serializing them, 'preSerialize()' might be a good description. To emphasize that you're really doing the opposite of what a constructor does, 'deconstruct()' would be descriptive. If you're pragmatic about object-orientation and only define your own classes to get better type-checking and code completion, then 'untype()' expresses that you're turning a custom-tailored object with typed fields back into a generic glob of lists/maps/scalars. (Personally, I would probably go with Filip's comment of "to_primitives()".)

Answer 2

I always try to be as descriptive as possible when naming things so other can quickly understand what my code is doing, so I would not call the function just to_dict() because it seems to me not descriptive enough.

When naming function I stick to the convention of having a verb in the name. So I would call your function something like convert_complex_to_simple_type().

If I have to work/maintain your code, especially if I am not as experienced as you are, and see the to_dict() function I immediately understand that something is going to be converted to a dictionary but maybe I would appreciate to understand more about the nature of what is going to be converted just by looking at the name of the function.

Within reasonable limits, I prefer a name a little bit longer but very descriptive, than one that is shorter but less clear.