Benchmark: Ramda (/w transducer) vs. Lodash v2

Ramda (/w transducer) vs. Lodash v2 (version: 0)

Compares performance on the same task using Lodash vs two styles of Ramda vs two styles of "native" Javascript. In all cases the task is pulling "counter" property from each item in an array, filtering out odd items, squaring them, then returning those squared values that have less than two digits.

Comparing performance of: Lodash vs Ramda with transducer vs Ramda with currying and composition vs Ramda without relying on currying or composition

Created: 10 months ago by: Guest

Jump to the latest result

HTML Preparation code:

<script src="https://cdnjs.cloudflare.com/ajax/libs/ramda/0.28.0/ramda.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.15/lodash.min.js"></script>

Script Preparation code:

var data = _.range(100000).map(function(i) {
  return {
    counter: i
  }
});

function isOdd(num) {
  return num % 2 === 1;
}

function square(num) {
  return num * num;
}

function lessThanThreeDigits(num) {
  return num.toString().length < 3;
}

Tests:

Lodash
var result = _.chain(data) .pick('counter') .filter(isOdd) .map(square) .filter(lessThanThreeDigits) .value();
Ramda with transducer
var transducer = R.compose ( R.map(R.prop('counter')), R.filter(isOdd), R.map(square), R.filter(lessThanThreeDigits), ); var result = R.transduce ( transducer, (acc, val) => { acc.push(val); return acc; }, [], data, );
Ramda with currying and composition
var result = R.pipe( R.pluck('counter'), R.filter(isOdd), R.map(square), R.filter(lessThanThreeDigits) )(data);
Ramda without relying on currying or composition
var result = R.filter(lessThanThreeDigits, R.map(square, R.filter(isOdd, R.pluck('counter', data))));

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lodash
Ramda with transducer
Ramda with currying and composition
Ramda without relying on currying or composition

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 10 months ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36

Browser/OS: Chrome 121 on Windows

View result in a separate tab

Test name	Executions per second
Lodash	517255.8 Ops/sec
Ramda with transducer	83.4 Ops/sec
Ramda with currying and composition	72.4 Ops/sec
Ramda without relying on currying or composition	74.9 Ops/sec

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

LLMs can make mistakes. Check important info.

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

**Overview**

The benchmark compares the performance of three different ways to achieve a common task: filtering, mapping, and transforming an array of objects in JavaScript. The task involves:

1. Pulling the "counter" property from each object in the array.
2. Filtering out odd numbers.
3. Squaring the remaining numbers.
4. Returning only those squared values with less than two digits.

**Test Cases**

There are four test cases:

### 1. Lodash

The first test case uses Lodash, a popular JavaScript library for functional programming. It defines three functions:

* `isOdd`: checks if a number is odd.
* `square`: squares a number.
* `lessThanThreeDigits`: returns true if a number has less than two digits.

It then creates an array of 100,000 objects with increasing counter values and uses the Lodash chain method (`_.chain`) to perform the following operations:

1. Selects only the "counter" property using `_.pick`.
2. Filters out odd numbers using `_.filter(isOdd)`.
3. Maps each number to its square using `_.map(square)`.
4. Filters out numbers with less than two digits using `_.filter(lessThanThreeDigits)`.
5. Returns the resulting array using `_.value`.

### 2. Ramda with Transducer

The second test case uses Ramda, another popular JavaScript library for functional programming. It defines a transducer function that takes an accumulator and a value as input and returns the updated accumulator.

The test case creates an empty array (`[]`) as the initial accumulator, data as the input array, and then applies the transducer function to process the data:

* `R.compose` is used to create a composed function from several individual functions:
	+ `R.map(R.prop('counter'))`: maps each object in the array to its counter value.
	+ `R.filter(isOdd)`: filters out odd numbers.
	+ `R.map(square)`: squares each number.
	+ `R.filter(lessThanThreeDigits)`: filters out numbers with less than two digits.
* The composed function is then applied to the data using `R.transduce`, which updates the accumulator and returns the resulting array.

### 3. Ramda without Currying or Composition

The third test case uses Ramda but without relying on currying or composition. It defines a single function that takes the input array as an argument:

* `R.filter(lessThanThreeDigits, R.map(square, R.filter(isOdd, R.pluck('counter', data))))`: applies the filters in sequence:
	1. Extracts only the counter values using `R.pluck('counter')`.
	2. Filters out odd numbers.
	3. Maps each number to its square.
	4. Filters out numbers with less than two digits.

### 4. Ramda with Currying and Composition

The fourth test case uses Ramda with currying and composition. It defines the same composed function as in Test Case 2:

* `R.pipe(R.pluck('counter'), R.filter(isOdd), R.map(square), R.filter(lessThanThreeDigits))`: applies the filters in sequence:
	1. Extracts only the counter values.
	2. Filters out odd numbers.
	3. Maps each number to its square.
	4. Filters out numbers with less than two digits.

**Options Compared**

The benchmark compares four different approaches:

* Lodash chain method
* Ramda transducer function
* Ramda composed function without currying or composition
* Ramda composed function with currying and composition

Each approach has its own trade-offs:

* **Lodash chain method**: easy to read, but may lead to slower performance due to the overhead of creating a chain.
* **Ramda transducer function**: more efficient than Lodash for large datasets, but requires a deeper understanding of functional programming concepts.
* **Ramda composed function without currying or composition**: similar performance to the Lodash chain method, but with less overhead.
* **Ramda composed function with currying and composition**: combines the efficiency of Ramda transducer functions with the readability of composed functions.

**Performance Results**

The benchmark results show that the order of performance is:

1. Ramda transducer function
2. Ramda composed function without currying or composition
3. Lodash chain method
4. Ramda composed function with currying and composition

These results suggest that using a transducer function in Ramda can lead to better performance, especially for large datasets.

Related benchmarks:

Ramda (/w transducer) vs. Lodash v2 (version: 0)

Compares performance on the same task using Lodash vs two styles of Ramda vs two styles of "native" Javascript. In all cases the task is pulling "counter" property from each item in an array, filtering out odd items, squaring them, then returning those squared values that have less than two digits.

Comparing performance of: Lodash vs Ramda with transducer vs Ramda with currying and composition vs Ramda without relying on currying or composition

Created: 10 months ago by: Guest

Jump to the latest result

Lodash

Ramda with transducer

Ramda with currying and composition

Ramda without relying on currying or composition

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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