Currying is mostly used if the second parameter section is a function or a by name parameter. This has two advantages. First, the function argument can then look like a code block enclosed in braces. E.g. using(new File(name)) { f => … } This reads better than the uncurried alternative: using(new File(name), f => { … Read more
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. … Read more
EDIT: As noted in comments, this is partial application rather than currying. I wrote a blog post on my understanding of the difference, which folks may find interesting. Well, it’s not particularly different – but I’d separate out the currying part from the “calling DoSomething” part: public static Func<TResult> Apply<TResult, TArg> (Func<TArg, TResult> func, TArg … Read more
1. What is currying? Currying simply means a transformation of a function of several arguments to a function of a single argument. This is most easily illustrated using an example: Take a function f that accepts three arguments: int f(int a,std::string b,float c) { // do something with a, b, and c return 0; } … Read more
Multiple Parameter List Methods For Type Inference Methods with multiple parameter sections can be used to assist local type inference, by using parameters in the first section to infer type arguments that will provide an expected type for an argument in the subsequent section. foldLeft in the standard library is the canonical example of this. … Read more
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; }; }
The semantic difference has been explained fairly well in the answer linked to by Plasty Grove. In terms of functionality, there doesn’t seem much of a difference, though. Let’s look at some examples to verify that. First, a normal function: scala> def modN(n: Int, x: Int): Boolean = ((x % n) == 0) scala> modN(5, … Read more
Strictly speaking, this is not a curried function, but a method with multiple argument lists, although admittedly it looks like a function. As you said, the multiple arguments lists allow the method to be used in the place of a partially applied function. (Sorry for the generally silly examples I use) object NonCurr { def … Read more
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 add the currying mechanism. This was much easier to do than modifying the compiler, and is sufficient to … Read more
Here’s an interesting AND practical use of currying in JavaScript that uses closures: function converter(toUnit, factor, offset, input) { offset = offset || 0; return [((offset + input) * factor).toFixed(2), toUnit].join(” “); } var milesToKm = converter.curry(‘km’, 1.60936, undefined); var poundsToKg = converter.curry(‘kg’, 0.45460, undefined); var farenheitToCelsius = converter.curry(‘degrees C’, 0.5556, -32); milesToKm(10); // returns … Read more