Question

I’m working in Python here (which is actually pass-by-name, I think), but the idea is language-agnostic as long as method parameters behave similarly:

If I have a function like this:

def changefoo(source, destination):
    destination["foo"] = source
    return destination

and call it like so,

some_dict = {"foo": "bar"}
some_var = "a"

new_dict = changefoo(some_var, some_dict)

new_dict will be a modified version of some_dict, but some_dict will also be modified.

Assuming the mutable structure like the dict in my example will almost always be similarly small, and performance is not an issue (in application, I’m taking abstract objects and changing into SOAP requests for different services, where the SOAP request will take an order of magnitude longer than reformatting the data for each service), is this okay?

The destination in these functions (there are several, it’s not just a utility function like in my example) will always be mutable, but I like to be explicit: the return value of a function represents the outcome of a deterministic computation on the parameters you passed in. I don’t like using out parameters but there’s not really a way around this in Python when passing mutable structures to a function. A couple options I’ve mulled over:

• Copying the parameters that will be mutated, to preserve the original

  I’d have to copy the parameters in every function where I mutate them, which seems cumbersome and like I’m just duplicating a lot. Plus I don’t think I’ll ever actually need the original, it just seems messy to return a reference to the mutated object I already had.

• Just use it as an in/out parameter

  I don’t like this, it’s not immediately obvious what the function is doing, and I think it’s ugly.

• Create a decorator which will automatically copy the parameters

  Seems like overkill

So is what I’m doing okay? I feel like I’m hiding something, and a future programmer might think the original object is preserved based on the way I’m calling the functions (grabbing its result rather than relying on the fact that it mutates the original). But I also feel like any of the alternatives will be messy. Is there a more preferred way? Note that it’s not really an option to add a mutator-style method to the class representing the abstract data due to the way the software works (I would have to add a method to translate that data structure into the corresponding SOAP structure for every service we send that data off too–currently the translation logic is in a separate package for each service)

Answer 1

If you have a lot of functions like this, I think your best bet is to write a little class that wraps the dict and modifies it in-place:

class DictMunger(object):
    def __init__(self, original_dict):
        self.original_dict = original_dict

    def changefoo(source)
        self.original_dict['foo'] = source

some_dict = {"foo": "bar"}
some_var = "a"

munger = DictMunger(some_dict)
munger.changefoo(some_var)
# ...
new_dict = munger.original_dict

Objects modifying themselves is generally expected and reads well.