currying

I have the following Scala class: class Person(var name : String, var age : Int, var email : String) I would like to use the Person constructor as a curried function: def mkPerson = (n : String) => (a : Int) => (e : String) => new Person(n,a,e) This works, but is there another way to accomplish this? This approach seems a bit tedious and error-prone. I could imagine something like Function.curried, but then for constructors. This will work: def mkPerson = (new Person(_, _, _)).curried A bit late to this party, but if you make Person a case class: scala> case class Person(name: String, age: Int

Say you have the following: foo(x: String)(y: Int): Int foo(x: String)(y: Double): Int Scala does not allow such expression. As far as I can see, the reason for this is that foo("asdf") does not have a well defined type (it's either Int => Int or Double => Int). Is there a reason why such "polytyped" functions should not be allowed? Overloading resolution in Scala takes only the first parameter list into account. That's why alternatives must differ already in this list. There's a good reason for this: We can then use the resolved function's type to infer the type of subsequent arguments. This

I'm doing some excersises where I have to add a function's type and explain what it does. I'm stuck with this: phy = uncurry ($) The type, according to GHCi is phy :: (a -> b, a) -> b . My haskell knowledge is basic so I really have no idea what it does. Let's spell out the type part systematically. We'll start with the types of uncurry and ($) : uncurry :: (a -> b -> c) -> (a, b) -> c ($) :: (a -> b) -> a -> b Since the target expression has ($) as the argument of uncurry , let's line up their types to reflect this: uncurry :: (a -> b -> c) -> (a, b) -> c ($) :: (a -> b) -> a -> b The whole

In my Haskell program, I want to use printf to format a list of tuples. I can map printf over a list to print out the values one at a time like this: mapM_ (printf "Value: %d\n") [1,2,3,4] Value: 1 Value: 2 Value: 3 Value: 4 I want to be able to do something like this: mapM_ (printf "Values: %d %d\n") [(1,100),(2,350),(3,600),(4,200)] Values: 1 100 Values: 2 350 Values: 3 600 Values: 4 200 But this passes a tuple to printf, not two separate values. How can I turn the tuple into two arguments for printf? Function uncurry converts a two-argument (curried) function into a function on pairs. Here

There are tons of tutorials on how to curry functions, and as many questions here at stackoverflow. However, after reading The Little Schemer, several books, tutorials, blog posts, and stackoverflow threads I still don't know the answer to the simple question: "What's the point of currying?" I do understand how to curry a function, just not the "why?" behind it. Could someone please explain to me the practical uses of curried functions (outside of languages that only allow one argument per function, where the necessity of using currying is of course quite evident.) edit: Taking into account

I have read several Java 8 tutorials before. Right now I encountered following topic: Does java support Currying? Here, I see following code: IntFunction<IntUnaryOperator> curriedAdd = a -> b -> 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 -> b -> 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. If you express this as non-shorthand lambda syntax or pre-lambda Java

Say I have a function called multiplyDivide If I were to call multiplyDivide(2)(3)(4)(6) it would be equivalent to 2 * 3 / 4 * 6 . Update: Is it possible to write a function like this if I don't know in advance how many parameters I will be taking? For example, I could have multiplyDivide(1)(2) or multiplyDivide(1)(2)(3)(4)...(n-1)(n) Why does it have to be curried? Wouldn't this be much easier to just "overload" a function by supplying n arguments? function multiplyDivide() { var result = arguments[0]; for (var i = 1; i < arguments.length; i++) { result = (i % 2) ? (result * arguments[i]) :