Benchmark: Immutable.Set Union vs Constructing a new plain JS Set

HTML Preparation code:

<script src="https://cdnjs.cloudflare.com/ajax/libs/immutable/3.8.2/immutable.min.js"></script>
<script src="https://cdn.jsdelivr.net/npm/immutability-helper@2.7.0/index.min.js"></script>

Tests:

Immutable.Set union
const set1_Immutable = new Immutable.Set(Array.from(Array(100).keys())); const set2_Immutable = new Immutable.Set(Array.from(Array(1000).keys())); const result = set1_Immutable.union(set2_Immutable)
Convert JS Set to array, construct new Set
const set1_JS = new Set(Array.from(Array(100).keys())); const set2_JS = new Set(Array.from(Array(1000).keys())); const result = new Set([...set1_JS, ...set2_JS])
Array.from, construct new Set
const set1_JS = new Set(Array.from(Array(100).keys())); const set2_JS = new Set(Array.from(Array(1000).keys())); const result = new Set(Array.from(set1_JS).concat(Array.from(set2_JS)))

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Immutable.Set union
Convert JS Set to array, construct new Set
Array.from, construct new Set

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 25 days ago):

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and explain what's being tested.

**Benchmark Overview**

The benchmark compares three approaches to performing set operations in JavaScript:

1. Immutable.Set union (using the Immutable.js library)
2. Converting JS Set to an array, constructing a new Set
3. Using Array.from and concatenating two Sets

**Options Compared**

Here are the options being compared:

* **Immutable.Set union**: This approach uses the Immutable.js library to create two immutable sets, `set1_Immutable` and `set2_Immutable`, and then performs a union operation on them.
* **Convert JS Set to array, construct new Set**: This approach converts both input Sets to arrays using `Array.from()`, creates two new empty Sets, and then uses the spread operator (`...`) to merge the two arrays into a single Set.
* **Array.from, construct new Set**: Similar to the previous option, this approach uses `Array.from()` to convert one of the input Sets to an array, concatenates that array with another array created from the second input Set using `Array.from()`, and then creates a new Set from the concatenated array.

**Pros and Cons**

Here are some pros and cons of each approach:

* **Immutable.Set union**: This approach provides immutability guarantees for both sets, which can be beneficial in concurrent programming or when working with large datasets. However, it requires importing the Immutable.js library, which may add a small performance overhead.
* **Convert JS Set to array, construct new Set**: This approach is straightforward and easy to implement. It avoids any additional library dependencies, making it a good choice for smaller projects or production code. However, converting Sets to arrays can be expensive operations, especially for large datasets.
* **Array.from, construct new Set**: This approach combines the benefits of both previous options. It uses `Array.from()` to convert one of the input Sets to an array, which is faster than converting both sets to arrays, and then concatenates that array with another array created from the second input Set. However, it still requires creating multiple intermediate arrays.

**Library Usage**

The benchmark uses two external libraries:

* **Immutable.js**: A library for working with immutable data structures in JavaScript.
* **immutability-helper**: A utility library for helping with common tasks related to immutability.

**Special JS Feature/Syntax**

There is no special JavaScript feature or syntax being used in this benchmark. All code snippets use standard ECMAScript 2020 syntax and features.

**Other Alternatives**

If you're interested in exploring alternative approaches, here are a few options:

* **Using the `Set` interface with `spread`**: Instead of converting Sets to arrays using `Array.from()`, you can use the spread operator (`...`) to merge two Sets into one. This approach is simpler and more efficient than converting both sets to arrays.
* **Using a custom Set implementation**: If performance is critical, you can consider implementing a custom Set data structure that provides optimized set operations.

Keep in mind that these alternatives may not provide the same level of immutability guarantees as using Immutable.js or the `Set` interface with `spread`.

Latest run results:

Run details: (Test run date: 19 hours ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36

Browser/OS: Chrome 130 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Immutable.Set union	10514.1 Ops/sec
Convert JS Set to array, construct new Set	17134.7 Ops/sec
Array.from, construct new Set	17809.6 Ops/sec

Related benchmarks:

Immutable.Set Union vs Constructing a new plain JS Set (version: 0)

Comparing performance of: Immutable.Set union vs Convert JS Set to array, construct new Set vs Array.from, construct new Set

Created: 2 years ago by: Guest

Jump to the latest result

Immutable.Set union

Convert JS Set to array, construct new Set

Array.from, construct new Set

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 25 days ago):