What is the term used to describe a function/method that modifies the object it's called on?

Question

Sorry for the generic question. I have searched all over and found so many threads similar to this, however not one that answers my specific question - perhaps because the term I'm looking for doesn't even exist.

A friend of mine is learning programming, JavaScript specifically, and he asked me why this wasn't working:

var a = "Hello World";
a.replace("Hello", "Goodbye");

console.log(a)  // Logs "Hello World"

The reason is because replace does not modify a, as strings are immutable in JavaSript. Becuase it returns a string, you'd need to do something like...

var a = "Hello World";
a = a.replace("Hello", "Goodbye");

console.log(a);  // Logs "Goodbye World"

---

However, the alternative is a function like JavaScript's reverse(), as it modifies whatever calls it. For example:

var fruits = ["Apples", "Oranges", "Bananas"];
fruits.reverse();

console.log(fruits)  // ["Bananas", "Oranges", "Apples"]

When my friend asked me why his replace wasn't working, I realized I was reaching for a word that I don't know (as far as I'm aware)...

"You have to set the string to "string dot replace", because the replace function is ________."

You don't need to set an array equal to "array dot reverse", because reverse is ________."

I'm familiar with prototype functions though I don't believe that's the word I'm looking for. Can anyone help me fill in these blanks?

Answer 1

The pair of concepts that you are looking for are mutable/immutable parameters and in-place/returning of results.

In your examples:

You have to set the string to "string dot replace", because the replace function operates on a string which, in python, is immutable so the replace function returns a new string.

For a C/C++ programmer this is more familiar as parameters "passed by value", rather than "passed by reference", which makes them immutable and returning the result.

You don't need to set an array equal to "array dot reverse", because reverse operates on an array, which is mutable, so is able to make changes in-place before returning.

In languages such as C/C++ this is known as parameters "passed by reference" i.e. passing the address which, if unmodified by const, allows the function to change, mutate, the contents of that address altering the results in-place before returning.

Of course it is not unusual to have a function that returns results by both mechanisms, e.g. int SomeFn(int p1, int p2, int *ErrCode) can, potentially return results both in the return value and by modifying the contents of ErrCode.

A 3rd Method

For completeness a 3rd mechanism for returning results is by side-effect or global, i.e. modifying file scope, program wide, shared or environmental values. This is generally considered bad news as, unless very well documented, you can only find out what is being changed by careful reading of the code. In languages such as C/C++ this is all too easy to do by having an outer scope variable with a given name, possibly even in another module, and no masking local scope variable of the same name. In Python, while you can read the values of values in outer scopes, unless outer scope values are explicitly set as available to be modified with the global keyword, attempting to modify an outer scope variable automatically creates a local of the same name.

Answer 2

My preferred way to express it is:

• The Array reverse method is mutating. It's a mutator. A common special case is a setter.

• The String replace method is non-mutating. It's not a mutator. If it doesn't modify anything, it's side-effect free. A common special case is a getter.

• Since JavaScript Strings are immutable, String methods cannot be mutating.

  "Hello World".replace("Hello", "Goodbye");

  should make you uncomfortable. It doesn't modify a string literal. It discards the result. Static code analyzers can sometimes detect such bugs.

• Since JavaScript Arrays are mutable, Array methods can be mutating. JavaScript tends to use Arrays as local storage bins, easily modified and infrequently copied.

Answer 3

Sometimes, when used in the context of pure functional programming, I've heard functions that modify the input value (and therefore are not pure functions) called destructive. I'm not sure if this is the correct term, though.

In your case, you would say:

You have to set the string to "string dot replace", because the replace function is not destructive.

You don't need to set an array equal to "array dot reverse", because reverse is destructive.

Answer 4

Perhaps pure is the word you're looking for?

replace() is (or appears to be) pure because it doesn't look like it has any side-effects (i.e., modifying the string) whereas reverse() is impure because it changes the state of the array.

Answer 5

These would usually be separated into functions and methods (where methods are a subset of functions). A function is a section of code that can be called in isolation, whereas a method has a concept of a current 'context' on which it operates. The action of a method changes the state of its context.

In object oriented programming, the context is the instance that the function is operating on.

Answer 6

I don't know that there is an official answer, but here's two you might like.

Procedure

Only because it seemed like a good answer to this question, which looks a lot like your question BTW-- you should check it out.

In-place unary operation

Review this page: java.util.function. It provides a sort of made-up name for delegates (input/output signatures) of various prototypes, e.g. a delegate which takes an argument and returns nothing is called a consumer.

Now, as an astute student of OOP, you ought to be aware that an a method is just a function which takes a hidden parameter (this). Since it is supplied as a reference, it serves as both an input and an output parameter.

According to these Java guys (and they seem pretty smart), a delegate which accepts a single input and returns a value of the same type is called an unary operator.

Now in the case of array::Reverse(), an array is not immutable, and can potentially take up a lot of space, so it is more efficient and convenient to perform the operation in place. Therefore Reverse() is an in-place unary operator.

But to me, an "operator" is a special symbol (like the addition operator, also known as +) or a mathematical keyword like mod. Therefore I prefer to call it an operation, yielding in-place unary operation.