Benchmark: Ramda vs. Lodash vs. Sanctuary

Ramda vs. Lodash vs. Sanctuary (version: 0) Benchmark.js

Compares performance on the same task using Lodash vs two styles of Ramda vs two styles of "native" Javascript vs Sanctuary. 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 without relying on currying or composition vs Ramda with currying and composition vs Sanctuary with currying`

Created: 3 years ago by: Registered User

Go to the latest result

HTML Preparation code:

<script src="https://cdnjs.cloudflare.com/ajax/libs/ramda/0.29.0/ramda.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.21/lodash.min.js"></script>
<script src="https://cdn.jsdelivr.net/gh/sanctuary-js/sanctuary@3.1.0/dist/bundle.js"></script>

Script Preparation code:

const S = window.sanctuary;

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 without relying on currying or composition
var result = R.filter(lessThanThreeDigits, R.map(square, R.filter(isOdd, R.pluck('counter', data))));
Ramda with currying and composition
var result = R.pipe( R.pluck('counter'), R.filter(isOdd), R.map(square), R.filter(lessThanThreeDigits) )(data);
Sanctuary with currying
var result = window.sanctuary.pipe([ window.sanctuary.map(window.sanctuary.prop('counter')), window.sanctuary.filter(isOdd), window.sanctuary.map(square), window.sanctuary.filter(lessThanThreeDigits) ])(data);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

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

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one year ago)

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

Browser/OS: Firefox 135 on Mac OS X 10.15

View result in a separate tab

Lodash

763K/s

Ramda without relying on currying or composition

3K/s

Ramda with currying and composition

832/s

Sanctuary with currying

0/s

View exact numbers

Test name	Executions per second
✓ Lodash	763,344 Ops/sec
Ramda without relying on currying or composition	2,859 Ops/sec
Ramda with currying and composition	832 Ops/sec
Sanctuary with currying	0 Ops/sec

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

LLMs can make mistakes. Check important info.

I'll break down the benchmark and explain what's being tested, the different approaches, their pros and cons, and other considerations.

**Benchmark Overview**

The benchmark compares the performance of three JavaScript libraries: Lodash, Ramda, and Sanctuary. The test case is designed to filter an array of objects, square the values of the "counter" property for even numbers, and return only those values with less than 3 digits.

**Library Descriptions**

* **Lodash**: A popular utility library that provides a lot of built-in functions for common tasks, such as filtering, mapping, and reducing data.
* **Ramda**: A functional programming library that provides a different set of functions for manipulating data, focusing on immutable data structures and higher-order functions.
* **Sanctuary**: A JavaScript library that provides a more concise and expressive way to work with data, using a simpler syntax and a focus on immutability.

**Test Cases**

The benchmark consists of four test cases:

1. **Lodash without currying or composition**: Uses the `_.chain()` method to create a pipeline of functions that filters, maps, and reduces the data.
2. **Ramda without currying or composition**: Uses plain functions from Ramda's API to filter, map, and reduce the data.
3. **Ramda with currying and composition**: Uses Ramda's curry and compose functions to create a more concise and expressive pipeline of operations.
4. **Sanctuary with currying**: Uses Sanctuary's `pipe()` function to create a concise pipeline of operations.

**Approaches Compared**

The benchmark is comparing the performance of different approaches:

* Using the `_.chain()` method in Lodash
* Using plain functions from Ramda's API
* Using curry and compose functions in Ramda
* Using Sanctuary's `pipe()` function

Each approach has its own pros and cons:

* **Lodash without currying or composition**: Pros: easy to read, well-maintained library. Cons: can be slower due to the use of a chain method.
* **Ramda without currying or composition**: Pros: concise syntax, expressive functions. Cons: may require more expertise to write effective pipelines.
* **Ramda with currying and composition**: Pros: highly concise syntax, easy to compose multiple operations. Cons: may be less readable for some developers.
* **Sanctuary with currying**: Pros: concise syntax, expressive functions. Cons: may not be as widely adopted or maintained as other libraries.

**Other Considerations**

* **Device Platform and Browser**: The benchmark results are specific to a Chrome 114 browser running on a Macintosh with Intel OS X 10.15.7.
* **Data Size**: The test case uses an array of 10,000 objects.
* **Optimization Techniques**: Not explicitly mentioned in the benchmark, but optimization techniques like caching or memoization could potentially improve performance.

**Alternatives**

Other alternatives for these libraries include:

* Lodash: Jest or other testing frameworks
* Ramda: Immer.js or other data manipulation libraries
* Sanctuary: ReScript or other functional programming libraries

Keep in mind that the choice of library depends on the specific needs and goals of the project.