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: one year 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>

AخA
 
<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;
}

​x
 
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();

 
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,
);

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

Experimental features:

Memory measurements supported only in Chrome.
For precise memory measurements Chrome must be launched with --enable-precise-memory-info flag.
More information: Monitoring JavaScript Memory

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: one year 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 6 months ago):

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:

Pulling the "counter" property from each object in the array.
Filtering out odd numbers.
Squaring the remaining numbers.
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:

Selects only the "counter" property using _.pick.
Filters out odd numbers using _.filter(isOdd).
Maps each number to its square using _.map(square).
Filters out numbers with less than two digits using _.filter(lessThanThreeDigits).
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:

Ramda transducer function
Ramda composed function without currying or composition
Lodash chain method
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.

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