Is currying just a way to avoid inheritance?

So my understanding of currying (based on SO questions) is that it lets you partially set parameters of a function and return a "truncated" function as a result.

If you have a big hairy function takes 10 parameters and looks like

function (location, type, gender, jumpShot%, SSN, vegetarian, salary) {
    //weird stuff
}

and you want a "subset" function that will let you deal with presets for all but the jumpShot%, shouldn't you just break out a class that inherits from the original function?

I suppose 开发者_运维知识库what I'm looking for is a use case for this pattern. Thanks!

Currying has many uses. From simply specifying default parameters for functions you use often to returning specialized functions that serve a specific purpose.

But let me give you this example:

function log_message(log_level, message){}
log_error = curry(log_message, ERROR)
log_warning = curry(log_message, WARNING)

log_message(WARNING, 'This would be a warning')
log_warning('This would also be a warning')

In javascript I do currying on callback functions (because they cannot be passed any parameters after they are called (from the caller)

So something like:

...
var test = "something specifically set in this function";
onSuccess: this.returnCallback.curry(test).bind(this),

// This will fail (because this would pass the var and possibly change it should the function be run elsewhere
onSuccess: this.returnCallback.bind(this,test),
...

// this has 2 params, but in the ajax callback, only the 'ajaxResponse' is passed, so I have to use curry
returnCallback: function(thePassedVar, ajaxResponse){
   // now in here i can have 'thePassedVar', if 
}

I'm not sure if that was detailed or coherent enough... but currying basically lets you 'prefill' the parameters and return a bare function call that already has data filled (instead of requiring you to fill that info at some other point)

When programming in a functional style, you often bind arguments to generate new functions (in this example, predicates) from old. Pseudo-code:

filter(bind_second(greater_than, 5), some_list)

might be equivalent to:

filter({x : x > 5}, some_list)

where {x : x > 5} is an anonymous function definition. That is, it constructs a list of all values from some_list which are greater than 5.

In many cases, the parameters to be omitted will not be known at compile time, but rather at run time. Further, there's no limit to the number of curried delegates that may exist for a given function. The following is adapted from a real-world program.

I have a system in which I send out command packets to a remote machine and receive back response packets. Every command packet has an index number, and each reply bears the index number of the command to which it is a response. A typical command, translated into English, might be "give me 128 bytes starting at address 0x12300". A typical response might be "Successful." along with 128 bytes of data.

To handle communication, I have a routine which accepts a number of command packets, each with a delegate. As each response is received, the corresponding delegate will be run on the received data. The delegate associated with the command above would be something like "Confirm that I got a 'success' with 128 bytes of data, and if so, store them into my buffer at address 0x12300". Note that multiple packets may be outstanding at any given time; the curried address parameter is necessary for the routine to know where the incoming data should go. Even if I wanted to write a "store data to buffer" routine which didn't require an address parameter, it would have no way of knowing where the incoming data should go.