Brunobkr/llama.cpp_AlgMor24_github

1# Immutable collections for JavaScript2 3[![Build Status](https://github.com/immutable-js/immutable-js/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/immutable-js/immutable-js/actions/workflows/ci.yml?query=branch%3Amain) [Chat on slack](https://immutable-js.slack.com)4 5[Read the docs](https://immutable-js.com/docs/) and eat your vegetables.6 7Docs are automatically generated from [README.md][] and [immutable.d.ts][].8Please contribute! Also, don't miss the [wiki][] which contains articles on9additional specific topics. Can't find something? Open an [issue][].10 11**Table of contents:**12 13- [Introduction](#introduction)14- [Getting started](#getting-started)15- [The case for Immutability](#the-case-for-immutability)16- [JavaScript-first API](#javascript-first-api)17- [Nested Structures](#nested-structures)18- [Equality treats Collections as Values](#equality-treats-collections-as-values)19- [Batching Mutations](#batching-mutations)20- [Lazy Seq](#lazy-seq)21- [Additional Tools and Resources](#additional-tools-and-resources)22- [Contributing](#contributing)23 24## Introduction25 26[Immutable][] data cannot be changed once created, leading to much simpler27application development, no defensive copying, and enabling advanced memoization28and change detection techniques with simple logic. [Persistent][] data presents29a mutative API which does not update the data in-place, but instead always30yields new updated data.31 32Immutable.js provides many Persistent Immutable data structures including:33`List`, `Stack`, `Map`, `OrderedMap`, `Set`, `OrderedSet` and `Record`.34 35These data structures are highly efficient on modern JavaScript VMs by using36structural sharing via [hash maps tries][] and [vector tries][] as popularized37by Clojure and Scala, minimizing the need to copy or cache data.38 39Immutable.js also provides a lazy `Seq`, allowing efficient40chaining of collection methods like `map` and `filter` without creating41intermediate representations. Create some `Seq` with `Range` and `Repeat`.42 43Want to hear more? Watch the presentation about Immutable.js:44 45[![Immutable Data and React](website/public/Immutable-Data-and-React-YouTube.png)](https://youtu.be/I7IdS-PbEgI)46 47[README.md]: https://github.com/immutable-js/immutable-js/blob/main/README.md48[immutable.d.ts]: https://github.com/immutable-js/immutable-js/blob/main/type-definitions/immutable.d.ts49[wiki]: https://github.com/immutable-js/immutable-js/wiki50[issue]: https://github.com/immutable-js/immutable-js/issues51[Persistent]: https://en.wikipedia.org/wiki/Persistent_data_structure52[Immutable]: https://en.wikipedia.org/wiki/Immutable_object53[hash maps tries]: https://en.wikipedia.org/wiki/Hash_array_mapped_trie54[vector tries]: https://hypirion.com/musings/understanding-persistent-vector-pt-155 56## Getting started57 58Install `immutable` using npm.59 60```shell61# using npm62npm install immutable63 64# using Yarn65yarn add immutable66 67# using pnpm68pnpm add immutable69 70# using Bun71bun add immutable72```73 74Then require it into any module.75 76```js77import { Map } from 'immutable';78const map1 = Map({ a: 1, b: 2, c: 3 });79const map2 = map1.set('b', 50);80map1.get('b') + ' vs. ' + map2.get('b'); // 2 vs. 5081```82 83### Browser84 85Immutable.js has no dependencies, which makes it predictable to include in a Browser.86 87It's highly recommended to use a module bundler like [webpack](https://webpack.js.org/),88[rollup](https://rollupjs.org/), or89[browserify](https://browserify.org/). The `immutable` npm module works90without any additional consideration. All examples throughout the documentation91will assume use of this kind of tool.92 93Alternatively, Immutable.js may be directly included as a script tag. Download94or link to a CDN such as [CDNJS](https://cdnjs.com/libraries/immutable)95or [jsDelivr](https://www.jsdelivr.com/package/npm/immutable).96 97Use a script tag to directly add `Immutable` to the global scope:98 99```html100<script src="immutable.min.js"></script>101<script>102  var map1 = Immutable.Map({ a: 1, b: 2, c: 3 });103  var map2 = map1.set('b', 50);104  map1.get('b'); // 2105  map2.get('b'); // 50106</script>107```108 109Or use an AMD-style loader (such as [RequireJS](https://requirejs.org/)):110 111```js112require(['./immutable.min.js'], function (Immutable) {113  var map1 = Immutable.Map({ a: 1, b: 2, c: 3 });114  var map2 = map1.set('b', 50);115  map1.get('b'); // 2116  map2.get('b'); // 50117});118```119 120### Flow & TypeScript121 122Use these Immutable collections and sequences as you would use native123collections in your [Flowtype](https://flowtype.org/) or [TypeScript](https://typescriptlang.org) programs while still taking124advantage of type generics, error detection, and auto-complete in your IDE.125 126Installing `immutable` via npm brings with it type definitions for Flow (v0.55.0 or higher)127and TypeScript (v4.5 or higher), so you shouldn't need to do anything at all!128 129#### Using TypeScript with Immutable.js v4+130 131Immutable.js type definitions embrace ES2015. While Immutable.js itself supports132legacy browsers and environments, its type definitions require TypeScript's 2015133lib. Include either `"target": "es2015"` or `"lib": "es2015"` in your134`tsconfig.json`, or provide `--target es2015` or `--lib es2015` to the135`tsc` command.136 137```js138import { Map } from 'immutable';139const map1 = Map({ a: 1, b: 2, c: 3 });140const map2 = map1.set('b', 50);141map1.get('b') + ' vs. ' + map2.get('b'); // 2 vs. 50142```143 144#### Using TypeScript with Immutable.js v3 and earlier:145 146Previous versions of Immutable.js include a reference file which you can include147via relative path to the type definitions at the top of your file.148 149```js150///<reference path='./node_modules/immutable/dist/immutable.d.ts'/>151import { Map } from 'immutable';152var map1: Map<string, number>;153map1 = Map({ a: 1, b: 2, c: 3 });154var map2 = map1.set('b', 50);155map1.get('b'); // 2156map2.get('b'); // 50157```158 159## The case for Immutability160 161Much of what makes application development difficult is tracking mutation and162maintaining state. Developing with immutable data encourages you to think163differently about how data flows through your application.164 165Subscribing to data events throughout your application creates a huge overhead of166book-keeping which can hurt performance, sometimes dramatically, and creates167opportunities for areas of your application to get out of sync with each other168due to easy to make programmer error. Since immutable data never changes,169subscribing to changes throughout the model is a dead-end and new data can only170ever be passed from above.171 172This model of data flow aligns well with the architecture of [React][]173and especially well with an application designed using the ideas of [Flux][].174 175When data is passed from above rather than being subscribed to, and you're only176interested in doing work when something has changed, you can use equality.177 178Immutable collections should be treated as _values_ rather than _objects_. While179objects represent some thing which could change over time, a value represents180the state of that thing at a particular instance of time. This principle is most181important to understanding the appropriate use of immutable data. In order to182treat Immutable.js collections as values, it's important to use the183`Immutable.is()` function or `.equals()` method to determine _value equality_184instead of the `===` operator which determines object _reference identity_.185 186```js187import { Map } from 'immutable';188const map1 = Map({ a: 1, b: 2, c: 3 });189const map2 = Map({ a: 1, b: 2, c: 3 });190map1.equals(map2); // true191map1 === map2; // false192```193 194Note: As a performance optimization Immutable.js attempts to return the existing195collection when an operation would result in an identical collection, allowing196for using `===` reference equality to determine if something definitely has not197changed. This can be extremely useful when used within a memoization function198which would prefer to re-run the function if a deeper equality check could199potentially be more costly. The `===` equality check is also used internally by200`Immutable.is` and `.equals()` as a performance optimization.201 202```js203import { Map } from 'immutable';204const map1 = Map({ a: 1, b: 2, c: 3 });205const map2 = map1.set('b', 2); // Set to same value206map1 === map2; // true207```208 209If an object is immutable, it can be "copied" simply by making another reference210to it instead of copying the entire object. Because a reference is much smaller211than the object itself, this results in memory savings and a potential boost in212execution speed for programs which rely on copies (such as an undo-stack).213 214```js215import { Map } from 'immutable';216const map = Map({ a: 1, b: 2, c: 3 });217const mapCopy = map; // Look, "copies" are free!218```219 220[React]: https://reactjs.org/221[Flux]: https://facebook.github.io/flux/docs/in-depth-overview/222 223## JavaScript-first API224 225While Immutable.js is inspired by Clojure, Scala, Haskell and other functional226programming environments, it's designed to bring these powerful concepts to227JavaScript, and therefore has an Object-Oriented API that closely mirrors that228of [ES2015][] [Array][], [Map][], and [Set][].229 230[es2015]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/New_in_JavaScript/ECMAScript_6_support_in_Mozilla231[array]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array232[map]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map233[set]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set234 235The difference for the immutable collections is that methods which would mutate236the collection, like `push`, `set`, `unshift` or `splice`, instead return a new237immutable collection. Methods which return new arrays, like `slice` or `concat`,238instead return new immutable collections.239 240```js241import { List } from 'immutable';242const list1 = List([1, 2]);243const list2 = list1.push(3, 4, 5);244const list3 = list2.unshift(0);245const list4 = list1.concat(list2, list3);246assert.equal(list1.size, 2);247assert.equal(list2.size, 5);248assert.equal(list3.size, 6);249assert.equal(list4.size, 13);250assert.equal(list4.get(0), 1);251```252 253Almost all of the methods on [Array][] will be found in similar form on254`Immutable.List`, those of [Map][] found on `Immutable.Map`, and those of [Set][]255found on `Immutable.Set`, including collection operations like `forEach()`256and `map()`.257 258```js259import { Map } from 'immutable';260const alpha = Map({ a: 1, b: 2, c: 3, d: 4 });261alpha.map((v, k) => k.toUpperCase()).join();262// 'A,B,C,D'263```264 265### Convert from raw JavaScript objects and arrays.266 267Designed to inter-operate with your existing JavaScript, Immutable.js268accepts plain JavaScript Arrays and Objects anywhere a method expects a269`Collection`.270 271```js272import { Map, List } from 'immutable';273const map1 = Map({ a: 1, b: 2, c: 3, d: 4 });274const map2 = Map({ c: 10, a: 20, t: 30 });275const obj = { d: 100, o: 200, g: 300 };276const map3 = map1.merge(map2, obj);277// Map { a: 20, b: 2, c: 10, d: 100, t: 30, o: 200, g: 300 }278const list1 = List([1, 2, 3]);279const list2 = List([4, 5, 6]);280const array = [7, 8, 9];281const list3 = list1.concat(list2, array);282// List [ 1, 2, 3, 4, 5, 6, 7, 8, 9 ]283```284 285This is possible because Immutable.js can treat any JavaScript Array or Object286as a Collection. You can take advantage of this in order to get sophisticated287collection methods on JavaScript Objects, which otherwise have a very sparse288native API. Because Seq evaluates lazily and does not cache intermediate289results, these operations can be extremely efficient.290 291```js292import { Seq } from 'immutable';293const myObject = { a: 1, b: 2, c: 3 };294Seq(myObject)295  .map((x) => x * x)296  .toObject();297// { a: 1, b: 4, c: 9 }298```299 300Keep in mind, when using JS objects to construct Immutable Maps, that301JavaScript Object properties are always strings, even if written in a quote-less302shorthand, while Immutable Maps accept keys of any type.303 304```js305import { fromJS } from 'immutable';306 307const obj = { 1: 'one' };308console.log(Object.keys(obj)); // [ "1" ]309console.log(obj['1'], obj[1]); // "one", "one"310 311const map = fromJS(obj);312console.log(map.get('1'), map.get(1)); // "one", undefined313```314 315Property access for JavaScript Objects first converts the key to a string, but316since Immutable Map keys can be of any type the argument to `get()` is317not altered.318 319### Converts back to raw JavaScript objects.320 321All Immutable.js Collections can be converted to plain JavaScript Arrays and322Objects shallowly with `toArray()` and `toObject()` or deeply with `toJS()`.323All Immutable Collections also implement `toJSON()` allowing them to be passed324to `JSON.stringify` directly. They also respect the custom `toJSON()` methods of325nested objects.326 327```js328import { Map, List } from 'immutable';329const deep = Map({ a: 1, b: 2, c: List([3, 4, 5]) });330console.log(deep.toObject()); // { a: 1, b: 2, c: List [ 3, 4, 5 ] }331console.log(deep.toArray()); // [ 1, 2, List [ 3, 4, 5 ] ]332console.log(deep.toJS()); // { a: 1, b: 2, c: [ 3, 4, 5 ] }333JSON.stringify(deep); // '{"a":1,"b":2,"c":[3,4,5]}'334```335 336### Embraces ES2015337 338Immutable.js supports all JavaScript environments, including legacy339browsers (even IE11). However it also takes advantage of features added to340JavaScript in [ES2015][], the latest standard version of JavaScript, including341[Iterators][], [Arrow Functions][], [Classes][], and [Modules][]. It's inspired342by the native [Map][] and [Set][] collections added to ES2015.343 344All examples in the Documentation are presented in ES2015. To run in all345browsers, they need to be translated to ES5.346 347```js348// ES2015349const mapped = foo.map((x) => x * x);350// ES5351var mapped = foo.map(function (x) {352  return x * x;353});354```355 356All Immutable.js collections are [Iterable][iterators], which allows them to be357used anywhere an Iterable is expected, such as when spreading into an Array.358 359```js360import { List } from 'immutable';361const aList = List([1, 2, 3]);362const anArray = [0, ...aList, 4, 5]; // [ 0, 1, 2, 3, 4, 5 ]363```364 365Note: A Collection is always iterated in the same order, however that order may366not always be well defined, as is the case for the `Map` and `Set`.367 368[Iterators]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/The_Iterator_protocol369[Arrow Functions]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions370[Classes]: https://wiki.ecmascript.org/doku.php?id=strawman:maximally_minimal_classes371[Modules]: https://www.2ality.com/2014/09/es6-modules-final.html372 373## Nested Structures374 375The collections in Immutable.js are intended to be nested, allowing for deep376trees of data, similar to JSON.377 378```js379import { fromJS } from 'immutable';380const nested = fromJS({ a: { b: { c: [3, 4, 5] } } });381// Map { a: Map { b: Map { c: List [ 3, 4, 5 ] } } }382```383 384A few power-tools allow for reading and operating on nested data. The385most useful are `mergeDeep`, `getIn`, `setIn`, and `updateIn`, found on `List`,386`Map` and `OrderedMap`.387 388```js389import { fromJS } from 'immutable';390const nested = fromJS({ a: { b: { c: [3, 4, 5] } } });391 392const nested2 = nested.mergeDeep({ a: { b: { d: 6 } } });393// Map { a: Map { b: Map { c: List [ 3, 4, 5 ], d: 6 } } }394 395console.log(nested2.getIn(['a', 'b', 'd'])); // 6396 397const nested3 = nested2.updateIn(['a', 'b', 'd'], (value) => value + 1);398console.log(nested3);399// Map { a: Map { b: Map { c: List [ 3, 4, 5 ], d: 7 } } }400 401const nested4 = nested3.updateIn(['a', 'b', 'c'], (list) => list.push(6));402// Map { a: Map { b: Map { c: List [ 3, 4, 5, 6 ], d: 7 } } }403```404 405## Equality treats Collections as Values406 407Immutable.js collections are treated as pure data _values_. Two immutable408collections are considered _value equal_ (via `.equals()` or `is()`) if they409represent the same collection of values. This differs from JavaScript's typical410_reference equal_ (via `===` or `==`) for Objects and Arrays which only411determines if two variables represent references to the same object instance.412 413Consider the example below where two identical `Map` instances are not414_reference equal_ but are _value equal_.415 416```js417// First consider:418const obj1 = { a: 1, b: 2, c: 3 };419const obj2 = { a: 1, b: 2, c: 3 };420obj1 !== obj2; // two different instances are always not equal with ===421 422import { Map, is } from 'immutable';423const map1 = Map({ a: 1, b: 2, c: 3 });424const map2 = Map({ a: 1, b: 2, c: 3 });425map1 !== map2; // two different instances are not reference-equal426map1.equals(map2); // but are value-equal if they have the same values427is(map1, map2); // alternatively can use the is() function428```429 430Value equality allows Immutable.js collections to be used as keys in Maps or431values in Sets, and retrieved with different but equivalent collections:432 433```js434import { Map, Set } from 'immutable';435const map1 = Map({ a: 1, b: 2, c: 3 });436const map2 = Map({ a: 1, b: 2, c: 3 });437const set = Set().add(map1);438set.has(map2); // true because these are value-equal439```440 441Note: `is()` uses the same measure of equality as [Object.is][] for scalar442strings and numbers, but uses value equality for Immutable collections,443determining if both are immutable and all keys and values are equal444using the same measure of equality.445 446[object.is]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is447 448#### Performance tradeoffs449 450While value equality is useful in many circumstances, it has different451performance characteristics than reference equality. Understanding these452tradeoffs may help you decide which to use in each case, especially when used453to memoize some operation.454 455When comparing two collections, value equality may require considering every456item in each collection, on an `O(N)` time complexity. For large collections of457values, this could become a costly operation. Though if the two are not equal458and hardly similar, the inequality is determined very quickly. In contrast, when459comparing two collections with reference equality, only the initial references460to memory need to be compared which is not based on the size of the collections,461which has an `O(1)` time complexity. Checking reference equality is always very462fast, however just because two collections are not reference-equal does not rule463out the possibility that they may be value-equal.464 465#### Return self on no-op optimization466 467When possible, Immutable.js avoids creating new objects for updates where no468change in _value_ occurred, to allow for efficient _reference equality_ checking469to quickly determine if no change occurred.470 471```js472import { Map } from 'immutable';473const originalMap = Map({ a: 1, b: 2, c: 3 });474const updatedMap = originalMap.set('b', 2);475updatedMap === originalMap; // No-op .set() returned the original reference.476```477 478However updates which do result in a change will return a new reference. Each479of these operations occur independently, so two similar updates will not return480the same reference:481 482```js483import { Map } from 'immutable';484const originalMap = Map({ a: 1, b: 2, c: 3 });485const updatedMap = originalMap.set('b', 1000);486// New instance, leaving the original immutable.487updatedMap !== originalMap;488const anotherUpdatedMap = originalMap.set('b', 1000);489// Despite both the results of the same operation, each created a new reference.490anotherUpdatedMap !== updatedMap;491// However the two are value equal.492anotherUpdatedMap.equals(updatedMap);493```494 495## Batching Mutations496 497> If a tree falls in the woods, does it make a sound?498>499> If a pure function mutates some local data in order to produce an immutable500> return value, is that ok?501>502> — Rich Hickey, Clojure503 504Applying a mutation to create a new immutable object results in some overhead,505which can add up to a minor performance penalty. If you need to apply a series506of mutations locally before returning, Immutable.js gives you the ability to507create a temporary mutable (transient) copy of a collection and apply a batch of508mutations in a performant manner by using `withMutations`. In fact, this is509exactly how Immutable.js applies complex mutations itself.510 511As an example, building `list2` results in the creation of 1, not 3, new512immutable Lists.513 514```js515import { List } from 'immutable';516const list1 = List([1, 2, 3]);517const list2 = list1.withMutations(function (list) {518  list.push(4).push(5).push(6);519});520assert.equal(list1.size, 3);521assert.equal(list2.size, 6);522```523 524Note: Immutable.js also provides `asMutable` and `asImmutable`, but only525encourages their use when `withMutations` will not suffice. Use caution to not526return a mutable copy, which could result in undesired behavior.527 528_Important!_: Only a select few methods can be used in `withMutations` including529`set`, `push` and `pop`. These methods can be applied directly against a530persistent data-structure where other methods like `map`, `filter`, `sort`,531and `splice` will always return new immutable data-structures and never mutate532a mutable collection.533 534## Lazy Seq535 536`Seq` describes a lazy operation, allowing them to efficiently chain537use of all the higher-order collection methods (such as `map` and `filter`)538by not creating intermediate collections.539 540**Seq is immutable** — Once a Seq is created, it cannot be541changed, appended to, rearranged or otherwise modified. Instead, any mutative542method called on a `Seq` will return a new `Seq`.543 544**Seq is lazy** — `Seq` does as little work as necessary to respond to any545method call. Values are often created during iteration, including implicit546iteration when reducing or converting to a concrete data structure such as547a `List` or JavaScript `Array`.548 549For example, the following performs no work, because the resulting550`Seq`'s values are never iterated:551 552```js553import { Seq } from 'immutable';554const oddSquares = Seq([1, 2, 3, 4, 5, 6, 7, 8])555  .filter((x) => x % 2 !== 0)556  .map((x) => x * x);557```558 559Once the `Seq` is used, it performs only the work necessary. In this560example, no intermediate arrays are ever created, filter is called three561times, and map is only called once:562 563```js564oddSquares.get(1); // 9565```566 567Any collection can be converted to a lazy Seq with `Seq()`.568 569```js570import { Map, Seq } from 'immutable';571const map = Map({ a: 1, b: 2, c: 3 });572const lazySeq = Seq(map);573```574 575`Seq` allows for the efficient chaining of operations, allowing for the576expression of logic that can otherwise be very tedious:577 578```js579lazySeq580  .flip()581  .map((key) => key.toUpperCase())582  .flip();583// Seq { A: 1, B: 2, C: 3 }584```585 586As well as expressing logic that would otherwise seem memory or time587limited, for example `Range` is a special kind of Lazy sequence.588 589```js590import { Range } from 'immutable';591Range(1, Infinity)592  .skip(1000)593  .map((n) => -n)594  .filter((n) => n % 2 === 0)595  .take(2)596  .reduce((r, n) => r * n, 1);597// 1006008598```599 600## Comparison of filter(), groupBy(), and partition()601 602The `filter()`, `groupBy()`, and `partition()` methods are similar in that they603all divide a collection into parts based on applying a function to each element.604All three call the predicate or grouping function once for each item in the605input collection. All three return zero or more collections of the same type as606their input. The returned collections are always distinct from the input607(according to `===`), even if the contents are identical.608 609Of these methods, `filter()` is the only one that is lazy and the only one which610discards items from the input collection. It is the simplest to use, and the611fact that it returns exactly one collection makes it easy to combine with other612methods to form a pipeline of operations.613 614The `partition()` method is similar to an eager version of `filter()`, but it615returns two collections; the first contains the items that would have been616discarded by `filter()`, and the second contains the items that would have been617kept. It always returns an array of exactly two collections, which can make it618easier to use than `groupBy()`. Compared to making two separate calls to619`filter()`, `partition()` makes half as many calls it the predicate passed to620it.621 622The `groupBy()` method is a more generalized version of `partition()` that can623group by an arbitrary function rather than just a predicate. It returns a map624with zero or more entries, where the keys are the values returned by the625grouping function, and the values are nonempty collections of the corresponding626arguments. Although `groupBy()` is more powerful than `partition()`, it can be627harder to use because it is not always possible predict in advance how many628entries the returned map will have and what their keys will be.629 630| Summary                       | `filter` | `partition` | `groupBy`      |631| :---------------------------- | :------- | :---------- | :------------- |632| ease of use                   | easiest  | moderate    | hardest        |633| generality                    | least    | moderate    | most           |634| laziness                      | lazy     | eager       | eager          |635| # of returned sub-collections | 1        | 2           | 0 or more      |636| sub-collections may be empty  | yes      | yes         | no             |637| can discard items             | yes      | no          | no             |638| wrapping container            | none     | array       | Map/OrderedMap |639 640## Additional Tools and Resources641 642- [Atom-store](https://github.com/jameshopkins/atom-store/)643 644  - A Clojure-inspired atom implementation in Javascript with configurability645    for external persistance.646 647- [Chai Immutable](https://github.com/astorije/chai-immutable)648 649  - If you are using the [Chai Assertion Library](https://chaijs.com/), this650    provides a set of assertions to use against Immutable.js collections.651 652- [Fantasy-land](https://github.com/fantasyland/fantasy-land)653 654  - Specification for interoperability of common algebraic structures in JavaScript.655 656- [Immutagen](https://github.com/pelotom/immutagen)657 658  - A library for simulating immutable generators in JavaScript.659 660- [Immutable-cursor](https://github.com/redbadger/immutable-cursor)661 662  - Immutable cursors incorporating the Immutable.js interface over663    Clojure-inspired atom.664 665- [Immutable-ext](https://github.com/DrBoolean/immutable-ext)666 667  - Fantasyland extensions for immutablejs668 669- [Immutable-js-tools](https://github.com/madeinfree/immutable-js-tools)670 671  - Util tools for immutable.js672 673- [Immutable-Redux](https://github.com/gajus/redux-immutable)674 675  - redux-immutable is used to create an equivalent function of Redux676    combineReducers that works with Immutable.js state.677 678- [Immutable-Treeutils](https://github.com/lukasbuenger/immutable-treeutils)679 680  - Functional tree traversal helpers for ImmutableJS data structures.681 682- [Irecord](https://github.com/ericelliott/irecord)683 684  - An immutable store that exposes an RxJS observable. Great for React.685 686- [Mudash](https://github.com/brianneisler/mudash)687 688  - Lodash wrapper providing Immutable.JS support.689 690- [React-Immutable-PropTypes](https://github.com/HurricaneJames/react-immutable-proptypes)691 692  - PropType validators that work with Immutable.js.693 694- [Redux-Immutablejs](https://github.com/indexiatech/redux-immutablejs)695 696  - Redux Immutable facilities.697 698- [Rxstate](https://github.com/yamalight/rxstate)699 700  - Simple opinionated state management library based on RxJS and Immutable.js.701 702- [Transit-Immutable-js](https://github.com/glenjamin/transit-immutable-js)703  - Transit serialisation for Immutable.js.704  - See also: [Transit-js](https://github.com/cognitect/transit-js)705 706Have an additional tool designed to work with Immutable.js?707Submit a PR to add it to this list in alphabetical order.708 709## Contributing710 711Use [Github issues](https://github.com/immutable-js/immutable-js/issues) for requests.712 713We actively welcome pull requests, learn how to [contribute](https://github.com/immutable-js/immutable-js/blob/main/.github/CONTRIBUTING.md).714 715Immutable.js is maintained within the [Contributor Covenant's Code of Conduct](https://www.contributor-covenant.org/version/2/0/code_of_conduct/).716 717### Changelog718 719Changes are tracked as [Github releases](https://github.com/immutable-js/immutable-js/releases).720 721### License722 723Immutable.js is [MIT-licensed](./LICENSE).724 725### Thanks726 727[Phil Bagwell](https://www.youtube.com/watch?v=K2NYwP90bNs), for his inspiration728and research in persistent data structures.729 730[Hugh Jackson](https://github.com/hughfdjackson/), for providing the npm package731name. If you're looking for his unsupported package, see [this repository](https://github.com/hughfdjackson/immutable).732