Ramda vs RxJS vs JS lambda calculus vs JS functional vs JS loop

index.js

/*
  Test environment:
    - node.js 10.5.0
    - macOS   10.13.5
    - MacBook Pro Late 2013

    - Ramda 0.25.0
    - RxJS  6.2.1

  Results (Babel transpiled):

    js loop (baseline):     338.453ms
    js functional:          668.639ms
    Ramda compose:          597.600ms
    Pure Ramda compose:     9394.814ms
    Rx pipe:                526.859ms
    Pure js lambda compose: 151.258ms (best!)

  Results (without transpiling):
    
    js loop (baseline):     19.861ms (best!)
    js functional:          738.664ms
    Ramda compose:          653.546ms
    Pure Ramda compose:     7783.351ms
    Rx pipe:                559.815ms
    Pure js lambda compose: 164.935ms

*/

const R = require('ramda');
const Rx = require('rxjs');
const { reduce, map, takeLast } = require('rxjs/operators');

const length = 10000000;
const values = Int32Array.from({ length }, _ => Math.random() * length);


console.time('js loop (baseline)');

let r = 0;
for (let i = 0; i < length; ++i) {
  // r += (values[i] + 1) * 2 + 2;
  r += values[i] * 2 + 4;
}

console.timeEnd('js loop (baseline)');

console.time('js functional');
const r0 = values
    .map(x => x + 1)
    .map(x => x * 2)
    .map(x => x + 2)
    .reduce((a, b) => a + b, 0);
console.timeEnd('js functional');

console.time('Ramda compose');

const r1 = R.compose(
  R.reduce((a, b) => a + b, 0),
  R.map(x => x + 2),
  R.map(x => x * 2),
  R.map(x => x + 1),
)(values);

console.timeEnd('Ramda compose');

console.time('Pure Ramda compose');

const r11 = R.compose(
  R.sum,
  R.map(R.add(2)),
  R.map(R.multiply(2)),
  R.map(R.inc),
)(values);

console.timeEnd('Pure Ramda compose');

console.time('Rx pipe');

let rx = 0;
Rx.from(values).pipe(
  map(x => x + 1),
  map(x => x * 2),
  map(x => x + 2),
  reduce((a, b) => a + b, 0),
).subscribe(r => { rx = r });

console.timeEnd('Rx pipe');

console.time('Pure js lambda compose');

const t = x => x + 2;
const f = x => x * 2;
const g = x => x + 1;

const r2 = values.reduce((a, b) => a + t(f(g(b))), 0);

console.timeEnd('Pure js lambda compose');

console.log('\n---results---\n');
console.log('loop result', r);
console.log('func result', r0);
console.log('Ramda result', r1);
console.log('Pure Ramda result', r11);
console.log('Rx result', rx);
console.log('Pure lambda result', r2);

• node v10.8.0
• Lenovo Z50-70 Core i5, 6 gb RAM
• Ubuntu 18.04
• ramda 0.25.0
• rxjs 6.3.3

Output

js loop (baseline): 24.083ms
js functional: 1050.064ms
Ramda compose: 896.911ms
Pure Ramda compose: 12493.258ms
Rx pipe: 868.019ms
Pure js lambda compose: 226.452ms

---results---

loop result 100008817058952
func result 100008817058952
Ramda result 100008817058952
Pure Ramda result 100008817058952
Rx result 100008817058952
Pure lambda result 100008817058952

Env:

Node 10.1.0
Windows 10 Pro
i5 4210U 8GB RAM

js loop (baseline): 26.604ms
js functional: 988.365ms
Ramda compose: 949.867ms
Pure Ramda compose: 12899.294ms
Rx pipe: 779.636ms
Pure js lambda compose: 244.800ms

---results---

loop result 100012307696532
func result 100012307696532
Ramda result 100012307696532
Pure Ramda result 100012307696532
Rx result 100012307696532
Pure lambda result 100012307696532

Update header comments and mentioned Babel

Env

• Node 8.11.4
• Intel i7-6700k, 16 GB
• Windows 10

Output

js loop (baseline): 24.890ms
js functional: 486.079ms
Ramda compose: 468.768ms
Pure Ramda compose: 6383.017ms
Rx pipe: 389.795ms
Pure js lambda compose: 121.109ms

---results---

loop result 99985743810424
func result 99985743810424
Ramda result 99985743810424
Pure Ramda result 99985743810424
Rx result 99985743810424
Pure lambda result 99985743810424

ENV

Node v10.15.3
Ubuntu 18
Intel Core i5

OUTPUT

js functional: 665.883ms
Ramda compose: 636.588ms
Pure Ramda compose: 9406.856ms
Rx pipe: 532.125ms
Pure js lambda compose: 175.168ms

---results---

loop result 100027104651568
func result 100027104651568
Ramda result 100027104651568
Pure Ramda result 100027104651568
Rx result 100027104651568
Pure lambda result 100027104651568 

This doesn’t seem like a proper comparison - isn’t doing map 3 times going to interate over the huge array 3 times vs the plain js version that iterates only once? That’s why the js composé version seems 4 times faster....