Benchmark: Ramda pipe vs vanilla JS pipe (v2.0)

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];
  };
};

Tests:

Ramda pipe
R.pipe(funOne, funTwo, funOne, funTwo, funOne, funTwo, funOne, funTwo, funOne, funTwo, funOne, funTwo)(data)
vanilla JS pipe
flow([funOne, funTwo, funOne, funTwo, funOne, funTwo, funOne, funTwo, funOne, funTwo, funOne, funTwo])(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

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36

Browser/OS: Chrome 120 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Ramda pipe	721405.5 Ops/sec
vanilla JS pipe	850268.7 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down what is being tested in this benchmark.

**Benchmark Definition**

The benchmark tests two approaches to function composition in JavaScript:

1. **Ramda Pipe**: The Ramda library provides a `pipe` function that allows you to compose functions together, passing the output of each function as the input to the next one.
2. **Vanilla JS Pipe**: This is a custom implementation of function composition using an array of functions.

**Options Compared**

The two options being compared are:

* Ramda Pipe: uses the `pipe` function from the Ramda library
* Vanilla JS Pipe: uses a custom implementation of function composition

**Pros and Cons**

**Ramda Pipe**

Pros:

* Concise and expressive syntax
* Well-tested and maintained library
* Provides a convenient way to compose functions together

Cons:

* External dependency on the Ramda library (which may not be included in all environments)
* May have slower execution due to the overhead of calling external functions

**Vanilla JS Pipe**

Pros:

* No external dependencies, making it more self-contained and portable
* Can potentially be optimized for performance by eliminating function call overhead

Cons:

* More verbose syntax compared to Ramda Pipe
* Requires careful implementation to ensure correct behavior
* May have slower execution due to the overhead of creating and invoking functions

**Library: Ramda**

Ramda is a functional programming library for JavaScript that provides a wide range of utility functions, including `pipe`. It is designed to be concise and expressive, making it easier to write reusable code.

**Special JS Feature/Syntax**

None mentioned in this benchmark. However, note that the use of function composition can also involve other features like higher-order functions, closures, and currying, which are not explicitly mentioned here.

**Other Alternatives**

Other alternatives for function composition in JavaScript include:

* **Lodash**: A popular utility library that provides a `pipe` function similar to Ramda.
* **ES6 function composition**: The `compose` function is part of the ES6 specification and can be used directly without any additional libraries.
* **Custom implementation**: As seen in the Vanilla JS Pipe benchmark, it's possible to implement function composition from scratch using traditional JavaScript techniques.

Overall, the choice between Ramda Pipe and Vanilla JS Pipe depends on your specific use case, performance requirements, and personal preference. If you're already familiar with Ramda or prefer a concise syntax, Ramda Pipe might be a good choice. Otherwise, Vanilla JS Pipe provides a more self-contained and portable solution.

Related benchmarks:

Ramda pipe vs vanilla JS pipe (v2.0) (version: 0)

Comparing performance of: Ramda pipe vs vanilla JS pipe

Created: 5 years ago by: Guest

Jump to the latest result

Ramda pipe

vanilla JS pipe

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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