Can pure functions mutate other properties inside it's container class using `this`?

Question

I know that pure functions shouldn't mutate state that's not passed in as a parameter but I don't know if the this keyword is an exception to that rule. Here is a simple example of what I'm thinking:

 class Car {
    color: string = 'red';
    make: string = 'Dodge';

    constructor() {}

    changeMake(newMake: string): string {
      this.color = 'blue';  // <-- Is this impure?
      return newMake;
    }
  }

Is this impure? Why, or why not?

Aren't pure components functions? If you have `this`, that's the holder of state — Ruan Mendes, Jan 14 '19 at 19:05
Pure functions shouldn't mutate anything _at all_, save perhaps local variables that go out of scope anyways when the function is finished. — leftaroundabout, Jan 14 '19 at 19:07
it's impure because it has a different effect when `this` refers to different values — Mulan, Jan 14 '19 at 19:33

score 4 · Answer 1 · answered Jan 14 '19 at 22:23

No, you cannot mutate properties since that changes the value (object) and that is a side effect. Pure methods can expose their data, but never change them. They can create new objects and then they are considered pure:

class Car {
    color: string;
    make: string;

    constructor(color = 'red', make = 'Dodge') {
        this.color = color; 
        this.make = make;
    }

    changeMake(newMake: string): Car {
        return new Car(this.color, newMake);
    }
}

This creates a copy of the original car with the new make and thus every place the old object was used still has the old object.

A really good example of this is the Java String class, which is purely functional. Every method that returns a String that is different always return a newly constructed one. Quite a feat when thinking it was conceived in the golden age of OO.

Two additions: A language with reference values like JS `Object`s cannot be technically pure because it has referential identity instead of the required transparency. And when you work with `class`es and their hierarchies it is only natural to work with mutations as well, because such a design relies on mutations. — , Jan 15 '19 at 10:33

Can pure functions mutate other properties inside it's container class using `this`?

1 Answers1