Benchmark: ramda-transducer w/mutations v2

HTML Preparation code:

<script src="https://rawgit.com/ramda/ramda/master/dist/ramda.js"></script>

Script Preparation code:

var ids = Array.from({ length: 10000 }, (_, index) => index + 1)
var isPositive = i => i % 2 === 0

Tests:

Array(map + filter)
ids.map(R.identity).filter(isPositive).map(R.inc)
ramda(map + filter)
R.pipe( R.map(R.identity), R.filter(isPositive), R.map(R.inc) )(ids)
ramda-transducer(map + filter)
const transform = R.pipe( R.map(R.identity), R.filter(isPositive), R.map(R.inc) ) R.transduce( transform, (acc, item) => { acc.push(item); return acc; }, [], ids, );
Array(combined map reduce)
ids.reduce((acc, item) => { const identity = R.identity(item) if (!isPositive(identity)) return acc acc.push(R.inc(identity)) return acc }, [])

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Array(map + filter)
ramda(map + filter)
ramda-transducer(map + filter)
Array(combined map reduce)

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

**Benchmark Explanation**

The provided benchmark is designed to measure the performance of different approaches for filtering and mapping arrays in JavaScript. The test cases compare the execution time of various methods, including:

1. **Array.prototype.map() + Array.prototype.filter()**: This approach uses the native JavaScript `map()` and `filter()` methods.
2. **Ramda's `map()` + filter()`**: This approach uses Ramda's functional programming library to chain together three functions: `R.map(R.identity)`, `R.filter(isPositive)`, and `R.map(R.inc)`.
3. **Ramda's `transduce()` with a custom transformation function**: This approach uses Ramda's `transduce()` method, which applies a transformation function to an array while accumulating the results in an accumulator.
4. **Array.prototype.reduce() + Array.prototype.filter()**: This approach uses the native JavaScript `reduce()` method in combination with `filter()`.

**Options Compared**

The benchmark compares the performance of these four approaches:

* Native JavaScript methods (Array.prototype.map() + Array.prototype.filter())
* Ramda's functional programming library (Ramda's map() + filter())
* Ramda's transduce() method with a custom transformation function
* A hybrid approach combining native JavaScript reduce() and filter()

**Pros and Cons of Each Approach**

1. **Native JavaScript methods**: Fast and efficient, but may not be as concise or readable as other approaches.
2. **Ramda's functional programming library**: Provides a concise and expressive way to perform transformations, but may incur overhead due to the library itself.
3. **Ramda's transduce() method**: Can be more flexible than native JavaScript methods, but may require more boilerplate code and understanding of the transformation function.
4. **Hybrid approach (reduce() + filter())**: May offer a balance between performance and conciseness.

**Library: Ramda**

Ramda is a functional programming library for JavaScript that provides a set of higher-order functions for working with arrays, objects, and functions. The `map()`, `filter()`, and `transduce()` methods are core components of the library, allowing developers to write concise and expressive code.

**Special JS Feature/Syntax: None**

There is no special JavaScript feature or syntax used in this benchmark that would require explanation beyond Ramda's functional programming concepts.

**Other Alternatives**

Other alternatives for filtering and mapping arrays might include:

* Lodash (similar to Ramda)
* Immutable.js
* RxJS (for reactive programming)

However, these alternatives are not explicitly compared in this benchmark.

Latest run results:

Run details: (Test run date: 3 years ago)

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.66 Safari/537.36

Browser/OS: Chrome 87 on Linux

View result in a separate tab

Test name	Executions per second
Array(map + filter)	1456.9 Ops/sec
ramda(map + filter)	3168.5 Ops/sec
ramda-transducer(map + filter)	1741.2 Ops/sec
Array(combined map reduce)	201.4 Ops/sec

Related benchmarks:

ramda-transducer w/mutations v2 (version: 0)

Comparing performance of: Array(map + filter) vs ramda(map + filter) vs ramda-transducer(map + filter) vs Array(combined map reduce)

Created: 3 years ago by: Guest

Jump to the latest result

Array(map + filter)

ramda(map + filter)

ramda-transducer(map + filter)

Array(combined map reduce)

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):