Would having a Pure Class concept make sense or not?

Question

I was wondering if pure classes make sense or not (as a concept)?

For example the constraints would be:

• No inheritance (only composition)

• All dependencies are passed in the constructor, or methods

For example:

class Elem {
  constructor(el) {
    this.el = el;
  }
  get html() {
    return this.el.innerHTML;
  }
  get cls() {
    return this.el.className.split(' ');
  }
  set cls(arr) {
    this.el.className(arr.join(' '));
  }
  hide() {
    this.el.style.display = 'none';
  }
}

const appEl = document.getElementById('app');
const app = new Elem(appEl);
app.cls = ['flex', 'h100'];
app.hide();

Just wondering if having such constraints would add benefits similar to pure functions?

Update

I think the above example is bad, because this.el lives somewhere else I guess (in the dom), but what about:

class One {
  constructor() {
    this.val = 1;
  }
  add(val) {
    return this.val + val;
  }
}

const one = new One;
one.add(6);

Answer 1

Using functions doesn't make you a functional programmer. You need to understand what is it that functional programming tries to achieve.

For example a pure function:

1. Does not mutate its argument(s)
2. Returns the same output for the same input
3. Has no side effects

So I hear that a class gets converted into function(s) under the hood... Fine. Will they be pure? It depends.

In your particular case, they're not. And that is because of the nature of the thing you're working with: a DOM element.

Your .html() method is almost guaranteed to be impure for example:

const el = document.querySelector('#foo');

const elem = new Elem(el);

elem.html();
//=> e.g. "foo"

el.innerHTML = "bar";

elem.html();
//=> "bar"

The outside world has the power to modify the behaviour of your functions. Hence your functions are impure and therefore your class and all its instances.

On the other hand, your class can also change the world:

elem.cls = ['become-super-big'];

This may or may not make your app unusable and/or conflicts with other parts of your app. That's definitely not a good thing.

What I personally try to achieve with functional programming (it's not easy believe me), is predictability. Your system and its smaller parts should all have a predictable behaviour under the same circumstance. Always, all the time. No compromise.

Can you have a pure class? Interesting question! Maybe. But certainly not in the way you're approaching it I'm afraid.