consider using a backwards while-loop for map

map and other methods could be made a tiny bit faster when we would use a backwards loop, see http://stackoverflow.com/a/23998651/1246198 why it’s faster and so on.

...
**Look at this** 

    for( var index = 0 , length = array.length ; index < length ; index++ ) {
     
     //do stuff
    
    }

 1. Need to create at least 2 variables (index,length)
 2. Need to check if the index is smaller than the length
 3. Need to increase the index
 4. the `for` loop has 3 parameters

**Now tell me why this should be faster than:**

    var length = array.length;
    
    while( --length ) { //or length--
    
     //do stuff
    
    }

 1. One variable
 2. No checks
 3. the index is decreased (Machines prefer that)
 4. `while` has only one parameter
...

This is just a suggestion, doesn’t have to be this way in any way 😉

[CrossEye]

Benchmark runs these as many times as it can. (It’s what underlies JSPerf, and a successor of sorts to JSLitmus.)

And I’m still not convinced:

const R1 = require("./ramda")
const R2 = require("./ramda2")
const Benchmark = require("benchmark")
const benchmarks = require("beautify-benchmark")

const tenK = R1.range(1, 10001);

const suite = new Benchmark.Suite

suite.add("normal ramda", () => {
  R1.map(n => n * n, tenK)
})
.add("ramda with reversed while", () => {
  R2.map(n => n * n, tenK)
})
.on("cycle", event => {
  benchmarks.add(event.target)
})
.on("complete", () => {
  benchmarks.log()
})
.run()

>node bench2

  2 tests completed.

  normal ramda              x 9,611 ops/sec ±0.92% (90 runs sampled)
  ramda with reversed while x 9,806 ops/sec ±1.41% (85 runs sampled)


>node bench2

  2 tests completed.

  normal ramda              x 9,937 ops/sec ±0.83% (90 runs sampled)
  ramda with reversed while x 9,771 ops/sec ±1.28% (88 runs sampled)


>node bench2

  2 tests completed.

  normal ramda              x 9,922 ops/sec ±0.81% (89 runs sampled)
  ramda with reversed while x 9,919 ops/sec ±0.86% (86 runs sampled)

Mostly I’m not convinced of the worth of chasing such micro-optimizations. If there is a really substantive difference, I would certainly be interested in talking about it. But I don’t see that here. I see years of history of engines one-upping each other in various parts, and performance gaining unevenly because of that, but no particular algorithmic advantage.

[mrtnbroder]

I’m definitely not convinced:

Now imagine a larger array and the function being run many times in just a few seconds (quite the real world scenario, with React + some render logic)