What is Currying

Question

I ve seen references to curried functions in several articles and blogs but I can t find a good explanation  or at least one that makes sense

User · Answer

Currying is one of the higher-order functions of Java Script.

Currying is a function of many arguments which is rewritten such that it takes the first argument and return a function which in turns uses the remaining arguments and returns the value.

Confused?

Let see an example,

function add(a,b)
    {
        return a+b;
    }
add(5,6);

This is similar to the following currying function,

function add(a)
    {
        return function(b){
            return a+b;
        }
    }
var curryAdd = add(5);
curryAdd(6);

So what does this code means?

Now read the definition again,

Currying is a function of many arguments which is rewritten such that it takes first argument and return a function which in turns uses the remaining arguments and returns the value.

Still, Confused? Let me explain in deep!

When you call this function,

var curryAdd = add(5);

It will return you a function like this,

curryAdd=function(y){return 5+y;}

So, this is called higher-order functions. Meaning, Invoking one function in turns returns another function is an exact definition for higher-order function. This is the greatest advantage for the legend, Java Script. So come back to the currying,

This line will pass the second argument to the curryAdd function.

curryAdd(6);

which in turns results,

curryAdd=function(6){return 5+6;}
// Which results in 11

Hope you understand the usage of currying here. So, Coming to the advantages,

Why Currying?

It makes use of code reusability. Less code, Less Error. You may ask how it is less code?

I can prove it with ECMA script 6 new feature arrow functions.

Yes! ECMA 6, provide us with the wonderful feature called arrow functions,

function add(a)
    {
        return function(b){
            return a+b;
        }
    }

With the help of the arrow function, we can write the above function as follows,

x=>y=>x+y

Cool right?

So, Less Code and Fewer bugs!!

With the help of these higher-order function one can easily develop a bug-free code.

I challenge you!

Hope, you understood what is currying. Please feel free to comment over here if you need any clarifications.

Thanks, Have a nice day!

User · Answer

If you understand partial you re halfway there   The idea of partial is to preapply arguments to a function and give back a new function that wants only the remaining arguments   When this new function is called it includes the preloaded arguments along with whatever arguments were supplied to it   In Clojure   is a function but to make things starkly clear    defn add  a b     a b     You may be aware that the inc function simply adds 1 to whatever number it s passed    inc 7      gt  8   Let s build it ourselves using partial    def inc  partial add 1     Here we return another function that has 1 loaded into the first argument of add   As add takes two arguments the new inc function wants only the b argument -- not 2 arguments as before since 1 has already been partially applied   Thus partial is a tool from which to create new functions with default values presupplied   That is why in a functional language functions often order arguments from general to specific   This makes it easier to reuse such functions from which to construct other functions   Now imagine if the language were smart enough to understand introspectively that add wanted two arguments   When we passed it one argument  rather than balking  what if the function partially applied the argument we passed it on our behalf understanding that we probably meant to provide the other argument later   We could then define inc without explicitly using partial    def inc  add 1    partial is implied   This is the way some languages behave   It is exceptionally useful when one wishes to compose functions into larger transformations   This would lead one to transducers

User · Answer

An example of currying would be when having functions you only know one of the parameters at the moment   For example   func aFunction str  String        let callback   callback str     signature now is  NSData - gt          performAsyncRequest callback     func callback str  String  data  NSData           Callback code    func performAsyncRequest callback  NSData - gt               Async code that will call callback with NSData as parameter     Here  since you don t know the second parameter for callback when sending it to performAsyncRequest     you would have to create another lambda   closure to send that one to the function

User · Answer

Here s a toy example in Python      gt  gt  gt  from functools import partial as curry   gt  gt  gt    Original function taking three parameters   gt  gt  gt  def display quote who  subject  quote           print who   said regarding   subject               print       quote          gt  gt  gt  display quote  hoohoo    functional languages               I like Erlang  not sure yet about Haskell    hoohoo said regarding functional languages   I like Erlang  not sure yet about Haskell     gt  gt  gt    Let s curry the function to get another that always quotes Alex     gt  gt  gt  am quote   curry display quote   Alex Martelli     gt  gt  gt  am quote  currying    As usual  wikipedia has a nice summary      Alex Martelli said regarding currying   As usual  wikipedia has a nice summary        Just using concatenation via   to avoid distraction for non-Python programmers    Editing to add   See http   docs python org library functools html highlight partial functools partial  which also shows the partial object vs  function distinction in the way Python implements this

User · Answer

Curry can simplify your code  This is one of the main reasons to use this  Currying is a process of converting a function that accepts n arguments into n functions that accept only one argument   The principle is to pass the arguments of the passed function  using the closure  closure  property  to store them in another function and treat it as a return value  and these functions form a chain  and the final arguments are passed in to complete the operation   The benefit of this is that it can simplify the processing of parameters by dealing with one parameter at a time  which can also improve the flexibility and readability of the program  This also makes the program more manageable  Also dividing the code into smaller pieces would make it reuse-friendly    For example   function curryMinus x       return function y           return x - y         var minus5   curryMinus 1   minus5 3   minus5 5     I can also do     var minus7   curryMinus 7   minus7 3   minus7 5     This is very great for making complex code neat and handling of unsynchronized methods etc

