currying

I want to make a function that return a curry function like below func addTwoNumbers(a: Int)(b: Int) -> Int { return a + b } addTwoNumbers(4)(b: 6) // Result: 10 var add4 = addTwoNumbers(4) add4(b: 10) // returns 14 What is the return type of such function and how can I generate a function like this using a function that take Variadic parameters. func generateCurry(.../*Variadic parameters*/) -> .../*curry function type*/ { return ...//curry function } I want a generic solution and not take only Int as arguments in the parmeter of the generateCurry function let curried = curry(func(a, b, c) {

Is it possible to do a foldLeft on a list of arguments, where the initial value supplied to the fold is a fully curried function, the operator is apply , and the list is a list of arguments to be passed to function f ? For example, let's say f is defined as: scala> val f = (i: Int, j: Int, k: Int, l: Int) => i+j+k+l f: (Int, Int, Int, Int) => Int = <function4> Which we can of course use directly: scala> f(1, 2, 3, 4) res1: Int = 10 Or curry and apply the arguments one at a time: scala> f.curried res2: Int => Int => Int => Int => Int = <function1> scala> f.curried.apply(1).apply(2).apply(3)

This question already has an answer here: What's the difference between multiple parameters lists and multiple parameters per list in Scala? 4 answers 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