Benchmark: lodash flow vs ramdajs pipe

HTML Preparation code:

<script src="//cdnjs.cloudflare.com/ajax/libs/ramda/0.27.0/ramda.js"></script>
<script src="//cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.15/lodash.fp.js"></script>

Script Preparation code:

var numbers = Array(100).fill().map((item, index) => index + 1);
var isEven = number => number % 2 === 0;

Tests:

Ramda PIPE
R.pipe(R.filter(isEven), R.map(x => x + 1))(numbers);
Lodash flow
_.flow(_.filter(isEven),_.map(x => x + 1))(numbers);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Ramda PIPE
Lodash flow

Fastest: N/A

Slowest: N/A

Autogenerated LLM Sumamry (model llama3.2:3b, generated 20 days ago):

LLMs can make mistakes. Check important info.

Let's break down the provided benchmarking test cases on MeasureThat.net.

**What is being tested?**

The test measures the performance of two different approaches for creating and executing pipeable functions in JavaScript: Ramda's `pipe` function and Lodash's `flow` function. Both functions are designed to compose multiple smaller functions together, but they implement this functionality differently.

**Options compared**

Two main options are being compared:

1. **Ramda's `pipe`**: This function takes an array of functions as arguments and returns a new function that applies each function in sequence to the input values.
2. **Lodash's `flow`**: This function also takes an array of functions as arguments, but it returns a function that applies each function in a chain-like manner, using the return value of each function as the input to the next one.

**Pros and Cons**

Here are some pros and cons of each approach:

* **Ramda's `pipe`**:
	+ Pros: Immutability, clear syntax, simple to read and write.
	+ Cons: Can be slower due to the creation of new functions for each pipeline stage.
* **Lodash's `flow`**:
	+ Pros: Faster execution speed because it reuses existing function objects instead of creating new ones.
	+ Cons: Less readable than Ramda's `pipe` due to the use of a closure and the need to specify the order of function calls.

Other considerations:

* **Function composition**: Both approaches allow for function composition, which can lead to more modular and reusable code.
* **Caching**: Some implementations (like Lodash) provide caching mechanisms to improve performance.
* **Type safety**: Ramda's `pipe` is designed with type safety in mind, while Lodash's `flow` is more flexible.

**Library usage**

The test case uses two JavaScript libraries:

1. **Ramda**: A functional programming library that provides a set of reusable functions for data processing and manipulation.
2. **Lodash**: A utility-first library that provides a broad range of functions for tasks such as string manipulation, object manipulation, and more.

**Special JS features or syntax**

This test case does not use any special JavaScript features or syntax, so there's nothing to explain in this regard.

**Alternatives**

If you're looking for alternative approaches to Ramda's `pipe` and Lodash's `flow`, here are a few options:

1. **Array.prototype.reduce()**: This method can be used to compose functions together, although it might not offer the same level of immutability as Ramda's `pipe`.
2. **Function composition with arrow functions**: You can use arrow functions to create simple function compositions without relying on any external libraries.
3. **Other functional programming libraries**: There are other JavaScript libraries, such as Immer and Ramble, that provide similar functionality to Ramda and Lodash.

Keep in mind that each approach has its own trade-offs and may be better suited for specific use cases or performance requirements.

Latest run results:

Run details: (Test run date: 6 days ago)

User agent: Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Mobile Safari/537.36

Browser/OS: Chrome Mobile 130 on Android

View result in a separate tab

Test name	Executions per second
Ramda PIPE	271095.1 Ops/sec
Lodash flow	24179.0 Ops/sec

Related benchmarks:

lodash flow vs ramdajs pipe (version: 0)

check this out

Comparing performance of: Ramda PIPE vs Lodash flow

Created: 4 years ago by: Guest

Jump to the latest result

Ramda PIPE

Lodash flow

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Sumamry (model llama3.2:3b, generated 20 days ago):