User · Answer

Currying is translating a function from callable as f a  b  c  into callable as f a  b  c     Otherwise currying is when you break down a function that takes multiple arguments into a series of functions that take part of the arguments   Literally  currying is a transformation of functions  from one way of calling into another  In JavaScript  we usually make a wrapper to keep the original function   Currying doesn   t call a function  It just transforms it   Let   s make curry function that performs currying for two-argument functions  In other words  curry f  for two-argument f a  b  translates it into f a  b   function curry f       curry f  does the currying transform   return function a        return function b          return f a  b                     usage function sum a  b      return a   b     let carriedSum   curry sum    alert  carriedSum 1  2        3   As you can see  the implementation is a series of wrappers    The result of curry func  is a wrapper function a   When it is called like sum 1   the argument is saved in the Lexical Environment  and a new wrapper is returned function b   Then sum 1  2  finally calls function b  providing 2  and it passes the call to the original multi-argument sum

User · Answer

I found this article  and the article it references  useful  to better understand currying  http   blogs msdn com wesdyer archive 2007 01 29 currying-and-partial-function-application aspx  As the others mentioned  it is just a way to have a one parameter function   This is useful in that you don t have to assume how many parameters will be passed in  so you don t need a 2 parameter  3 parameter and 4 parameter functions

User · Answer

As all other answers currying helps to create partially applied functions  Javascript does not provide native support for automatic currying  So the examples provided above may not help in practical coding  There is some excellent example in livescript  Which essentially compiles to js  http   livescript net   times    x  y  -- gt  x   y times 2  3          gt  6  normal use works as expected  double   times 2 double 5            gt  10   In above example when you have given less no of arguments livescript generates new curried function for you  double

User · Answer

It can be a way to use functions to make other functions    In javascript     let add   function x     return function y       return x   y           Would allow us to call it like so   let addTen   add 10     When this runs the 10 is passed in as x   let add   function 10     return function y       return 10   y            which means we are returned this function   function y    return 10   y      So when you call   addTen      you are really calling    function y    return 10   y      So if you do this    addTen 4    it s the same as   function 4    return 10   4     14   So our addTen   always adds ten to whatever we pass in  We can make similar functions in the same way   let addTwo   add 2           addTwo    will add two to whatever you pass in let addSeventy   add 70          and so on      Now the obvious follow up question is why on earth would you ever want to do that  It turns what was an eager operation x   y into one that can be stepped through lazily  meaning we can do at least two things   1  cache expensive operations  2  achieve abstractions in the functional paradigm   Imagine our curried function looked like this   let doTheHardStuff   function x      let z   doSomethingComputationallyExpensive x    return function  y       z   y         We could call this function once  then pass around the result to be used in lots of places  meaning we only do the computationally expensive stuff once   let finishTheJob   doTheHardStuff 10  finishTheJob 20  finishTheJob 30    We can get abstractions in a similar way

User · Answer

Here is the example of generic and the shortest version for function currying with n no  of params   const add   a   gt  b   gt  b   add a   b    a      x000D   x000D  const add   a   gt  b   gt  b   add a   b    a   x000D  console log add 1  2  3  4      x000D   x000D   x000D

User · Answer

There is an example of  Currying in ReasonML     let run        gt        Js log  Curryed function          let sum    x  y    gt  x   y      Printf printf  sum 2  3     d n   sum 2  3        let per2   sum 2       Printf printf  per2 3     d n   per2 3

User · Answer

Here s a concrete example   Suppose you have a function that calculates the gravitational force acting on an object  If you don t know the formula  you can find it here  This function takes in the three necessary parameters as arguments   Now  being on the earth  you only want to calculate forces for objects on this planet  In a functional language  you could pass in the mass of the earth to the function and then partially evaluate it  What you d get back is another function that takes only two arguments and calculates the gravitational force of objects on earth  This is called currying

User · Answer

The  quot currying quot  is the process of taking the function of multiple arguments and converting it into a serious of functions that each take a single argument and return a function of a single argument  or in the case of the final function  return the actual result

User · Answer

Currying is when you break down a function that takes multiple arguments into a series of functions that each take only one argument  Here s an example in JavaScript     function add  a  b      return a   b     add 3  4      returns 7   This is a function that takes two arguments  a and b  and returns their sum  We will now curry this function   function add  a      return function  b        return a   b          This is a function that takes one argument  a  and returns a function that takes another argument  b  and that function returns their sum   add 3  4    var add3   add 3    add3 4     The first statement returns 7  like the add 3  4  statement  The second statement defines a new function called add3 that will add 3 to its argument  This is what some people may call a closure  The third statement uses the add3 operation to add 3 to 4  again producing 7 as a result

