Benchmark: Ramda pipe vs vanilla JS pipe

HTML Preparation code:

<script src="https://cdnjs.cloudflare.com/ajax/libs/ramda/0.27.1/ramda.min.js" integrity="sha512-rZHvUXcc1zWKsxm7rJ8lVQuIr1oOmm7cShlvpV0gWf0RvbcJN6x96al/Rp2L2BI4a4ZkT2/YfVe/8YvB2UHzQw==" crossorigin="anonymous"></script>

Script Preparation code:

var data = 2;

function funOne(data) {
  return data + data;
}

var funTwo = function funTwo(data) {
  return data * 2;
};

var flow = function flow(funcs) {
  return function () {
    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
      args[_key] = arguments[_key];
    }

    return funcs.reduce(function (prev, fnc) {
      return [fnc.apply(void 0, prev)];
    }, args)[0];
  };
};

var doFlow = flow([funOne, funTwo, funOne, funTwo, funOne, funTwo, funOne, funTwo, funOne, funTwo, funOne, funTwo]);

Tests:

Ramda pipe
R.pipe(funOne, funTwo, funOne, funTwo, funOne, funTwo, funOne, funTwo, funOne, funTwo, funOne, funTwo)(data)
vanilla JS pipe
doFlow(data)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Ramda pipe
vanilla JS pipe

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 28 days ago):

LLMs can make mistakes. Check important info.

Let's break down what's being tested on the provided JSON.

**Benchmark Definition**

The benchmark is comparing two approaches to create and execute a pipeline of functions:

1. **Ramda pipe**: This approach uses the Ramda library to create a pipeline of functions. The `R.pipe` function takes multiple arguments, which are the individual functions to be composed together.
2. **Vanilla JS pipe** (also known as "doFlow"): This approach creates a custom pipeline using a self-invoking anonymous function (`doFlow`). The `flow` function takes an array of functions as arguments and returns another function that applies each function in the order they are passed.

**Options being compared**

The two options being compared are:

* Using the Ramda library to create a pipeline of functions (`R.pipe`)
* Creating a custom pipeline using a self-invoking anonymous function (`doFlow`)

**Pros and cons**

**Ramda pipe:**

Pros:

* Provides a concise way to create pipelines of functions
* Simplifies code by abstracting away boilerplate logic
* Often faster due to optimized implementation

Cons:

* Requires an external library (Ramda) which may introduce overhead
* May not be as well-known or widely supported, especially among developers without experience with functional programming

**Vanilla JS pipe (doFlow):**

Pros:

* Does not require any additional libraries or dependencies
* Can be more accessible to developers without experience with functional programming
* Allows for fine-grained control over the pipeline creation process

Cons:

* Requires manual implementation of the pipeline logic, which can lead to boilerplate code and less readable code
* May perform slightly slower due to the need to create a custom function

**Other considerations**

When choosing between these two approaches, consider the following factors:

* **Readability**: If you value concise and readable code, Ramda pipe may be a better choice.
* **Performance**: If performance is critical, Ramda pipe's optimized implementation may provide a slight edge.
* **Development speed**: If you need to develop quickly and don't mind using an external library, Ramda pipe can simplify the process.

**Library used: Ramda**

Ramda is a popular functional programming library for JavaScript that provides a set of reusable functions for common tasks such as data manipulation, transformation, and composition. In this benchmark, `R.pipe` is used to create a pipeline of functions.

**Special JS feature or syntax**

There are no special JS features or syntax mentioned in the benchmark code. However, it's worth noting that functional programming concepts like pipelines and higher-order functions are becoming increasingly popular in JavaScript development.

Overall, both approaches have their advantages and disadvantages, and the choice ultimately depends on your specific needs and preferences as a developer.

Latest run results:

Run details: (Test run date: 2 years ago)

User agent: Mozilla/5.0 (X11; Linux x86_64; rv:96.0) Gecko/20100101 Firefox/96.0

Browser/OS: Firefox 96 on Linux

View result in a separate tab

Test name	Executions per second
Ramda pipe	164370.9 Ops/sec
vanilla JS pipe	474810.8 Ops/sec

Related benchmarks:

Ramda pipe vs vanilla JS pipe (version: 0)

Comparing performance of: Ramda pipe vs vanilla JS pipe

Created: 3 years ago by: Guest

Jump to the latest result

Ramda pipe

vanilla JS pipe

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 28 days ago):