What is currying?

How can currying be done in C++?

Please Explain binders in STL container?




How can currying be done in C++?

I&#39;m trying to understand the advantages of currying over partial applications in Scala. Please consider the following code:

      def sum(f: Int =&gt; Int) = (a: Int, b: Int) =&gt; f(a) + f(b)
    
      def sum2(f: Int =&gt; Int, a: Int, b: Int): Int = f(a) + f(b)

      def sum3(f: Int =&gt; Int)(a: Int, b: Int): Int = f(a) + f(b)
      
      val ho = sum({identity})
      val partial = sum2({ identity }, _, _)
      val currying = sum3({ identity })
    
      val a = currying(2, 2)
      val b = partial(2, 2)
      val c = ho(2, 2)

So, if I can calculate partially applied function that easy, what are the advantages of currying?

Usefulness (as in practical applications) of Currying v.s. Partial Application in Scala

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][1] 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 there any drawbacks to using it?

As requested here are some good resources on JavaScript currying:

  - [http://www.dustindiaz.com/javascript-curry/][2]
  - Crockford, Douglas (2008) *JavaScript: The Good Parts*
  - [http://www.svendtofte.com/code/curried_javascript/][3]
 (Takes a detour into ML so skip the whole section from “A crash course in ML” and start again at “How to write curried JavaScript”)
  - [http://web.archive.org/web/20111217011630/http://blog.morrisjohns.com:80/javascript_closures_for_dummies][4]
  - [https://stackoverflow.com/questions/111102/how-does-a-javascript-closure-work][5]
  - **[http://ejohn.org/blog/partial-functions-in-javascript][6] (Mr. Resig on the money as per usual)**
  - &lt;http://benalman.com/news/2010/09/partial-application-in-javascript/&gt;

I’ll add more as they crop up in the comments.

---

So, according to the answers, currying and partial application in general are convenience techniques.

If you are frequently “refining” a high-level function by calling it with same configuration, you can curry (or use Resig’s partial) the higher-level function to create simple, concise helper methods.


  [1]: https://stackoverflow.com/questions/113780/javascript-curry-what-are-the-practical-applications#113799
  [2]: http://www.dustindiaz.com/javascript-curry/
  [3]: http://www.crockford.com/javascript/www_svendtofte_com/code/curried_javascript/index.html
  [4]: http://web.archive.org/web/20111217011630/http://blog.morrisjohns.com:80/javascript_closures_for_dummies
  [5]: https://stackoverflow.com/questions/111102/how-does-a-javascript-closure-work
  [6]: http://ejohn.org/blog/partial-functions-in-javascript/

JavaScript curry: what are the practical applications?

I&#39;ve seen references to curried functions in several articles and blogs but I can&#39;t find a good explanation (or at least one that makes sense!)

What is &#39;Currying&#39;?

I have read several Java 8 tutorials before.

Right now I encountered following topic:
https://stackoverflow.com/questions/6134278/does-java-support-currying

Here, I see following code:

    IntFunction&lt;IntUnaryOperator&gt; curriedAdd = a -&gt; b -&gt; a + b;
    System.out.println(curriedAdd.apply(1).applyAsInt(12));


I understand that this example sum 2 elements but I cannot understand the construction:


    a -&gt; b -&gt; a + b;

According to the left part of expression, this row should implement following function:

    R apply(int value); 

Before this, I only met lambdas only with one arrow.

What does lambda with 2 arrows mean in Java 8?

In Python, I&#39;d like to write a function `make_cylinder_volume(r)` which returns another function. That returned function should be callable with a parameter `h`, and return the volume of a cylinder with height `h` and radius `r`.

I know how to return *values* from functions in Python, but how do I return *another function*?

How do I write a function that returns another function?

I quite often see on the Internet various complaints that other peoples examples of currying are not currying, but are actually just partial application.

I&#39;ve not found a decent explanation of what partial application is, or how it differs from currying. There seems to be a general confusion, with equivalent examples being described as currying in some places, and partial application in others.

Could someone provide me with a definition of both terms, and details of how they differ?

What is the difference between currying and partial application?

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 -&gt; foo bar x 42` were happening.

When designing a function signature what principles will help me to make the best use of currying? 

Ordering of parameters to make use of currying

I was wondering if there is any way to pull that in Java. I think it is not possible without native support for closures.

Does Java support Currying?

In Scala one can write (curried?) functions like this

    def curriedFunc(arg1: Int) (arg2: String) = { ... }

What is the difference between the above `curriedFunc` function definition with two parameters lists and functions with multiple parameters in a single parameter list: 

    def curriedFunc(arg1: Int, arg2: String) = { ... }

From a mathematical point of view this is `(curriedFunc(x))(y)` and `curriedFunc(x,y)` but I can write `def sum(x) (y) = x + y` and the same will be `def sum2(x, y) = x + y`

I know only one difference - this is partially applied functions. But both ways are equivalent for me.

Are there any other differences?

What&#39;s the difference between multiple parameters lists and multiple parameters per list in Scala?

I am having a discussion around *[Multiple Parameter Lists][1]* in the Scala Style Guide I maintain. I&#39;ve come to realize that there are two ways of [currying][2], and I&#39;m wondering what the use cases are:

    def add(a:Int)(b:Int) = {a + b}
    // Works
    add(5)(6)
    // Doesn&#39;t compile
    val f = add(5)
    // Works
    val f = add(5)_
    f(10) // yields 15

    def add2(a:Int) = { b:Int =&gt; a + b }
    // Works
    add2(5)(6)
    // Also works
    val f = add2(5)
    f(10) // Yields 15
    // Doesn&#39;t compile
    val f = add2(5)_

The style guide incorrectly implies these are the same, when they are clearly not. The guide is trying to make a point about created curried functions, and, while the second form is not &quot;by-the-book&quot; currying, it&#39;s still very similar to the first form (though arguably easier to use because you don&#39;t need the `_`)

From those that use these forms, what&#39;s the consensus on when to use one form over the other?

  [1]: http://davetron5000.github.com/scala-style/declarations/methods/currying.html
  [2]: http://en.wikipedia.org/wiki/Currying


Two ways of currying in Scala; what&#39;s the use-case for each?

I realize that there are several questions on here about ***what*** currying and partially applied functions are, but I&#39;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 =&gt; 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&#39;ve found that I can do the same thing this way:

    def modN(n: Int, x: Int) = ((x % n) == 0)

    val p = modN(2, _: Int)
    println(filter(nums, p))

which also returns: `List(2,4,6,8)`. 

So my question is, what&#39;s the main difference between the two, and when would you use one over the other? Is this just too simplistic of an example to show why one would be used over the other?

Scala currying vs partially applied functions

Multiple parameters lists, e.g. `def foo(a:Int)(b:Int) = {}` and multiple parameters per list, e.g. `def foo(a:Int, b:Int) = {}` are semantically equivalent so far as I can tell, and most functional languages have only one way of declaring multiple parameters, e.g. F#.

The only reason I can figure out for supporting both these styles of function definitions is to allow syntax-like language extensions using a parameter list that has only one parameter in it.

    def withBufferedWriter(file: File)(block: BufferedWriter =&gt; Unit)

can now be called with the syntax-looking

    withBufferedWriter(new File(&quot;myfile.txt&quot;)) { out =&gt;
      out write &quot;whatever&quot;
      ...
    }

However, there could be other ways of supporting the use of curly braces without having multiple parameter lists.

A related question: why is the use of multiple parameter lists in Scala called &quot;currying&quot;? Currying is usually defined as a technique for making an n-ary function unary for the sake of supporting partial application. However, in Scala one can partially apply a function without making a &quot;curried&quot; (multiple parameter lists with one param each) version of the function.

Why does Scala provide both multiple parameters lists and multiple parameters per list?

I have been getting into the basics of functional programming with C++. I am trying to make a function `f(a)(b)(c)` that will return `a + b + c`. I successfully implemented the function `f(a)(b)` which returns a + b. Here is the code for it:

    std::function&lt;double(double)&gt; plus2(double a){
        return[a](double b){return a + b; };
    }

I just cannot figure out how to implement the function `f(a)(b)(c)` which as I previously stated should return `a + b + c`.

Functional programming in C++. Implementing f(a)(b)(c)

I am always interested in learning new languages, a fact that keeps me on my toes and makes me (I believe) a better programmer. My attempts at conquering Haskell come and go - twice so far - and I decided it was time to try again. 3rd time&#39;s the charm, right?

Nope. I re-read my old notes... and get disappointed :-(

The problem that made me lose faith last time, was an easy one: permutations of integers.
i.e. from a list of integers, to a list of lists - a list of their permutations:

    [int] -&gt; [[int]]

This is in fact a generic problem, so replacing &#39;int&#39; above with &#39;a&#39;, would still apply.

From my notes:

I code it first on my own, I succeed. Hurrah!

I send my solution to a good friend of mine - Haskell guru, it usually helps to learn from gurus - and he sends me this, which I am told, &quot;expresses the true power of the language, the use of generic facilities to code your needs&quot;. All for it, I recently drank the kool-aid, let&#39;s go:

    permute :: [a] -&gt; [[a]]
    permute = foldr (concatMap.ins) [[]]
       where ins x []     = [[x]]
             ins x (y:ys) = (x:y:ys):[ y:res | res &lt;- ins x ys]

Hmm.
Let&#39;s break this down:

    bash$ cat b.hs
    ins x []     = [[x]]
    ins x (y:ys) = (x:y:ys):[ y:res | res &lt;- ins x ys]
    
    bash$ ghci
    Prelude&gt; :load b.hs
    [1 of 1] Compiling Main             ( b.hs, interpreted )
    Ok, modules loaded: Main.
    
    *Main&gt; ins 1 [2,3]
    [[1,2,3],[2,1,3],[2,3,1]]

OK, so far, so good. Took me a minute to understand the second line of &quot;ins&quot;, but OK:
It places the 1st arg in all possible positions in the list. Cool.

Now, to understand the foldr and concatMap. in &quot;Real world Haskell&quot;, the DOT was explained...

    (f . g) x

...as just another syntax for...

    f (g x) 

And in the code the guru sent, DOT was used from a foldr, with the &quot;ins&quot; function as the fold &quot;collapse&quot;:

    *Main&gt; let g=concatMap . ins
    *Main&gt; g 1 [[2,3]]
    [[1,2,3],[2,1,3],[2,3,1]]

OK, since I want to understand how the DOT is used by the guru, I try the equivalent expression according to the DOT definition, (f . g) x = f (g x) ...

    *Main&gt; concatMap (ins 1 [[2,3]])
    
    &lt;interactive&gt;:1:11:
         Couldn&#39;t match expected type `a -&gt; [b]&#39;
                against inferred type `[[[t]]]&#39;
         In the first argument of `concatMap&#39;, namely `(ins 1 [[2, 3]])&#39;
         In the expression: concatMap (ins 1 [[2, 3]])
         In the definition of `it&#39;: it = concatMap (ins 1 [[2, 3]])

What!?! Why?
OK, I check concatMap&#39;s signature, and find that it needs a lambda and a list, but that&#39;s 
just a human thinking; how does GHC cope? According to the definition of DOT above...

    (f.g)x = f(g x), 

...what I did was valid, replace-wise:

    (concatMap . ins) x y = concatMap (ins x y)

Scratching head...

    *Main&gt; concatMap (ins 1) [[2,3]]
    [[1,2,3],[2,1,3],[2,3,1]]

So... The DOT explanation was apparently
too simplistic... DOT must be somehow clever enough to understand
that we in fact wanted &quot;ins&quot; to get curri-ed away and &quot;eat&quot; the first
argument - thus becoming a function that only wants to operate on [t]
(and &quot;intersperse&quot; them with &#39;1&#39; in all possible positions). 

But where was this specified? How did GHC knew to do this, when we invoked:

    *Main&gt; (concatMap . ins) 1 [[2,3]]
    [[1,2,3],[2,1,3],[2,3,1]]

Did the &quot;ins&quot; signature somehow conveyed this... &quot;eat my first argument&quot; policy?

    *Main&gt; :info ins
    ins :: t -&gt; [t] -&gt; [[t]]        -- Defined at b.hs:1:0-2

I don&#39;t see nothing special - &quot;ins&quot; is a function that takes a &#39;t&#39;, 
a list of &#39;t&#39;, and proceeds to create a list with all &quot;interspersals&quot;. Nothing about &quot;eat your first argument and curry it away&quot;.

So there... I am baffled. I understand (after an hour of looking at the code!) what goes on, but... God almighty... Perhaps GHC makes attempts to see how many arguments it can &quot;peel off&quot;?

      let&#39;s try with no argument &quot;curried&quot; into &quot;ins&quot;,
      oh gosh, boom, 
      let&#39;s try with one argument &quot;curried&quot; into &quot;ins&quot;,
      yep, works,
      that must be it, proceed)

Again - yikes...

And since I am always comparing the languages I am learning with what I already know, how would &quot;ins&quot; look in Python? 

    a=[2,3]
    print [a[:x]+[1]+a[x:] for x in xrange(len(a)+1)]

    [[1, 2, 3], [2, 1, 3], [2, 3, 1]]

Be honest, now... which is simpler?

I mean, I know I am a newbie in Haskell, but I feel like an idiot... Looking at 4 lines of code for an hour, and ending up assuming that the compiler... tries various interpretations until it finds something that &quot;clicks&quot;?

To quote from Lethal weapon, &quot;I am too old for this&quot;...

All Currying Solutions on Gang of Coders

Total of 15 Currying Solutions