currying

I have twice recently refactored code in order to change the order of parameters because there was too much code where hacks like flip or \x -> foo bar x 42 were happening. When designing a function signature what principles will help me to make the best use of currying? For languages that support currying and partial-application easily, there is one compelling series of arguments, originally from Chris Okasaki: Put the data structure as the last argument Why? You can then compose operations on the data nicely. E.g. insert 1 $ insert 2 $ insert 3 $ s . This also helps for functions on state .

I wrote a simple curry function in JavaScript which works correctly for most cases: const add = curry((a, b, c) => a + b + c); const add2 = add(2); const add5 = add2(3); console.log(add5(5)); <script> const curried = Symbol("curried"); Object.defineProperty(curry, curried, { value: true }); function curry(functor, ...initArgs) { if (arguments.length === 0) return curry; if (typeof functor !== "function") { const value = JSON.stringify(functor); throw new TypeError(`${value} is not a function`); } if (functor[curried] || initArgs.length >= functor.length) return functor(...initArgs); const

Say I have a pointer to a function _stack_push(stack* stk, void* el) . I want to be able to call curry(_stack_push, my_stack) and get back a function that just takes void* el . I couldn't think of a way to do it, since C doesn't allow runtime function definition, but I know there are far cleverer people than me here :). Any ideas? Jared Oberhaus I found a paper by Laurent Dami that discusses currying in C/C++/Objective-C: More Functional Reusability in C/C++/Objective-c with Curried Functions Of interest to how it is implemented in C: Our current implementation uses existing C constructs to

I want to make this syntax possible: var a = add(2)(3); //5 based on what I read at http://dmitry.baranovskiy.com/post/31797647 I've got no clue how to make it possible. You need add to be a function that takes an argument and returns a function that takes an argument that adds the argument to add and itself. var add = function(x) { return function(y) { return x + y; }; } function add(x) { return function(y) { return x + y; }; } Ah, the beauty of JavaScript This syntax is pretty neat as well function add(x) { return function(y) { if (typeof y !== 'undefined') { x = x + y; return arguments

I realize that there are several questions on here about what currying and partially applied functions are, but I'm asking about how they are different. As a simple example, here is a curried function for finding even numbers: def filter(xs: List[Int], p: Int => Boolean): List[Int] = if (xs.isEmpty) xs else if (p(xs.head)) xs.head :: filter(xs.tail, p) else filter(xs.tail, p) def modN(n: Int)(x: Int) = ((x % n) == 0) So you could write the following to use this: val nums = List(1,2,3,4,5,6,7,8) println(filter(nums, modN(2)) which returns: List(2,4,6,8) . But I've found that I can do the same

I don’t think I’ve grokked currying yet. I understand what it does, and how to do it. I just can’t think of a situation I would use it. Where are you using currying in JavaScript (or where are the main libraries using it)? DOM manipulation or general application development examples welcome. One of the answers mentions animation. Functions like slideUp , fadeIn take an element as an arguments and are normally a curried function returning the high order function with the default “animation function” built-in. Why is that better than just applying the higher-up function with some defaults? Are