union types + type guards are extremely awkward with loops

[zpdDG4gta8XKpMCd]

Consider an implementation of a list and a fold function in TS1.6:

module Nothing {
    export const enum Brand {}
}
interface Nothing {
    'a brand': Nothing.Brand;
}
interface Node<a> {
    value: a;
    previous: List<a>;
}
export function hasAny<a>(values: List<a>) : values is Node<a> {
    return values != null;
}
type List<a> = Node<a> |  Nothing;
var values : List<string> = undefined;

function fold<a, r>(values: List<a>, result: r, fold: (result: r, value: a) => r) : r {
   // using union types and custom guards what the body of this function should look like?
}

Now in order to iterate through such list in JavaScript all it would take is:

function fold(values, result, fold) {
    for (var node = values; node != null; node = node.previous) {
        result = fold(result, node.value);
    }
    return result;
}

So I would expect that something like this could be easily done in TypeScript using its latest safety features like type guards and union types.

// pseudo code that I wish worked
function fold<a, r>(values: List<a>, result: r, fold: (result: r, value: a) => r) : r {
   for (var node = values; hasAny(node); node = node.previous) {
       result = fold(result, node.value);
   }
   return result;
}

However what I ended up with doesn't look nearly as simple:

// real code full of awkwardness that I managed to hack
function fold<a, r>(values: List<a>, result: r, fold: (result: r, value: a) => r): r {
    var previous = values;
    while (true) {
        var current = previous;
        if (hasAny(current)) {
            result = fold(result, current.value);
            previous = current.previous;
        } else {
            break;
        }
    }
    return result;
}

Now anyone who sees the generated JavaScript would call the cops on me.

function fold(values, result, fold) {
    var previous = values;
    while (true) {
        var current = previous;
        if (hasAny(current)) {
            result = fold(result, current.value);
            previous = current.previous;
        }
        else {
            break;
        }
    }
    return result;
}

Question: Is this how union types + custom guards + loops were designed to work together or I am missing something?

[RyanCavanaugh]

It seems like we should be type guarding the third clause of a for and its body by the second clause? Is that sufficient to fix this?

[zpdDG4gta8XKpMCd]

third clause is a major pain point: the right side of it should be guaded, but the left should be not:

...; node /* <-- must be unguarded */  = node/ * <-- must be guarded */.previous ...

[RyanCavanaugh]

Thinking about it some more, another problem is that we're never going to apply a type guard to something that's assigned to, so we'd need #2388 first to be able to remove that restriction.

Anyway, for simplicity's sake, I would write this:

function fold<a, r>(values: List<a>, result: r, fold: (result: r, value: a) => r): r {
   for (var node = <Node<a>>values; hasAny(node); node = <Node<a>>node.previous) {
       result = fold(result, node.value);
   }
   return result;
}

[zpdDG4gta8XKpMCd]

sure thing you can, it's just upsetting that unions and guards are effectively useless upon arrival, hope you guys can think something up

[RyanCavanaugh]

Does this work as hoped with the new flow analysis?

[zpdDG4gta8XKpMCd]

yes