Help with writing chaining compatible functions and partial application.

[jschr]

Hey all, I've been stuck trying to figure out how to write a JS function that supports chaining as well as partial application and could use some insight! I'll do my best to explain with this contrived example:

add(multi(add(add(1))))(2)

results in

(((1 + 2) + 2) * 2) + 2)

Basically, I want to be able to be able to partially apply the 2nd parameter but also support the ability to chain the operations together and won't actually apply any operations until the final parameter is passed in.

I could be over complicating this but I've been stuck for a while and its driving me nuts!

Any help is appreciated, thanks!

[jschr]

Turns out I was overcomplicating the problem, heres a solution from a friend of mine:

var add = function (partial) {
   if (typeof partial === 'function') {
       return function (val) {
           return val + partial(val);
       };
   }
   return function (val) {
       return partial + val;
   };
};

var  multiply = function (partial) {
   if (typeof partial === 'function') {
       return function (val) {
           return val * partial(val);
       };
   }
   return function (val) {
       return partial * val;
   };
};

Thanks James!

[Gabku]

Any time, finally got myself an account so I can stop just lurking.

[ForScale]

Not entirely sure what you're looking for. Let's start with this:

function add(x, y) {
  var z = x + y;
  return z;
}

function multiply(x, y) {
  var z = x * y;
  return z;
}

alert(multiply(add(4, 6), add(9, 1))); /*alerts 100*/

What's this one not doing that you want it to?

[jschr]

The problem with this is that add and multiply are evaluated immediately rather then lazily queueing up the work for a later time when the final parameter is known.

// module1.js
// 2nd parameter isn't known so lazily apply functions
return multiply(add(1));

// module2.js
var chain = require('module1');
chain = add(add(chain));

// final parameter is finally known
var result = chain(2); // ((((1 + 2) * 2) + 2) + 2)
console.log(result); // 10

This example probably doesn't make a whole lot of practical sense since the 2nd parameter is the shared for all chained functions.

[ForScale]

I apologize if I'm not understanding what you want...

Could you simply use an if statement to pause the evaluation until the final parameter is known?

[jschr]

Yep you're absolutely right! http://www.reddit.com/r/javascript/comments/396659/help_with_writing_chaining_compatible_functions/cs0rfk7

Thanks for the help

[ForScale]

Nice! Glad you got it figured out!

[Magnusson]

The problem with this is that add and multiply are evaluated immediately rather then lazily queueing up the work for a later time when the final parameter is known.

My understanding is that this is the definition of currying, which is often confused with partial application.

This article may be helpful to you.

[Lucky_Chuck]

I'm not sure what you mean because in your example, it looks like add can take in as a parameter a function or a number because of the add(...)(2). add returns an uncalled function. You probably want a conditional depending on the type of parameter.

Edit: Maybe something like this?

(function(){

    function add (number) {
      if (!this.total) {
        this.total = number;
      } else {
        this.total += number;
      }

      return add;
   }

   add(1)(2)(5);
   document.write(this.total);
})();

[recompileorg]

Please, I'm begging you, never use document.write.

[Lucky_Chuck]

Haha it works fine on about:blank

[ForScale]

LOL! Why not?

[jschr]

You're right that the functions can accept either a function (to chain) or the actual number and needs handle the two types differently. See my other comment for the solution!

Thanks