CFML implementation of Array.reduce()

Question

G'day Just before I submit this to CFLib, it'd be great to get feedback:

<cfscript>
/**
* @hint CFML implementation of Array.reduce(), similar to Javascript's one ref https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/Reduce
* @array Array to reduce
* @callback Callback function to use to reduce. Will receive the following arguments: element (of current iteration of the all), index, array, (optional) result (of preceeding call to callback())
* @initialValue The initial value to use to start the reduction
*/

public any function arrayReduce(required array array, required any callback, any initialValue){
    var startIdx = 1;
    if (!structKeyExists(arguments, "initialValue")){
        if (arrayLen(array) > 0){
            var result = callback(array[1], 1, array);
            startIdx = 2;
        }else{
            return;
        }
    }else{
        var result = initialValue;
    }
    for (var i=startIdx; i <= arrayLen(array); i++){
        result = callback(array[i], i, array, result);
    }
    return result;
}    
</cfscript>

I've created proper unit tests as a gist.

Answer 1

Interesting discussion!

@AdamTuttle Regarding the behavior in Underscore that you've highlighted: I did some quick tests and found that the same behavior exists in Ruby and native JS (Chrome and FF). This confirmed my suspicions that this seemingly weird behavior is just a product of the reduce algorithm itself.

In the algorithm, "memo" represents the current state of the fold operation. If you don't pass in an initial value, you're implying that the first element of the collection represents the initial state of the fold. From that perspective, the behavior you've shown is exactly what I'd expect.

If you want to remove uppercase letters from a collection and convert that to a string in a functional way, it would make more sense to call filter() to and then reduce(). Example:

adamArr = ['A','d','a','m'];
damArr = _.filter(adamArr, function (letter) { 
    var asciiCode = asc(letter); 
    return asciiCode >= 97 && asciiCode <= 122;
};
damString = _.reduce(damArr, function (memo, letter) {
    return memo & letter;
};

Answer 2

I don't see any flaws in your logic... but...

I know you've basically just ported the referenced JavaScript example, but I'm not really fond of the implementation of initialValue.

Instead, have a look at UnderscoreCF's reduce method: (which was itself ported from UnderscoreJS)

/**
*   @header _.reduce(collection, iterator, memo, [context]) : any
*   @hint Also known as inject and foldl, reduce boils down a collection of values into a single value. Memo is the initial state of the reduction, and each successive step of it should be returned by iterator.
*   @example sum = _.reduce([1, 2, 3], function(memo, num){ return memo + num; }, 0);<br />=> 6
*/
public any function reduce(obj = this.obj, iterator = _.identity, memo, this = {}) {

    var outer = {};
    if (structKeyExists(arguments, "memo")) {
        outer.initial = memo;
    }
    _.each(arguments.obj, function(value, index, collection, this) {
        if (!structKeyExists(outer, "initial")) {
            memo = value;
            outer.initial = true;
        }
        else {
            memo = iterator(memo, value, index, this);
        }
    }, arguments.this);

    return memo;
}

Granted it does lean on the _.each method, so it can be a little difficult to wrap your head around. The important bit is:

You can omit the initialValue value and it will be correct no matter what data type is being reduced. Since you have a default value of an empty string, if you're working with numerics, you pretty much have to set an initial value.

On the other hand, the way UnderscoreCF's implementation works is that, if you've not specified a value for memo (initialValue) then it uses the first item in the array as the initial value, and skips the first iteration.

So let's look at two (somewhat contrived) examples:

//string concat
arrayReduce(['A','d','a','m'], function(memo, item){
    return memo & item;
});

This (above) will concatenate the characters together into a string. It would work via either implementation of reduce (yours or UnderscoreCF's).

//sum
arrayReduce([1,2,3,4], function(memo, item){
    return memo + item;
});

This one does a sum, similarly to your example, except that your implementation of reduce will (probably? I haven't tested to see what would happen...) choke because the callback is expecting numerics but memo is defaulted to an empty string for the first iteration.

Hopefully this is clear. It's a subtle difference.

---

In writing this answer I've thought of a potential bug in the Underscore implementation: What if you're concatenating a string but you only wanted to include lower-cased characters?

arrayReduce(['A','d','a','m'], function(memo, item){
    var asciiCode = asc(item);
    return memo & ( asciiCode >= 97 && asciiCode <= 122 ? item : '');
});

You would expect the result to be: dam but would probably get back Adam with UnderscoreCF's implementation. It would be easily mitigated by passing '' for the initialValue argument to reduce, but it is worth noting.

Food for thought! :)