Ramda vs Lodash

foo.js

var _ = require("lodash");
var R = require("ramda");

var companies = [
  { name: "tw", since: 1993 },
  { name: "pucrs", since: 1930 },
  { name: "tw br", since: 2009 }
];

var r1 = _(companies).chain()
  .filter(function(c) {
    return c.name.split(" ")[0] === "tw";
  })
  .map(function(c) {
    return {
      name: c.name.toUpperCase(),
      since: c.since
    };
  })
  .sortBy(function(c) {
    return c.since;
  })
  .reverse()
  .value();

console.log("with lodash:", r1);

var r2 = R.compose(
  R.reverse,
  R.sortBy(R.prop("since")),
  R.map(R.over(R.lensProp("name"), R.toUpper)),
  R.filter(R.where({ name: R.test(/^tw/) }))
)(companies);

console.log("with ramda:", r2);

@hillerstorm: Got you covered!

var r5 = (companies || [])
  .filter(c => c.name && c.name.startsWith("tw"))
  .map(c => ({ ...c, name: c.name.toUpperCase() }))
  .sort((a, b) => b.since - a.since);

Even though Ramda is definitely more powerful, and I do prefer Ramda over lodash, I've found that for a lot of common operations lodash is simpler to use. It handles many real world cases that Ramda doesn't. For instance, when you iterate object properties with lodash it will skip "hidden" properties (that start with _) by default. It also performs much better on some operations, of course it doesn't really matter most of the time.

An even shorter Ramda version:

const r3 = R.pipe(
  R.filter(R.where({ name: R.startsWith('tw') })),
  R.map(R.evolve({ name: R.toUpper })),
  R.sort(R.descend(R.prop('since')))
)

r3(companies)

in the lodash example you said c.name.split(" ")[0] === "tw" but in the ramda's one you've put a regex R.test(/^tw/) . Really?
The same regex could be also applied in the first case, natively /^tw/.test(name) which is actually shorter.

But that would not be point-free. The point is not being shorter. The point is being point-free, auto-curried, composable.

Thanks for adding to the discussion :)

Oh, I wasn't aware of this comparison.

how about from performance perspective? anyone has done it?