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' ]

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

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.

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

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!

Attack of the general uncurrying function

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!