Anti-currying in JS

Anti-currying

On the contrary, the role of anti-currying is to expand the applicability of the function, so that the function originally used as a function owned by a specific object can be used by any object The used .
is to convert the function signature given below,

obj.func(arg1, arg2)

into a function form with the following signature:

func(obj, arg1, arg2)

This is the formal description of anti-currying.

For example, a simple implementation of the following:

Function.prototype.uncurrying = function() {    var that = this;    return function() {        return Function.prototype.call.apply(that, arguments);
    }
};function sayHi () {    return "Hello " + this.value +" "+[].slice.call(arguments);
}var sayHiuncurrying=sayHi.uncurrying();
console.log(sayHiuncurrying({value:'world'},"hahaha"));

Explanation:

• uncurrying is a method defined on the prototype of Function, so this method can be used for all functions. When calling: sayHiuncurrying=sayHi.uncurrying(), so this in uncurrying points to the sayHi function; (Generally, this in the prototype method does not point to the prototype object prototype, but to the calling object, where the calling object is another function. In javascript functions are also objects)

• call.apply(that, arguments) Set that as the context of the call method, and then pass the arguments to the call method, In the previous example, that actually points to sayHi, so calling sayHiuncurrying(arg1, arg2, ...) is equivalent to sayHi.call(arg1, arg2, ...);

• sayHi. call (arg1, arg2, ...), the call function treats arg1 as the context of sayHi, and then passes the remaining parameters such as arg2,... to sayHi, so the final equivalent is arg1.sayHi(arg2,...) ;

• So, this is equivalent to sayHiuncurrying(obj,args) equals obj.sayHi(args).

Finally, let’s look at it from the other side. In fact, anti-currying is equivalent to converting the original form of sayHi(args) into sayHiuncurrying(obj,args), making the scope of use of sayHi Generalized. Expressed more abstractly, uncurrying anti-currying allows the original x.y(z) call to be converted into a call in the form of y(x',z). Assuming x' is x or other objects, this expands the scope of use of the function.

Universal decurrying function

In the above example, uncurrying is written into the prototype, which is not good. We can actually encapsulate uncurrying into a separate function;

var uncurrying= function (fn) {    return function () {        var args=[].slice.call(arguments,1);        return fn.apply(arguments[0],args);        
    }    
};

The above function is very clear and straightforward.
When used, call uncurrying and pass in an existing function fn. The decurrying function will return a new function. The first actual parameter accepted by the new function will be bound to the context of this in fn, and the other parameters will Passed to fn as argument.

So, a more popular explanation for anti-currying can be the borrowing of functions, which means that functions can accept and process other objects, and generalization through borrowing expands the scope of use of functions.

So the more common usage of uncurrying is to borrow other methods built into Javascript without having to implement them all yourself.

The text description is a bit confusing, so let’s continue looking at the code:

var test="a,b,c";
console.log(test.split(","));var split=uncurrying(String.prototype.split);   //[ 'a', 'b', 'c' ]console.log(split(test,','));                   //[ 'a', 'b', 'c' ]

##split=uncurrying(String.prototype.split ) Pass in a specific fn to uncurrying, that is, String.prototype.split. The split function has the function of String.prototype.split. When the function calls split(test,','), the first parameter passed in is The context of split execution, and the remaining parameters are equivalent to passing to the original String.prototype.split function.

Look at another example:

var $ = {};
console.log($.push);                          // undefinedvar pushUncurrying = uncurrying(Array.prototype.push);
$.push = function (obj) {
    pushUncurrying(this,obj);
};
$.push('first');
console.log($.length);                        // 1console.log($[0]);                            // firstconsole.log($.hasOwnProperty('length'));      // true

Here imitates a "similar

jquery library "The implementation borrows the push method of Array. We know that the object does not have a push method, so console.log(obj.push) returns undefined. You can use Array to handle push, and the native array method (js engine) maintains the length of the pseudo-array object Attribute and array members.

For the same reason, we can continue to have:

var indexof=uncurrying(Array.prototype.indexOf);
$.indexOf = function (obj) {    return indexof(this,obj);
};
$.push("second");
console.log($.indexOf('first'));              // 0console.log($.indexOf('second'));             // 1console.log($.indexOf('third'));              // -1

For example, when we implement our own class library , if some methods are similar to native ones, you can borrow native methods through uncurrying.

We can also uncurring the Function.prototype.call/apply method, for example:

var call= uncurrying(Function.prototype.call);var fn= function (str) {
    console.log(this.value+str);
};var obj={value:"Foo "};
call(fn, obj,"Bar!");                       // Foo Bar!

This can be very useful Flexibly using functions as ordinary "data" has the advantages of functional programming. This usage can often be seen in some class libraries.

Attack of the general uncurrying function

The uncurrying function above is a version that is more in line with thinking habits and easy to understand. Next, we will attack all the way and look at several other versions:

First, If the B cell is higher, uncurrying may also be written like this:

var uncurrying= function (fn) {    return function () {        var context=[].shift.call(arguments);        return fn.apply(context,arguments);
    }
};

Of course, if you still need to improve the B cell, then it can also be Like this:

var uncurrying= function (fn) {    return function () {        
        return Function.prototype.call.apply(fn,arguments);
    }
};

The above is the detailed content of Anti-currying in JS. For more information, please follow other related articles on the PHP Chinese website!