Existe alguma biblioteca de matriz de JavaScript que normaliza os valores de retorno da matriz e mutações? Eu acho que a JavaScript Array API é muito inconsistente.

Alguns métodos alteram o array:

var A = [0,1,2];
A.splice(0,1); // reduces A and returns a new array containing the deleted elements

Alguns não

A.slice(0,1); // leaves A untouched and returns a new array

Alguns retornam uma referência para o array mutado:

A = A.reverse().reverse(); // reverses and then reverses back

Alguns apenas retornam indefinidos:

B = A.forEach(function(){});

O que eu gostaria é sempre alterar o array e sempre retornar o mesmo array, para que eu possa ter algum tipo de consistência e também ser capaz de encadear. Por exemplo:

A.slice(0,1).reverse().forEach(function(){}).concat(['a','b']);

Eu tentei alguns trechos simples como:

var superArray = function() {
    this.length = 0;
}

superArray.prototype = {
    constructor: superArray,

    // custom mass-push method
    add: function(arr) {
        return this.push.apply(this, arr);
    }
}

// native mutations
'join pop push reverse shift sort splice unshift map forEach'.split(' ').forEach(function(name) {
    superArray.prototype[name] = (function(name) {
        return function() {
            Array.prototype[name].apply(this, arguments);
            // always return this for chaining
            return this;
        };
    }(name));
});

// try it
var a = new superArray();
a.push(3).push(4).reverse();

Isso funciona bem para a maioria dos métodos de mutação, mas existem problemas. Por exemplo, eu preciso escrever protótipos personalizados para cada método que não sofra mutação do array original.

Então, como sempre enquanto eu estava fazendo isso, eu estava pensando que talvez isso tenha sido feito antes? Existe alguma biblioteca de matriz leve que já faz isso? Seria bom se a biblioteca também adicionasse shims para novos métodos do JavaScript 1.6 para navegadores mais antigos.