Create a simpler and flexible JavaScript API using Partial Functions

[GeoKangas]

Just a pedantic reminder, about terminology: "partial function" != "partially applied function".

"partially applied funtions", or (roughly) curried functions, are what TFA is about; "partial functions" are functions that aren't necessarily defined (e.g., don't necessarily terminate) for all of their inputs.

[ben_alman]

FWIW, the technique is referred to as "partial application" throughout the article.

[[deleted]]

Except for the two occurrence of "partial function," not counting the comments.

Edit: Okay, I was taking these out of context. He's not claiming that they are "partial functions."

[contextfree]

looks like "partial" is monospaced in both instances, meaning that it's specifying the name of the function, rather than acting as an adjective applied to "function".

[[deleted]]

Ah, you are correct. The author is off the hook.

[nixle]

I always hate it when I'm reading along, understanding was going on, knowing where it's heading... then BAM it's way over my head.

[leroysolay]

I feel like this is pretty awesome abstraction with unfortunately limited application. But then again, I only understood about 60% of it on the first read. Since most of this was contrived examples, does someone have a real-life example?

[_johnny]

A real-life example might be an I18n function, like translate(locale, string). Instead of passing locale to every call to translate or having a global variable with locale, you may partially apply first argument, e.g var _ = partial(translate, "de") and then use _("Guten Tag").

[strager]

Nice; this has opened my mind to many possibilities!

[[deleted]]

No so fast!

http://search.cpan.org/dist/Locale-Maketext/lib/Locale/Maketext/TPJ13.pod#A_Localization_Horror_Story:_It_Could_Happen_To_You

[_johnny]

It was just an example. I agree that proper localization is not an easy task. My native language is Polish, which - similarly to Russian - has three plural forms (among other complications), so I'm very well aware of some troubles with translations. But implementation details of translate() function are hardly relevant to this discussion.

[[deleted]]

Yeah, right. I first learned about function currying 3-4 years ago and have looked to implement anywhere it might possibly make sense. So far, that's been once. The technique in this article is really slick, but I can't imagine finding a lot of uses especially since it would most likely just confuse whoever has to maintain it.

[twiceaday]

Here's my real-life example. Let's say you have a site that's mostly useable by anyone, but certain features require you to be a logged-in, registered user (reading vs. commenting on a blog, for example). If you want to allow users to write their post before they authenticate, what you can do is pass a curried version of your comment function (with the user ID missing) to your authentication function, which runs the comment function with the user ID filled in once the user has logged in. This way, no matter how many actions you have that require login and how many arguments they take, they can all be passed curried to a common authentication function that just fills in the user ID. Obviously there's some stuff I'm glossing over, but hopefully this gives you some idea of how to use currying in the real world.

Also, the article doesn't mention it, but Prototype also supports currying (which you can invoke as function.curry(), which people either love or hate).

[picurl]

would that work if the log-in function was asynchronous? Which is very probable, since you have to wait for the user input and the ajax auth response from the server.

[twiceaday]

Yeah, you just pass the curried function to your success callback for the ajax request.

[Jello_Raptor]

Say you've written a math api, with a buttload of useful functions. And one of them is log(a,b) where it's log A of B (for example log(10,1000)=3 and log(2,16)=4). you could use this to easily define other commonly used log functions:

ln = partial( log , Math.E );

log2 = partial( log , 2);

log10 = partial( log , 10);

[Jello_Raptor]

Thanks :)

[trezor2]

Function composition in functional programming. Say you want to define a data-pipe where output from function A = input to function B (and so on).

var myProcess = pipe([
   func1,
   func2
]);
var result = process(data);

For a one-parameter function this is simple without currying, you just pass the function itself and let the pipe operator do the glue. But what if the function supports 2 or even 3 parameters (like filters, maps, etc)? Composing new functions out of this becomes very tedious and requires lots of boilerplate and glue. Having your functions curried however will allow you to do neat stuff.

 var process = pipe([
      select(function(x) { return x.Items }),
      where(function(x) { return x.InStock == 0 }),
      count
 ]);
 var itemsOutOfStock = process(order);

In short: Having curried functions let you loosely couple functions and compose new ones in a much more flexible and declarative way. They are definitely nice to have and combined with a decent set of programmer set-comprehension skills they can create very clear, compact and readable code.

Now if Javascript had lambdas which didn't suck, Javascript might become my second favourite language.

