guess that really depends.

  var nums = Array.apply(0, Array(300)).map(function(x, idx) {
    return idx;
  });

  var filter = ramda.filter;
  var map = ramda.map;
  var reduce = ramda.reduce;
  var compose = ramda.compose;

  var gt100pred = function(x) {
    return x > 100;
  };
  var add = function(a, b) {
    return a + b;
  };

  var result = nums
    .filter(gt100pred)
    .map(Math.sqrt)
    .reduce(add, 0);

  var gt100 = filter(gt100pred);
  var sqrt = map(Math.sqrt);
  var accum = reduce(add, 0);
  var result = compose(accum, sqrt, gt100)(nums);

=============

with the above your code does look shorter. but there is one big plus with the latter that not only can you pass around the predicate but the operation in itself can be passed around(gt100 is reusable etc..). (ramda actually works like a functional library wherein the function/predicate is the first argument and the data structure is the last. this makes partial function application and currying work much better)

also when we do away with the boilerplate the final thing looks like this:

  // "I want the sum of the square roots 
  // of all numbers greater than 100 in this list".
  var result = nums
    .filter(gt100pred)
    .map(Math.sqrt)
    .reduce(add, 0);

vs

  // think of it as pipelining from right to left.
  // get any number > 100, sqrt it, then accumulate it.
  var result = compose(accum, sqrt, gt100)(nums);

and if this was haskell:

  foldl (+) 0 . map sqrt . filter (> 100) $ [0..300]