A decorator for modifying a function to lift functions to work with different types of arguments

useWith.js

//
// Some common utility combinators and helpers
//
function flip(fn) {
    return function() {
        var args = [].slice.call(arguments);
        return fn.apply(this, args.reverse());
    };
}

function rightCurry(fn, n) {  
  var arity = n || fn.length,
      fn = flip(fn);
  return function curried() {
      var args = [].slice.call(arguments), 
          context = this;

      return args.length >= arity ?
          fn.apply(context, args.slice(0, arity)) : 
          function () {
              var rest = [].slice.call(arguments);
              return curried.apply(context, args.concat(rest));
          };
  };
}
function get(obj, prop) {
    return obj[prop];
}
function map(list, fn) {
    return list.map(fn);
}
function pluck(obj, prop) {
  return obj[prop];
}
var getWith = rightCurry(get),
    mapWith = rightCurry(map),
    pluckWith = rightCurry(pluck);


// Similar to Ramda's useWith(fn,...), A function decorator which 
// returns a function and takes a function to decorate, along with zero or
// more 'transform' functions.  
// The returned function, when called, will called the decorated function
// with the parameters it receives being augmented by the corresponding
// transform function.
// If there are more arguments than transform functions, those arguments 
// will be passed as is to the decorated function
// @return {Function} - a decorated version of the function passed as the first parameter
// @param {Function} - The function to decorate or wrap
// @param [{Function...}] - one or more transform functions, used to augment arguments
//      passed to the decorated function when invoked.
//
function useWith(fn /*, txnformfn, ... */) {
  var transforms = [].slice.call(arguments, 1),
      _transform = function(args) {
        return args.map(function(arg, i) {
          return transforms[i](arg);
        });
      };
  return function() {
    var args = [].slice.call(arguments),
        targs = args.slice(0,transforms.length),
        remaining = args.slice(transforms.length);

    return fn.apply(this, _transform(targs).concat(remaining));
  }
}

// A simple, resuable comparison for '>='
function greaterThanOrEqual(a, b) {
  return a >= b
}
// Right curried so we can create useful unary predicates
var greaterThanOrEqualTo = rightCurry(greaterThanOrEqual);

// Create a unary predicate to use with filter that lets us filter
// for values >= 30 days ago
var newerThan30Days = greaterThanOrEqualTo((new Date()).getTime() - (86400000 * 30));

// Array of sample object data
var dates = [ 
  { id: 1, date: (new Date('2015-07-29')).getTime() }, 
  { id: 2, date: (new Date('2015-05-01')).getTime() }
];

// Use our newerThan30Days predicate, modified using withProp
// to allow it to access object's `.date` property
dates.filter(useWith(newerThan30Days, pluckWith('date')));

Updated and added a useWith() function which is a more generic version of my original withProp() function, which matches the similarly named function in the Ramda.js functional library. useWith() basically returns a function that modifies the original function passed in by passing any arguments to the called function through a set of transform functions provided as the 1...N arguments of the original useWith() call.

For instance, if we wanted to use our simple greaterThanOrEqualTo() comparison to allow using objects, we could call it as:

var obj1 = { name: 'Dave' },
      obj2 = { name: 'Angie' };

useWith(greaterThanOrEqual, pluckWith('name'), pluckWith('name'))(obj1, obj2);
// true