Benchmark: Ramda (/w transducer) vs. Lodash

Ramda (/w transducer) vs. Lodash (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: 3 years 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(10000).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: 3 months ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:134.0) Gecko/20100101 Firefox/134.0

Browser/OS: Firefox 134 on Mac OS X 10.15

View result in a separate tab

Test name	Executions per second
Lodash	783883.0 Ops/sec
Ramda with transducer	793.9 Ops/sec
Ramda with currying and composition	849.4 Ops/sec
Ramda without relying on currying or composition	856.9 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the benchmark and explore what's being tested, compared options, pros and cons, library usage, special JavaScript features or syntax, and alternatives.

**Benchmark Overview**

The benchmark compares the performance of four different approaches to achieve the same result:

1. Lodash with `chain()`
2. Ramda with transducer
3. Ramda with currying and composition
4. Ramda without relying on currying or composition

The test case uses a dataset of 10,000 objects with a "counter" property, which is filtered to extract odd numbers, squared, and then further filtered to keep only values with less than three digits.

**Library Usage**

Two popular JavaScript libraries are used in the benchmark:

1. Lodash: A utility library that provides a wide range of functions for tasks like filtering, mapping, and reducing arrays.
2. Ramda: A functional programming library that provides a set of immutable functions for working with arrays and objects.

In this benchmark, both libraries are used to perform similar operations, but with different approaches:

* Lodash uses `chain()` to create a pipeline of operations on the dataset.
* Ramda uses transducers (a type of pure function) to apply transformations to the dataset in a stateless way.
* Ramda also provides currying and composition mechanisms, which allow for more flexible and modular code.

**Special JavaScript Features or Syntax**

While not explicitly mentioned, the benchmark relies on several advanced JavaScript features:

1. **Closure**: The `function isOdd(num) {...}` and `function square(num) {...}` closures are used to create private scope for each function.
2. **Arrow functions**: Some of the Ramda operations (e.g., `R.filter`) use arrow functions, which provide a concise way to define small, anonymous functions.
3. **Template literals**: The `var result = R.pluck('counter', ...)` and `var data = _.range(10000).map(function(i) {...})` expressions utilize template literals for string interpolation.

**Comparison of Approaches**

Here's a brief summary of each approach:

1. **Lodash with chain()**: This approach creates a pipeline of operations on the dataset using Lodash's `chain()` method. It's straightforward but may lead to slower performance due to the overhead of function calls.
2. **Ramda with transducer**: Ramda uses transducers, which are pure functions that take an input array and return a new array with the desired transformations applied in a stateless way. This approach is efficient because it avoids the overhead of creating intermediate arrays.
3. **Ramda with currying and composition**: This approach takes advantage of Ramda's currying and composition mechanisms to create modular, reusable functions that can be composed together. It offers flexibility but may lead to slower performance due to the complexity of the code.

**Pros and Cons**

Here are some pros and cons for each approach:

1. **Lodash with chain()**:
	* Pros: Easy to read, straightforward implementation.
	* Cons: May lead to slower performance due to function call overhead.
2. **Ramda with transducer**:
	* Pros: Efficient, stateless, and pure functions.
	* Cons: Requires understanding of Ramda's API and transducers concept.
3. **Ramda with currying and composition**:
	* Pros: Flexible, modular, and reusable code.
	* Cons: May lead to slower performance due to complexity.

**Alternatives**

Other alternatives for similar operations could be:

1. **ES6 Array methods**: Instead of using a library like Lodash or Ramda, you could use native ES6 array methods like `filter()`, `map()`, and `reduce()`.
2. **Other functional programming libraries**: Libraries like Underscore.js or Svelte's built-in functions could also be used for similar operations.

I hope this explanation helps software engineers understand the benchmark and the approaches being compared!

Related benchmarks:

Ramda (/w transducer) vs. Lodash (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: 3 years 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 6 months ago):