Errors Not Thrown on Array.Push

[andrewjmead]

First, thanks for the library. I love that it throws error so I can watch my tests fail.

I'm having an issue with the following snippet:

var arr = immu([])
arr.push('one'); // Does not throw an error (array does not update)

var obj = immu({});
obj.key = 'val'; // Throws an error (object does not update)

Trying to mutate an object runs as expected. The object does not get updated and an error is thrown.

Trying to mutate an array doesn't update the array, but it doesn't throw an error.

Is this expected behavior? Thanks!

[scottcorgan]

.push() doesn't actually throw an error because it aims to replicate the functionality of regular Javascript objects as much as possible. Here, .push() will add an it to the end of the array and return a new array (see the implementation here).

But, you make a could point. Should methods that mutate throw errors or should the perform the action in an immutable way?

[andrewjmead]

Thanks for the information!

I was not aware that a new implementation was being added for array methods that would otherwise update the array. I probably understood the goal of the library. I was looking for a library I could use during tests to make sure my Redux reducers didn't change the state or action argument passed in.

But, you make a could point. Should methods that mutate throw errors or should the perform the action in an immutable way?

Personally, I wouldn't use a library that changes the behavior of the JavaScript methods. I'd rather use the proper method (ES6 spread or .concat()) and avoid bad habits.

What could be useful is error messages that explain why it's mutating the object. For example, calling .push on an "immued" object would throw an error that directs the user towards the correct solution such as concat.

[scottcorgan]

You make very interesting points.

I think the original aim for the library was to mimic the Javascript api for objects and arrays, and just throw helpful errors when the user tries to mutate anything. In that spirit, all the methods were changed to be immutable if they were original mutable.

I'm open to starting a new library that just throws errors on use of any mutation and leaves the methods as-is.

Thoughts?

[andrewjmead]

Hey @scottcorgan.

I think both are useful. I originally used deep-freeze which prevents modifications but doesn't throw errors when a modification is attempted.

I then found deep-freeze-strict which will throw errors in my tests if the object in question gets modified.

[ajhyndman]

I sympathize with @andrewjmead's suggestion here.

I actually have been searching for a minimal, well-supported way to guarantee immutability while using something completely functional (like Ramda) for modification.

Thanks for putting this library together, and sharing it!

[ghost]

Yes, I really am looking for a lib that just properly freezies everything, removes mutators and that's it. I don't want to be coupled to a immutability library because someone relies on using their mutator methods.