currying

问题 The syntax of currying in scala is for example def f(x: Int, b: Int) = x + y is def f(x: Int)(b: Int) = x + y And currying for sum to sum for given range a and b is def sum(f: Int => Int, a: Int, b: Int) = { ... } sum(x=>x, 3, 6) // outcome is 18 (3+4+5+6) is def sum(f: Int => Int): (Int, Int) => Int = { def sumF(a: Int, b: Int): Int = if (a > b) 0 else f(a) + sumF(a + 1, b) sumF } sum(x=>x)(3, 6) // outcome is 18 (3+4+5+6) But I don't understand why colon(:) exists between (f: Int => Int)

问题 I'm having trouble figuring out a way to curry a function a specified number of times. That is, I give the function a natural number n and a function fun, and it curries the function n times. For example: (curry n fun) Is the function and a possible application would be: (((((curry 4 +) 1) 2) 3) 4) Which would produce 10. I'm really not sure how to implement it properly. Could someone please give me a hand? Thanks :) 回答1: You can write your own n-curry procedure by repeatedly calling curry :

问题 For example, suppose we had the functions double(x) = 2 * x , square(x) = x ^ 2 and sum(x,y) = x + y . What is a function compose such as compose(compose(sum, square), double) = x^2 + 2*x ? Notice that I'm asking a function that can be used for functions of any arity. For example, you could compose f(x,y,z) with g(x) , h(x) , i(x) into f(g(x), h(x), i(x)) . 回答1: This is a common Haskell idiom, applicative functors: composed = f <$> g1 <*> g2 <*> ... <*> gn (A nicer introduction can be found

问题 We do some dynamic creation of parallel steps in some of our jobs. Thanks to this thread I found how to dynamically create the map with parameters for use in the parallel step. However now I wanted to reuse parts of the code which is used to create those parallel steps. For this I feel that I would need to curry the closures. However currying seems not to work correctly. Referencing the loop variable (valueCopy) inside the closure does the right thing (as mentioned here) but currying does not

问题 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

问题 I'm very new to Haskell and FP in general. I've read many of the writings that describe what currying is, but I haven't found an explanation to how it actually works. Here is a function: (+) :: a -> (a -> a) If I do (+) 4 7 , the function takes 4 and returns a function that takes 7 and returns 11 . But what happens to 4 ? What does that first function do with 4 ? What does (a -> a) do with 7 ? Things get more confusing when I think about a more complicated function: max' :: Int -> (Int -> Int

问题 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

问题 I was wondering if there is any way to pull that in Java. I think it is not possible without native support for closures. 回答1: Java 8 (released March 18th 2014) does support currying. The example Java code posted in the answer by missingfaktor can be rewritten as: import java.util.function.*; import static java.lang.System.out; // Tested with JDK 1.8.0-ea-b75 public class CurryingAndPartialFunctionApplication { public static void main(String[] args) { IntBinaryOperator simpleAdd = (a, b) -> a

问题 I try to understand the function currying tutorial but that code seem out of date. And it's still not really clear about function currying. I try with this function: func curry<A, B, C>(_ f: @escaping (A, B) -> C) -> (A) -> (B) -> C { return { a in { b in f(a, b)} } } And it runs ok with Playground (Xcode 9 beta 6) . But the problem is I cannot use this function as the tutorial: let add = curry(+) let xs = 1...100 let x = xs.map(add(2)) The code above return error: Playground execution failed

问题 I don't think I quite understand currying, since I'm unable to see any massive benefit it could provide. Perhaps someone could enlighten me with an example demonstrating why it is so useful. Does it truly have benefits and applications, or is it just an over-appreciated concept? 回答1: (There is a slight difference between currying and partial application , although they're closely related; since they're often mixed together, I'll deal with both terms.) The place where I realized the benefits