Comments on: Partially Applied Functions In JavaScript

By: Andrew Kirkegaard

Andrew Kirkegaard — Tue, 04 Sep 2012 16:21:00 +0000

How would you bind the second attribute?
Like: var render = _.bind(Backbone.Marionette.Renderer.render, null, undefined, this.options.x);
Backbone.Marionette.TemplateCache.get(this.template)
.then(render)
.then(function (html) { that.$el.html(html); }) ;
In order to partially apply Marionette’s render to the serialized data, and then run when the Template is received.

By: David Tchepak

David Tchepak — Wed, 25 Jul 2012 01:11:00 +0000

I get what you mean, although compose is still a list of steps:

_.compose(a, b, c)(x) == a(b(c(x)))
// Which is the same as
var resultC = c(x)
var resultB = b (resultC)
var resultA = a ( resultB )

While “then” reads naturally to imperative programmers like me, I’m aware that learning to “speak” FP will probably make composition seem just as natural. I’m trying to learn this at the moment, as I feel being able to think in terms of composition will give me additional ways of thinking about problems.

For example, it may lead me to think of testing the composed “buildThumbnails” function separately from the async “whenFolderCreated” function, where I previously may have stubbed out the “localFolder.createFolderAsync” call.

You can also write a flipped compose function to compose left-to-right instead of right-to-left for cases where that reads more naturally.

Obviously none of this is to say that the chained calls are wrong, just that I’ve found it interesting and potentially useful to also think in terms of composition, so thought I’d share. :)

Cheers,
Dave

By: Derick Bailey

Derick Bailey — Tue, 24 Jul 2012 15:29:00 +0000

oops! yes. :)

i updated the gist to correct this. it will take a day or two for the cache to clear and be reflected in this post.

By: dan

dan — Tue, 24 Jul 2012 15:23:00 +0000

https://gist.github.com/3151016#file_3.js

Does partial need to bind to add?

var partial = _.bind(add, null, 1);

By: Derick Bailey

Derick Bailey — Tue, 24 Jul 2012 13:54:00 +0000

nice! wasn’t aware of that. in situations where you need to pass one function around, that would definitely be useful.

in my case, i don’t need to pass anything around. i want the code to read as a list of steps “this, then this, then this, then this”.

i’ll have to keep “compose” in mind, though. will be very useful.

By: David Tchepak

David Tchepak — Tue, 24 Jul 2012 12:55:00 +0000

Have you tried using function composition instead of chaining calls? I haven’t tried it in JS myself, but Liam recently pointed me to underscore’s compose function which looks quite interesting. AFAICT it would let you do something like:

//pseudocode
var buildThumbnails = _.compose(
   Tiles.update,
   Tiles.getFolderNamesFromFiles,
   Tiles.copyImages.bind(null, files));

whenFolderCreated.then(buildThumbnails);

Just another way to write the same thing I think, although a single composed function has the advantage of being able to be picked up and moved around / reused more easily than a chain of calls.

By: Derick Bailey

Derick Bailey — Fri, 20 Jul 2012 15:56:00 +0000

D’oh! I copied the wrong function out of that article. Thanks for letting me know :) I updated the gist, but it might take a day or so for the caching to clear up.

By: Matthew Manela

Matthew Manela — Fri, 20 Jul 2012 15:45:00 +0000

I think the example usage you provide from the Partial functional implementation from John Resig’s blog is incorrect.

The way that function works you need to pass in ‘undefined’ for the parameters you would like to be filled later.

var partial = add.partial(1);
console.log(partial(2) === 3); // = false
console.log(partial(2) === NaN); // = true

partial = add.partial(1,undefined);
console.log(partial(2) === 3); // = true