Large integers in memorable recursive fibonacci (Y)

I wrote version Y that automatically caches old values ​​in a closure using memoization.

var Y = function (f, cache) {
    cache = cache || {};
    return function (x) {
        if (x in cache) return cache[x];
        var result = f(function (n) {
            return Y(f, cache)(n);
        })(x);
        return cache[x] = result;
    };
};

      

        
        
        
      

    

Now when almostFibonacci

(defined below) is passed into the above function, it returns a large Fibonacci number comfortably.

var almostFibonacci = function (f) {
    return function (n) {
        return n === '0' || n === '1' ? n : f(n - 1) + f(n - 2);
    };
};

      

        
        
        
      

    

However, after a certain value ( Number.MAX_SAFE_INTEGER

), integers in JavaScript (due to their IEEE-754 double precision format ) are inaccurate. So, given the fact that the only math operations in the Fibonacci function above are additions and subtractions, and since the operators cannot be overloaded in JavaScript, I wrote naive implementations of sum and difference functions (which use strings to support large integers) that are in the following.

String.prototype.reverse = function () {
    return this.split('').reverse().join('');
};

var difference = function (first, second) {
    first = first.reverse();
    second = second.reverse();
    var firstDigit,
    secondDigit,
    differenceDigits = [],
        differenceDigit,
        carry = 0,
        index = 0;
    while (index < first.length || index < second.length || carry !== 0) {
        firstDigit = index < first.length ? parseInt(first[index], 10) : 0;
        secondDigit = index < second.length ? parseInt(second[index], 10) : 0;
        differenceDigit = firstDigit - secondDigit - carry;
        differenceDigits.push((differenceDigit + (differenceDigit < 0 ? 10 : 0)).toString());
        carry = differenceDigit < 0 ? 1 : 0;
        index++;
    }
    differenceDigits.reverse();
    while (differenceDigits[0] === '0') differenceDigits.shift();
    return differenceDigits.join('');
};

var sum = function (first, second) {
    first = first.reverse();
    second = second.reverse();
    var firstDigit,
    secondDigit,
    sumDigits = [],
        sumDigit,
        carry = 0,
        index = 0;
    while (index < first.length || index < second.length || carry !== 0) {
        firstDigit = index < first.length ? parseInt(first[index], 10) : 0;
        secondDigit = index < second.length ? parseInt(second[index], 10) : 0;
        sumDigit = firstDigit + secondDigit + carry;
        sumDigits.push((sumDigit % 10).toString());
        carry = sumDigit > 9 ? 1 : 0;
        index++;
    }
    sumDigits.reverse();
    while (sumDigits[0] === '0') sumDigits.shift();
    return sumDigits.join('');
};

      

        
        
        
      

    

Both of these functions now work fine on their own. ¹

I have now updated the function almostFibonacci

as follows to use the sum function instead of + and the difference function instead of - .

var almostFibonacci = function (f) {
    return function (n) {
        return n === '0' || n === '1' ? n : sum(f(difference(n, '1')), f(difference(n, '2')));
    };
};

      

        
        
        
      

    

As you may have guessed, this works. It breaks the violin in the case of even a small number such as 10.

Question: What could be wrong? All functions here work great individually. But in tandem, they seem to fail. Can anyone here help me debug this particularly difficult scenario?

¹ Except for the case of the edge for the difference function. This requires the first argument to be greater than the second.