Benchmark: pipe/compose functions

Script Preparation code:

const pipe1 = (...funcs) => {
    if (funcs.length === 0) return v => v
  
    if (funcs.length === 1) return funcs[0]
  
    return funcs.reduce((accum, f) => {
      if (Array.isArray(f)) return arg => {
          var res = accum(arg)
          return f.map(ff => ff(res));
      }
  
      if (typeof f === 'object') return arg => {
          var res = accum(arg)
          return Object.entries(f).reduce((accumObj, [key, ff]) => {
              accumObj[key] = ff(res)
              return accumObj
          }, {})
      }
  
      return arg => f(accum(arg))
    })
  }
  
  const pipe2 = (...funcs) => {
    if (funcs.length === 0) return v => v
  
    if (funcs.length === 1) return funcs[0]
  
    return funcs.reduce((accum, f) => {
      return arg => {
        if (Array.isArray(f)) {
            var res = accum(arg)
            return f.map(ff => ff(res));
        }
  
        if (typeof f === 'object') {
            var res = accum(arg)
            return Object.entries(f).reduce((accumObj, [key, ff]) => {
                accumObj[key] = ff(res)
                return accumObj
            }, {})
        }
  
        return f(accum(arg))
      }
    })
  }
  
  
  const pipe3 = (...funcs) => {
    if (funcs.length === 0) return v => v
  
    if (funcs.length === 1) return funcs[0]
  
    return input => funcs.reduce((prev, f) => {
      if (Array.isArray(f)) return f.map(ff => ff(prev));
  
      if (typeof f === 'object') return Object.entries(f).reduce((accumObj, [key, ff]) => {
            accumObj[key] = ff(prev)
            return accumObj
        }, {})
  
      return f(prev)
    }, input)
  }
  
  const fMake = lable => arg => {
    return arg + lable
  }
  
  var piped1 = pipe1(fMake('O'), [fMake('1'), fMake(2), fMake(3)], a => a.join(), {A: fMake('A'), B: fMake('B'), C: fMake('C')})
  
  var piped2 = pipe2(fMake('O'), [fMake('1'), fMake(2), fMake(3)], a => a.join(), {A: fMake('A'), B: fMake('B'), C: fMake('C')})
  
  var piped3 = pipe1(fMake('O'), [fMake('1'), fMake(2), fMake(3)], a => a.join(), {A: fMake('A'), B: fMake('B'), C: fMake('C')})

Tests:

pipe 1
piped1('a')
pipe 2
piped2('a')
pipe 3
piped3('a')

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
pipe 1
pipe 2
pipe 3

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/81.0.4000.3 Safari/537.36

Browser/OS: Chrome 81 on Windows

View result in a separate tab

Test name	Executions per second
pipe 1	392662.5 Ops/sec
pipe 2	293556.2 Ops/sec
pipe 3	398042.5 Ops/sec

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

LLMs can make mistakes. Check important info.

**Benchmark Overview**

The provided JSON represents a JavaScript benchmark test case on MeasureThat.net, where the focus is on comparing the performance of three different implementation approaches for function piping.

**Tested Scenarios and Options**

The benchmark tests three variations of a function piping pipeline:

1. `pipe1`
2. `pipe2`
3. `pipe3`

These implementations differ in their handling of array and object functions, which are passed as arguments to the piping pipeline.

**Options Compared**

* `pipe1`: Uses an `if` statement to check if the input is an array or an object, and applies different transformations accordingly.
* `pipe2`: Similar to `pipe1`, but uses a single `if` statement with more complex logic.
* `pipe3`: Does not use explicit `if` statements and instead applies transformations directly on the input value.

**Pros and Cons of Each Approach**

* **pipe1**: Simple and easy to understand, but might be slower due to the overhead of explicit checks.
	+ Pros: Easy to implement and maintain.
	+ Cons: Might be less efficient than other approaches.
* **pipe2**: More complex logic, but potentially faster due to reduced overhead.
	+ Pros: May offer better performance, but at the cost of increased complexity.
	+ Cons: Harder to understand and debug.
* **pipe3**: Directly applies transformations without explicit checks, potentially leading to improved performance.
	+ Pros: Can be faster and more efficient, especially for large datasets.
	+ Cons: More challenging to implement and maintain due to its non-intuitive logic.

**Library Usage**

The benchmark uses a custom function `fMake` (short for "function maker") which creates new functions with modified string concatenation. This library is not explicitly named in the provided JSON, but it appears to be a utility function used throughout the test cases.

**Special JS Features or Syntax**

None of the provided code utilizes any special JavaScript features or syntax beyond the standard language features. The implementation relies solely on basic arithmetic operations, conditional statements, and function piping.

**Alternatives**

If you were to create your own benchmark for similar scenarios, consider exploring alternative approaches, such as:

* Using a more efficient data structure, like a trie or a binary tree, to optimize the function piping pipeline.
* Utilizing parallel processing or concurrency to accelerate execution times.
* Implementing different caching strategies or memoization techniques to reduce redundant calculations.

By considering these alternatives, you can create a more comprehensive and realistic benchmark that simulates real-world performance scenarios.

Related benchmarks:

pipe/compose functions (version: 0)

Comparing performance of: pipe 1 vs pipe 2 vs pipe 3

Created: 4 years ago by: Guest

Jump to the latest result

pipe 1

pipe 2

pipe 3

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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