Practical functional programming in JavaScript

by walrus • 14 years ago

62 38 14 years ago

peteretep2• 14 years ago

> Currying is the process of converting a function of arity n into a nested set of functions with arity 1, i.e. making it partially applicable

If a reader knows what the words in the description mean, then presumably they know what currying is...

Wouldn't it be better to have documentation that illuminated, rather than showed off your grasp of programming terms?

peteretep2• 14 years ago

Also it seems a bit weird to have 'any' and 'filter' without having 'first'.

ostso• 14 years ago

Not really -- "any" and "filter" are total functions, but "first" of an empty list is undefined.

On the other hand, that also applies to foldl1 and {max,min}imum{,By}, so it's probably not the reason.

The reason is probably that in JavaScript you can just say a[0] to get the first element element of a.

ionfish12• 14 years ago

Of course it would. Patches which improved the documentation would be very welcome.

tikhonj• 14 years ago

I'd probably throw in concatMap, head, tail and the various scan functions for lists. Maybe init and last as well, although I never really use them.

As far as functions go, uncurry would be neat and create a nice symmetry along with curry.

ionfish12• 14 years ago

Patches for these would be welcome; I did mean to add them, but I got distracted by other projects, and then by my PhD.

egonschiele• 14 years ago

Looks awesome, mainly because all the function names tie up with Haskell, but what's the difference between this and underscore.js?

Also, you might be interested in Roy: http://roy.brianmckenna.org

ionfish12• 14 years ago

It has a few more functions that operate on lists, but it's missing a lot of the general utility functions that Underscore has.

Roy looks interesting, thanks for the link.

GeZe• 14 years ago

If you are interested in this you might want to check out http://gkz.github.com/prelude-ls/ - it has almost all the functions included in Udon as well as about 60 more based off of Haskell's Prelude module.

ionfish12• 14 years ago

That's very cool, although you have to use another dialect of JavaScript if you want to modify the source code, with all the disadvantages that entails.

jjm3• 14 years ago

True, but taking that aside and focusing on practicality, both underscorejs and Preludejs together provide one heck of a toolbox. I really enjoy functional programming a great deal and have been using it every which place I can the last several years. I totally understand that this is your take on the subject matter and so far so good, though the docs and usage for me are strange. If you have the goal of mass adoption you'll need to convince people like me why it needs adding to the toolbox.

Swizec• 14 years ago

As both a functional and a javascript programmer - I don't see the point of the curry function. I understand currying is great, I even use it a lot, but I don't see the benefit of converting a "normal" function to a curried one.

I mean, when I need currying, I just write my code like that.

Everything else looks pretty awesome!

Have you looked at underscore (http://underscorejs.org/) a lot of the functionality seems to overlap (and it's what I've been using for a long time to make functional javascript a bit more palatable)

tiglionabbit2• 14 years ago

I'm with you on the currying thing. The ability to curry functions doesn't enable you to do anything you couldn't already do better and with more flexibility by writing the full anonymous function.

Their example breaks down the moment your argument order matters: https://gist.github.com/3052264

Peaker2• 14 years ago

They seem to simply be missing flip.

  // Lets curry subtract instead of add
  var subtract = Udon.curry(function(a, b) {
      return a - b;
  });

  var five_minus = subtract(5);
  var minus_five = Udon.flip(subtract)(5)

ionfish12• 14 years ago

Yes, it does. This is true in Haskell too, of course.

    subtract :: (Int, Int) -> Int
    subtract (n, m) = n - m
    
    fiveMinus = (curry subtract) 5
    minusFive = ???
    
    subtract' = \n m -> n - m
    fiveMinus =   \m -> 5 - m
    minusFive =   \m -> m - 5

ionfish12• 14 years ago

To be honest, I completely agree with you. But it wouldn't be a JavaScript functional programming library if it didn't have the curry function.

I'm pretty familiar with Underscore, just wasn't happy with a couple of the design decisions, otherwise I would have just used that. Udon actually came out of various hacky functional JS libraries that I'd written over the years, and part of the motivation was to pull those together into a clean and coherent codebase.

walrus3• 14 years ago

Which of Underscore's design decisions didn't you like?

clux• 14 years ago

I'm in the process of writing my a functional utility library myself, and having thought about these things for a while, I think letting everyone curry things themselves make things less intelligent.

For example:

Udon.elem(2, [1, 2, 3]) === true;

As it stands this is simply an accessor for Array.prototype.indexOf. If people know how to use that, this alias is relatively useless unless you want to compose. And even then, you could always compose around the expression, or with a method on the prototype of the result (Number in this case).

However, it's very useful to have a curried version of it so that it can be used in filters:

[1,2,3,4,3,2].filter($.elem([2,4])); // [ 2, 4, 2 ]

This maintains your current javascript indexOf usage, but allows a higher order use that I think should be the default for this function.

If you want you JavaScript to look more like Haskell, then your way makes more sense, but having to write Udon.curry everywhere sort of takes away from that cleanliness you are trying to recreate. I prefer to not mess with existing semantics too much because of it. For reference, here's my library: https://github.com/clux/interlude#usage

ionfish12• 14 years ago

> having to write Udon.curry everywhere sort of takes away from that cleanliness you are trying to recreate.

This is true, and I considered your approach when writing functions like `elem`. There were two reasons for this. Firstly, I wanted to avoid introducing more closures than necessary. Secondly, I wanted to keep the source code reasonably transparent (if admittedly rather terse).

There is definitely a place for your approach, and it may even be the better one in practise. It's hard to say without writing large projects in both.

mappu• 14 years ago

Is it standard practice in other languages / libraries to have the function argument first and the data argument second, in e.g. map and filter?

In usual PHP fashion, array_map and array_filter take arguments in different orders. From all the jQuery i write it seems more natural to put the function argument last ($.get, $().bind, etc).

rapala• 14 years ago

I think the order of arguments comes from the use of partial application. In Haskell you can write:

  doubler :: Num a => [a] -> [a]
  doubler = map (2 *)

walrus3• 14 years ago

Putting the data argument second is nice when combined with currying. For example:

  var bigNumbers = Udon.curry(Udon.filter)(function (number) {
      return number > 5;
  });
  bigNumbers([3, 1, 4, 1, 5, 9]);  // [9]
  bigNumbers([2, 7, 1, 8, 2, 8]);  // [7, 8, 8]

JackC• 14 years ago

The other reason things work this way in functional languages might be the way your nesting tends to work out. For example, it would be common in Clojure to write something like:

    (set-result-to (do-this-to (do-that-to (do-the-other-thing-to (map map-function some-input-data)))))

If the order of arguments to map was reversed, your map function would be the only one messing up the right-to-left flow of your data.

/so not a functional programmer

masklinn2• 14 years ago

Why would I go with Udon (eager, functional) rather than underscore (also eager and functional, but more popular) or wu.js (lazy & functional)?

ionfish12• 14 years ago

You probably shouldn't. :)

sodelate• 14 years ago

i don't see any advantage of using it

Practical functional programming in JavaScript

Related Stories