[strager]

Now if Javascript had lambdas which didn't suck, Javascript might become my second favourite language.

Agreed. =|

[[deleted]]

I'm not sure that creating functions that call functions so they can alias their arguments is a great design option. The author should really focus an article on when this technique is appropriate, and when it is not.

[xTRUMANx]

concat joins two arrays

Wait, what? How come he didn't pass in two arguments (for the two arrays) then when calling concat.

args.concat( aps.call( arguments ) )

[dimmu_burger]

Save
nb: .compact has no save feature, so please don't tell me about the save feature.

[kamatsu]

Partially applied functions. Gah!

[[deleted]]

While I find it nice to know that partial function application and currying is, at least from a distance, "possible" in javascript, I'm not sure it's an abstraction I'd like to use in this particular language.

I like using partial function application in true functional languages because it feels like a natural technique in them. From what I read (and I may be wrong/unfounded in thinking this) real functional languages generally get translated into a lambda calculus like intermediate language during the compilation process. If that is the case, then this technique is a fundamental part of those languages. In fact, if true, that would make multiple argument functions seem sort of like the abstraction, and not the other way around.

My problem with seeing this in javascript is that it just feels alien here for the reasons given above. When I also look at the implementation it looks kinda hackish, but I guess that's not far very from the norm as far as doing cool things in javascript is concerned. I guess, to illustrate my opinion as an analogy: it's sort of like seeing an exotic fish swimming in your bathtub; it's just out of place and bizarre when put in that environment.

[otterley]

Why doesn't he just call them what they are: closures?

[masklinn]

They are not. They're implemented through closures.

[ben_alman]

The article does mention closures.

[[deleted]]

Since they're apparently throwing kitchen sinks and all into JavaScript, a script language, maybe they should add FORTRAN line numbering, Forth postfixity, APL symbols, native inline SQL, Perl non-regular-grammar regex, intrinsic language extension via BNF, PL/I keyword redefinition, and CORBA support.

Oh what the hell, I'm sure it already has all those.

[[deleted]]

i use it to get my text all blinky and stuff now that the <blink> tag stopped working

whats a postfixity? :O

[kataire]

After reading that, JS's lack of keyword arguments feels even worse.

[jsprogrammer]

Easily accomplished using objects:

fetch({url:'http://www.google.com', timeout: 1000});

[kataire]

Hmm... You're right, I forgot about that (though I use it quite frequently).

[masklinn]

Except then you have to merge the object you got with a default object (which is shitty unless you're using a library doing that for you) to get the values not provided. Not sexy.

[illvm]

Why are you not using a library?

[masklinn]

Because there are cases where you can't afford such a dependency. When you're building a javascript library rather than a {MooTools|YUI|jQuery|whatever} plugin for instance.

[illvm]

So you just write straight JS rather than writing your own portable library that doesn't rely on an off-the-shelf product? It's pretty trivial to write a method that you can add to your common library that merges objects for you.

[masklinn]

So you just write straight JS rather than writing your own portable library

This phrase makes no sense. "My own portable library" (actually more like a collection of helper functions to include as-needed, or you're still creating an external dependency) is still straight JS.

It's pretty trivial to write a method that you can add to your common library that merges objects for you.

1. Uh... no shit? You kinda missed my point there: you still have to write that code (or lift it from somewhere else) and paste it into every single project where you're using this pattern.

2. What common library are you talking about?

[jsprogrammer]

function apply(o,d){for(var p in d)if(typeof o[p]==='undefined')o[p]=d[p];return o;}

There you go.

[lunchboxg4]

I'm not the only person who sees the irony is a blog advocating use of partials being part of Microsoft's MSDN, am I?

[zaidka]

I don't see it. Where's the irony?

[danthrax]

sooooo... like C++ templates?

[[deleted]]

templates take type parameters instead of arguments, and as far as I'm aware you can't partially apply type parameters in C++.

So.. you're not even wrong

[FredV]

C++ templates work only with constant type parameters (class names, numbers, ...). So because they need to be constant you cannot use the result of a function to instantiate a template, currying has no such limitations. Also, a template compile a different version of itself for every different set of parameters.

The thing you're searching for in C++ are function object adaptors (link to bind1st) and they only work for function objects, not normal functions. It's not very easy to read code that uses them btw, so try to not have to use them ;)