btw, head = indexl 0 and last = indexr 0

last commit changed output from:

var go = function (v) {
    return function (v1) {
        if (v.pos === idx) {
            return {
                pos: v.pos + 1 | 0,
                elem: new Data_Maybe.Just(v1)
            };
        };
        var $119 = {};
        for (var $120 in v) {
            if ({}.hasOwnProperty.call(v, $120)) {
                $119[$120] = v[$120];
            };
        };
        $119.pos = v.pos + 1 | 0;
        return $119;
    };
};

to

var go = function (cursor) {
    return function (elem1) {
        if (cursor.elem instanceof Data_Maybe.Just) {
            return cursor;
        };
        var $115 = cursor.pos === idx;
        if ($115) {
            return {
                elem: new Data_Maybe.Just(elem1),
                pos: cursor.pos
            };
        };
        return {
            pos: cursor.pos + 1 | 0,
            elem: cursor.elem
        };
    };
};

@paf31 it's ready

Wouldn't this sort of thing be better suited to FoldableWithIndex, etc? I'm not sure adding indexing to a "normal" Foldable is a good idea necessarily, since I don't think there's any implied order, so ideas like getting the head is a bit strange.

I do think it makes sense to add this. A Foldable instance for a container just iterates (some or all of) its elements in some order. You can definitely observe the order by using toList, for example.

I do think it makes sense to add this. A Foldable instance for a container just iterates (some or all of) its elements in some order. You can definitely observe the order by using toList, for example.

Maybe with a warning that people using this on, say, a Map structure should have no guarantee that the order can't change in a point release?

I'm not sure. It would be quite annoying, I think, for the behavior of say, an Ord instance to change in a minor release. I would expect this to be the same.

I think changing Ord behavior is braking change not minor. so if someone makes braking change in minor release, it's fault of the lib not of this function. Someone would still have same issue if toList is used for example.

I'm not saying that it's the fault of the function, I'm saying the order of a fold should be considered part of the observable behavior of a Foldable instance for the purposes of semver.

Is this good to go?