Hacker News Reader

Comment by Swizec | Hacker News Reader

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)

View on HN

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

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)

Yes, although there is one subtlety here: should `flip` return a curried function, or an uncurried function? This isn't an issue in Haskell since it only has unary functions.

Haskell has tuples, so it could use an:

  (a, b) -> c

representation. If the uniform/canonical way to use functions is defined to be curried, then flip can simply return them curried.

> Haskell has tuples, so it could use an:

Which it does:

    curry :: ((a, b) -> c) -> a -> b -> c

    uncurry :: (a -> b -> c) -> (a, b) -> c

How about both?

  Udon.flip = function(f) {
      return function(x) {
          if(arguments.length > 1) {
              return f(arguments[1])(x);
          }
          return function(y) {
              return f(y)(x);
          };
      };
  };

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

Yes, what does? Are you agreeing or disagreeing with my statement that currying is useless? I think you're agreeing.

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.

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

Oh, I think it was mainly trivial stuff. I'm afraid I don't remember the specifics, this was two years ago.

Reply on news.ycombinator.com