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

Ramda (/w transducer) vs. Lodash v3 (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: `Ramda without relying on currying or composition vs Ramda with transducer vs Ramda with currying and composition vs Lodash`

Created: 2 years ago by: Registered User

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

Ramda without relying on currying or composition
var result = R.filter(lessThanThreeDigits, R.map(square, R.filter(isOdd, R.pluck('counter', data))));
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);
Lodash
var result = _.chain(data) .pick('counter') .filter(isOdd) .map(square) .filter(lessThanThreeDigits) .value();

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

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

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 2 years 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

Lodash

554K/s

Ramda with transducer

79/s

Ramda without relying on currying or composition

76/s

Ramda with currying and composition

74/s

View exact numbers

Test name	Executions per second
✓ Lodash	554,449 Ops/sec
Ramda with transducer	79 Ops/sec
Ramda without relying on currying or composition	76 Ops/sec
Ramda with currying and composition	74 Ops/sec

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

LLMs can make mistakes. Check important info.

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

**What is being tested?**

The benchmark compares the performance of four different approaches to perform a similar task:

1. Using Lodash (a popular JavaScript utility library)
2. Ramda (a functional programming library) with two styles:
	* "without relying on currying or composition" (using `filter`, `map`, and `compose` functions directly)
	* "with transducer" (using the `transduce` function to create a pipeline of operations)
3. Ramda with currying and composition (using `pipe` function to chain operations)

**Options compared**

The benchmark compares the performance of these four approaches:

1. Lodash: uses its built-in functions for filtering, mapping, and reducing.
2. Ramda "without relying on currying or composition": uses `filter`, `map`, and `compose` functions directly from Ramda.
3. Ramda "with transducer": uses the `transduce` function to create a pipeline of operations that can be composed together.
4. Ramda with currying and composition: uses the `pipe` function to chain operations together.

**Pros and cons**

Here's a brief summary of the pros and cons of each approach:

1. **Lodash**:
	* Pros: widely used, well-maintained, and easy to use.
	* Cons: may be slower than optimized libraries like Ramda due to its overhead.
2. **Ramda "without relying on currying or composition"**:
	* Pros: uses native JavaScript functions for filtering, mapping, and reducing, which might be faster.
	* Cons: can lead to less readable code if not used carefully.
3. **Ramda "with transducer"**:
	* Pros: allows for more flexible and composable pipeline of operations.
	* Cons: may have a learning curve due to the use of `transduce` function.
4. **Ramda with currying and composition**:
	* Pros: uses a concise and readable syntax, making it easier to chain operations together.
	* Cons: may be slower than other approaches due to the overhead of function creation.

**Libraries used**

The benchmark uses two popular JavaScript libraries:

1. Ramda (functional programming library)
2. Lodash (utility library)

Both libraries provide a set of functions for common tasks like filtering, mapping, and reducing arrays.

**Special JS features or syntax**

There are no special JS features or syntax used in this benchmark. The code is written using standard JavaScript syntax, with the exception of Ramda's currying and composition features.

**Alternatives**

If you're looking for alternatives to these libraries, here are a few options:

1. **Immutable.js**: another functional programming library that provides similar functionality to Ramda.
2. **Underscore.js**: an older utility library that provides similar functionality to Lodash.
3. **Papaparse**: a library specifically designed for parsing and manipulating arrays.

Keep in mind that the choice of library or alternative depends on your specific use case, personal preference, and performance requirements.