The concept of currying is that instead of accepting multiple arguments, a function accepts only one, and returns a function which acepts the remaining arguments. The returned function will also accept only one argument, and returns another function. This process continues until all arguments are exhausted and we are left only with a single return value.<\/p>\n
For example, usually we define a function that returns the sum of two integers as follows:<\/p>\n
func<\/code> add1(x: <\/code>Int<\/code>, y: <\/code>Int<\/code>) -> <\/code>Int<\/code> {<\/code><\/div> <\/code>return<\/code> x + y<\/code><\/div>}<\/code><\/div>add1(1, 2) <\/code>\/\/ Output: 3<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\nWe can always transform a function taking multiple arguments into a curried one, by separating the function into a series of function that each takes only one argument. The curried version of add1 is as follows:<\/p>\n
func<\/code> add2(x: <\/code>Int<\/code>) -> (<\/code>Int<\/code> -> <\/code>Int<\/code>) {<\/code><\/div> <\/code>return<\/code> { y <\/code>in<\/code> return<\/code> x + y }<\/code><\/div>}<\/code><\/div>add2(1)(2) <\/code>\/\/ Output: 3<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\nThis function has this type specified: Int -> Int -> Int<\/code>. This may seem a little strange to newcomers to functional programming. Which part is the argument, and which part is the return type?<\/p>\nHere, add2 is taking an Int<\/code>, and returning a Function which takes another Int<\/code>, which in turn returns a third Int<\/code>. You could say it’s something like this: Int -> (Int -> Int)<\/code>, or we could use typealias to make (Int -> Int)<\/code> more clear:<\/p>\ntypealias<\/code> IntTransformer<\/code> = (<\/code>Int<\/code> -> <\/code>Int<\/code>)<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\nNow, any time we see IntTransformer<\/code>, it’s easier to comprehend that it’s a function that transforms an Int value. With that, we could redfine add2 like this:<\/p>\nfunc<\/code> add2Aliased(x: <\/code>Int<\/code>) -> <\/code>IntTransformer<\/code> {<\/code><\/div>...<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\nThis probably looks a little more familiar, but under the hood this is exactly the same as the add2 function we defined with the data type Int -> Int -> Int<\/code>. This is just a more familiar looking way to write it.<\/p>\nCalling add2() with just a single argument returns a function that takes another (Int -> Int)<\/code> function, which means we can store that<\/em> function in a separate variable if we so choose:<\/p>\nlet<\/code> addTwentyTransformer = add2(20)<\/code><\/div>addTwentyTransformer(5) <\/code>\/\/ Output: 25<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\nNow, add2(20)<\/code> is a function that takes one integer and returns the value of that integer plus 20.<\/p>\nThe -> operator is defined as associativity right. Instead of writing A -> (B -> (C -> D))<\/code>, we can simply write A -> B -> C -> D<\/code>.<\/p>\nSwift also supports another way to define a curried function:<\/p>\n
func<\/code> add3(x: <\/code>Int<\/code>)(y: <\/code>Int<\/code>) -> <\/code>Int<\/code> {<\/code><\/div> <\/code>return<\/code> x + y<\/code><\/div>}<\/code><\/div>add3(1)(y: 2) <\/code>\/\/ Output: 3<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\nThis is helpful if you want named parameters, which can sometimes help your code easier to read. It’s also easy to make the syntax the same as add2<\/code> and remove the explicit argument name.<\/p>\nfunc<\/code> add4(x: <\/code>Int<\/code>)(_ y: <\/code>Int<\/code>) -> <\/code>Int<\/code> {<\/code><\/div> <\/code>return<\/code> x + y<\/code><\/div>}<\/code><\/div>add4(1)(2) <\/code>\/\/ Output: 3<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\nBenefits of Currying<\/h2>\n
What are the benefits currying provides? Let’s look at the add functions above.<\/p>\n
With add1<\/code> the regular function, we cannot apply this function until both of its arguments are ready. With the curried add2<\/code>, we can apply one or two arguments.<\/p>\nLet’s see an example that uses add1<\/code> and add2<\/code> with map<\/code>to transform an array of integers by adding 7 to each.<\/p>\n\/\/ Apply map to the array using the two functions<\/code><\/div>let<\/code> xs = [1, 2, 3]<\/code><\/div>let<\/code> addSeven1 = { add1($0, 7) }<\/code><\/div>map<\/code>(xs, addSeven1) <\/code>\/\/ Output: [8, 9, 10]<\/code><\/div>let<\/code> addSeven2 = add2(7)<\/code><\/div>map<\/code>(xs, addSeven2) <\/code>\/\/ Output: [8, 9, 10]<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\nThe curried function add2<\/code> is much cleaner in this case.<\/p>\nThere is another case when curried functions have obvious advantages. To demonstrate the example, first we define a function (a custom operator) that composes two functions together:<\/p>\n
\/\/ Define a new operator |> that has left associativity<\/code><\/div>infix<\/code> operator<\/code> |> { associativity left }<\/code><\/div>func<\/code> |> <A, B, C>(f: B -> C, g: A -> B) -> A -> C {<\/code><\/div> <\/code>return<\/code> { x <\/code>in<\/code><\/div> <\/code>f(g(x))<\/code><\/div> <\/code>}<\/code><\/div>}<\/code><\/div><\/div><\/td><\/tr><\/tbody><\/table><\/div><\/code><\/pre>\nLet’s say we want to transform an array of integers by adding 7 to each element, and then adding 3 again. We could write:<\/p>\n
let<\/code> xs = [1, 2, 3]<\/code><\/div> <\/div>