User · Answer

Currying is a transformation that can be applied to functions to allow them to take one less argument than previously   For example  in F  you can define a function thus -    let f x y z   x   y   z   Here function f takes parameters x  y and z and sums them together so -  f 1 2 3   Returns 6   From our definition we can can therefore define the curry function for f -  let curry f   fun x - gt  f x   Where  fun x -  f x  is a lambda function equivilent to x    f x  in C   This function inputs the function you wish to curry and returns a function which takes a single argument and returns the specified function with the first argument set to the input argument   Using our previous example we can obtain a curry of f thus -  let curryf   curry f   We can then do the following -  let f1   curryf 1   Which provides us with a function f1 which is equivilent to f1 y z   1   y   z  This means we can do the following -  f1 2 3   Which returns 6   This process is often confused with  partial function application  which can be defined thus -  let papply f x   f x   Though we can extend it to more than one parameter  i e  -  let papply2 f x y   f x y let papply3 f x y z   f x y z etc    A partial application will take the function and parameter s  and return a function that requires one or more less parameters  and as the previous two examples show is implemented directly in the standard F  function definition so we could achieve the previous result thus -  let f1   f 1 f1 2 3   Which will return a result of 6   In conclusion -  The difference between currying and partial function application is that -  Currying takes a function and provides a new function accepting a single argument  and returning the specified function with its first argument set to that argument  This allows us to represent functions with multiple parameters  as a series of single argument functions  Example -  let f x y z   x   y   z let curryf   curry f let f1   curryf 1 let f2   curryf 2 f1 2 3 6 f2 1 3 6   Partial function application is more direct - it takes a function and one or more arguments and returns a function with the first n arguments set to the n arguments specified  Example -  let f x y z   x   y   z let f1   f 1 let f2   f 2 f1 2 3 6 f2 1 3 6

User · Answer

A curried function is a function of several arguments rewritten such that it accepts the first argument and returns a function that accepts the second argument and so on  This allows functions of several arguments to have some of their initial arguments partially applied

User · Answer

In an algebra of functions  dealing with functions that take multiple arguments  or equivalent one argument that s an N-tuple  is somewhat inelegant -- but  as Moses Sch  nfinkel  and  independently  Haskell Curry  proved  it s not needed  all you need are functions that take one argument   So how do you deal with something you d naturally express as  say  f x y    Well  you take that as equivalent to f x  y  -- f x   call it g  is a function  and you apply that function to y   In other words  you only have functions that take one argument -- but some of those functions return other functions  which ALSO take one argument -    As usual  wikipedia has a nice summary entry about this  with many useful pointers  probably including ones regarding your favorite languages -  as well as slightly more rigorous mathematical treatment

User · Answer

A curried function is applied to multiple argument lists  instead of just one    Here is a regular  non-curried function  which adds two Int parameters  x and y   scala gt  def plainOldSum x  Int  y  Int    x   y plainOldSum   x  Int y  Int Int scala gt  plainOldSum 1  2  res4  Int   3   Here is similar function that   s curried  Instead of one list of two Int parameters  you apply this function to two lists of one Int parameter each   scala gt  def curriedSum x  Int  y  Int    x   y curriedSum   x  Int  y  Int Intscala gt  second 2  res6  Int   3 scala gt  curriedSum 1  2  res5  Int   3   What   s happening here is that when you invoke curriedSum  you actually get two traditional function invocations back to back  The first function invocation takes a single Int parameter named x   and returns a function value for the second function  This second function takes the Int parameter y    Here   s a function named first that does in spirit what the first traditional function invocation of curriedSum would do   scala gt  def first x  Int     y  Int    gt  x   y first   x  Int  Int    gt  Int   Applying 1 to the first function   in other words  invoking the first function and passing in 1    yields the second function   scala gt  val second   first 1  second   Int    gt  Int    lt function1 gt    Applying 2 to the second function yields the result   scala gt  second 2  res6  Int   3

User · Answer

Here you can find a simple explanation of currying implementation in C   In the comments  I have tried to show how currying can be useful   public static class FuncExtensions       public static Func lt T1  Func lt T2  TResult gt  gt  Curry lt T1  T2  TResult gt  this Func lt T1  T2  TResult gt  func                return x1   gt  x2   gt  func x1  x2              Usage var add   new Func lt int  int  int gt   x  y    gt  x   y  Curry    var func   add 1      Obtaining the next parameter here  calling later the func with next parameter    Or you can prepare some base calculations at the previous step and then   use the result of those calculations when calling the func multiple times    with different input parameters   int result   func 1

[functional-programming] What is 'Currying'?

Examples related to functional-programming

Examples related to terminology

Examples related to definition

Examples related to currying