[analyzer] type guards

[nadako]

Something from TypeScript to consider:

function foo(x:Dynamic) {
    if ((x is String)) {
        $type(x); // String
        $type(x.length); // Int
    }
}

See TS Spec: https://github.com/Microsoft/TypeScript/blob/master/doc/spec.md#4.24. That alone could help writing code that is both more concise and performant (on static targets, at least).

However, TS has another nice related feature: user-defined type guards. I.e.:

function isCat(a: Animal): a is Cat {
  return a.name === 'kitty';
}

var x: Animal;
if(isCat(x)) {
  x.meow(); // OK, x is Cat in this block
}

That would help a lot when working with anonymous structures where reflection is required to determine the actual value type. I think this also plays well with our Std.is, Reflect.isFunction, etc functions. e.g.:

function foo(a:Animal) {
    if (Std.is(a, Cat)) {
         $type(a); // Cat
    }
}

[Simn]

From my experience with GADT this is not gonna be very easy to support in our type system. I don't understand the second example though, how is that different from a constrained type parameter? In fact, how is it different from declaring the function isCat(a: Cat)?

[nadako]

The second example is about downcasting, here's what I have in mind regarding structure types:

typedef MapItem = {
    type:String,
}

typedef House = {
    >MapItem,
    numRooms:Int,
}

class Main {
    static function isHouse(mapItem:MapItem):(mapItem is House) {
        return mapItem.type == "house";
    }

    static function doMapItemStuff(mapItem:MapItem) {
        if (isHouse(mapItem)) {
            $type(mapItem); // House, because isHouse returned true and its return value defined as `(argName is Type)`
        }
    }
}

[Simn]

That reminds me of Rust's typestate: http://pcwalton.github.io/blog/2012/12/26/typestate-is-dead/

[ousado]

Regarding user defined type guards, I think it's possible to implement them already, using GADTs, like here:
https://gist.github.com/ousado/9e38931c1380025ba459
Regarding built-in type guards, I think that would boil down to another equally limited version of Std.is with equally abysmal performance.

[Simn]

It occurred to me that this would be a breaking change in this contrived example:

function foo(x:Dynamic) {
	if ((x is String)) {
		$type(x); // String
		x = 1; // Int should be String
	}
}

[nadako]

IIRC, TS remembers the wider type for assignment

[Simn]

This would have to go through a haxe-evolution with actual design and shit.