Benchmark: pipe (2 flavors) vs compose

Script Preparation code:

var _compose = (f, g) => (...args) => f(g(...args))
var compose = (...funcs) => funcs.reduce(_compose)

var _pipe = (f, g) => (...args) => g(f(...args))
var pipe = (...funcs) => funcs.reduce(_pipe)

var pipe2 = (...funcs) => funcs.reduceRight(_compose)

Tests:

Pipe
pipe(x => x + 'b', x => x + 'c')('a')
Pipe2
pipe2(x => x + 'b', x => x + 'c')('a')
Compose
compose(x => x + 'c', x => x + 'b')('a')

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Pipe
Pipe2
Compose

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 the benchmark and explain what's being tested.

**Benchmark Description**
The benchmark compares two functional programming approaches: `_pipe` (also known as `pipe`) and `_compose` (also known as `compose`). The goal is to see which approach is faster for a specific use case: piping functions together to transform an input value.

**Options Compared**

1. **_pipe (`pipe`)**: This implementation uses the `reduce` method to apply each function in sequence, starting from the left. It takes advantage of JavaScript's operator precedence to chain the functions.
2. **_compose (`compose`)**: This implementation uses a helper function `_compose` to define a curried function that takes a variable number of arguments and returns a new function that composes the input functions.

**Pros and Cons**

1. `pipe (_pipe)`: Pros:
	* Simplistic and easy to understand.
	* Uses JavaScript's operator precedence, making it efficient.
Cons:
	* May be less readable for those unfamiliar with functional programming concepts.
2. `_compose (compose)_: Pros:
	* More explicit and expressive than the `pipe` implementation.
	* Can be easier to debug and maintain, as each function is clearly defined.
Cons:
	* Uses more code and may be slower due to the overhead of creating and invoking helper functions.

**Library/Functionality Used**

None of the implementations use any external libraries. However, both `_compose` and `_pipe` use JavaScript's `reduce` method, which is a built-in function.

**Special JS Feature/Syntax**
The benchmark uses a feature called "currying," where a function with multiple arguments returns a new function that takes one argument at a time. This allows the functions to be composed together. However, this syntax may not be familiar to all JavaScript developers, especially those coming from imperative programming backgrounds.

**Alternative Approaches**

Other possible approaches to implement function composition could include:

1. Using a loop instead of `reduce` to apply each function in sequence.
2. Implementing function composition using a more traditional procedural programming style (e.g., using a `for` loop to iterate over the functions).
3. Using a library or framework that provides built-in support for functional programming concepts, such as Immutable.js or Ramda.

These alternative approaches may have different trade-offs in terms of performance, readability, and maintainability.

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/98.0.4758.80 Safari/537.36

Browser/OS: Chrome 98 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Pipe	4573776.0 Ops/sec
Pipe2	4791657.5 Ops/sec
Compose	3945169.2 Ops/sec

Related benchmarks:

pipe (2 flavors) vs compose (version: 0)

Comparing performance of: Pipe vs Pipe2 vs Compose

Created: 5 years ago by: Guest

Jump to the latest result

Pipe

Pipe2

Compose

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):