currying

I recently started coding in Python and I was wondering if it's possible to return a function that specializes another function. For example, in Haskell you can create a function that adds 5 to any given number like this: sumFive = (+5) Is it somehow possible in Python? I think the other answers are misunderstanding the question. I believe the OP is asking about partial application of a function, in his example the function is (+) . If the goal isn't partial application, the solution is as simple as: def sumFive(x): return x + 5 For partial application in Python, we can use this function:

Consider the following function: addAmount <- function(x, amount) { stopifnot(length(x) == 1) return(x + amount) } It can be used to add some amount to x : > addAmount(x = 5, amount = 3) [1] 8 > addAmount(x = 2, amount = 3) [1] 5 However, x must be of length 1: > addAmount(x = 7:9, amount = 3) Error: length(x) == 1 is not TRUE I added this restriction intentionally for exemplification. Using Vectorize , it is possible to pass in a vector for x : > Vectorize(addAmount)(x = 7:9, amount = 3) [1] 10 11 12 So far, so good. However, I'd like to turn my addAmount function into a "add 3" function,

Concerning currying in Ruby 1.9.x, I've been using it in some places, and can be translated like basically supporting default parameters to the proc arguments: p = proc {|x, y, z|x + y + z} p.curry[1] #=> returns a lambda p.curry[1, 2] #=> returns a lambda p.curry[1, 2, 3] #=> 6 p2 = p.curry[1, 2] p2.(2) #=> 5 p2.(4) #=> 7 very handy, right? thing is, I would like to be able to curry in reverse, that means, fill the last argument of my proc with a random value. Like this: p = proc{|x, y| x - y }.curry[1] p.(4) my desired result would be 3. this returns -3. i think there's no direct way of

I am trying to use currying to make a simple functional add in Python. I found this curry decorator here . def curry(func): def curried(*args, **kwargs): if len(args) + len(kwargs) >= func.__code__.co_argcount: return func(*args, **kwargs) return (lambda *args2, **kwargs2: curried(*(args + args2), **dict(kwargs, **kwargs2))) return curried @curry def foo(a, b, c): return a + b + c Now this is great because I can do some simple currying: >>> foo(1)(2, 3) 6 >>> foo(1)(2)(3) 6 But this only works for exactly three variables. How do I write the function foo so that it can accept any number of

I've always thought that F# had two different ways to pass arguments, curry style and tuple style. Is this actually correct? Isn't it simply one style , curry style, and arguments can either be simple values or tuples. e.g. someFunc (a,b) = isn't this a function with one curry style argument which happens to be a tuple ? Thus allowing me to pass tuples to this function using the pipleline operator? (where the elements of the tuple is named) (1,2) |> someFunc Is this correct? This will work just fine - the difference is when you have let f (a,b) = ... let f2 a b = ... then you can create a