Flaws of Flow

inconsistent-intersection.js

type Inconsistent = { foo: string } & { foo: number };

// const obj: Inconsistent = { foo: 123 }; // error, consistently

function trick<O: {}, K: string, V>(obj: O, key: K, val: V): O & { [K]: V } {
  obj[key] = val;
  return obj;
}

const obj = trick({ foo: "bar" }, "foo", 123);
(obj: Inconsistent);  // !
(obj.foo: string);    // ok
// (obj.foo: number); // error, why?
obj.foo.charAt(0);    // runtime error, obj.foo is a number

interface-def-site-variance.js

// @flow

class Animal {}
class Cat extends Animal {
  nyan() {
    console.log("nyan");
  }
}
class Serval extends Cat {
  sugoi() {
    console.log("sugoi");
  }
}

interface Src<+T> {
  read(): T,
  write(val: T): void // !?
}

const src: Src<Cat> = {
  val: new Cat(),
  read(): Cat {
    return this.val;
  },
  write(val: Cat) {
    this.val = val;
  }
};

(src.read(): Animal);
(src.read(): Cat);
// (src.read(): Serval); // error

// src.write(new Animal()); // error
src.write(new Cat());
src.write(new Serval());

(src: Src<Animal>); // !?
(src: Src<Cat>);
// (src: Src<Serval>); // error

(src: Src<Animal>).write(new Animal()); // :innocent:
(src.read(): Cat).nyan(); // runtime error