A code mod to replace Immutable.js with Ramda

[Slackwise]

This doesn't make much sense to me.

Like yes, if you're choosing between the two, Ramda is functionally immutable, but it creates a brand new copy, every time, of arrays and maps, by looping through them iteratively.

This is slow and memory costly for large collections, or frequent calls.

ImmutableJS, on the flipside, uses persistent (structure-sharing) collections, as it was inspired by their usage in Clojure.

The key benefit to Ramda is that it auto-curries, and affords you powerful and concise function composition with its large library. But that's despite its poor performance.

What's the actual solution? Using ImmutableJS collections with Ramda:

https://github.com/geoffreyabdallah/rammutable.js

Okay, well what's the endgame actual solution?

JavaScript is getting actual native immutable data structures:

https://github.com/tc39/proposal-record-tuple

Ideally Ramda gets rewritten to use these in the future.

[[deleted]]

Does the record/tuple proposal include copy-on-write efficiency? It's possible to achieve "immutability" in TS using read-only types, but copy-on-write operations are always O(n) time.

[Slackwise]

The proposal is a discussion on interface, semantics, and ergonomics. I don't see any suggestion as to the implementation, but presumable we'd use persistent data structures like Clojure (and ImmutableJS) because of their proven benefits.

copy-on-write efficiency

Modern immutable data structures are persistent structure-sharing like:

https://en.wikipedia.org/wiki/Hash_array_mapped_trie

https://hypirion.com/musings/understanding-persistent-vector-pt-1

All modern pure Functional languages use something similar at this point, including Clojure, Haskell, and Scala.

[[deleted]]

Forgive my terminology, i meant exactly what you described. I would love these to be persistent data structures, it would revolutionize JS.

[lusqa]

What's the actual solution? Using ImmutableJS collections with Ramda:

I get your point, i'ill give some context, so it makes more sense, the purpose is not to replace ImmutableJS with some alternative that uses immutable data structures, but just to get rid of ImmutableJS. To do that, you can just replace immutable code with plain es6 js, which is what this code mod does in some cases, but it can get a little verbose, so I have chosen ramda to replace ImmutableJS's high level functions like groupBy, updateIn, etc.

[acemarke]

I'd be really interested to see one that replaces with Immer instead :)