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

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....