Variables

• Variable declarations

  const x: number = 2
  const y: string = 2
  const z: object = 4
  

  (Playground)

  • Type 2 is not assignable to type string
  • Type 4 is not assignable to type object

  (Playground)

  • Type 'number' is not assignable to type 'string'.
  • Type 'number' is not assignable to type 'object'.

• Variable assignment constraints

  let x: number = 3
  x = "hello world"
  

  (Playground)

  • Type "hello world" is not assignable to type number

  (Playground)

  • Type 'string' is not assignable to type 'number'.

• Variable references

  const a = 3
  const b: string = a
  

  (Playground)

  • Type 3 is not assignable to type string

  (Playground)

  • Type 'number' is not assignable to type 'string'.

• Variable updates registered

  let a = 2
  a = "hello world"
  a satisfies number
  

  (Playground)

  • Expected number, found "hello world"

  (Playground)

  • Type 'string' is not assignable to type 'number'.

• Variable references does not exist

  const exists = 2;
  nexists
  

  (Playground)

  • Could not find variable 'nexists' in scope

  (Playground)

  • Cannot find name 'nexists'. Did you mean 'exists'?

• Assigning before declaration

  a = 3;
  let a = 2;
  

  (Playground)

  • Cannot assign to 'a' before declaration

  (Playground)

  • Block-scoped variable 'a' used before its declaration.

• Assignment to non-existent variable

  doesNotExist = 4;
  

  (Playground)

  • Cannot assign to unknown variable 'doesNotExist'

  (Playground)

  • Cannot find name 'doesNotExist'.

• Variable declared twice

  const a = 2
  {
      const a = 3;
      a satisfies 3;
  }
  a satisfies 2;
  const a = 3;
  

  (Playground)

  • Cannot redeclare variable 'a'

  (Playground)

  • Cannot redeclare block-scoped variable 'a'.
  • Cannot redeclare block-scoped variable 'a'.

• Variable shadowing

  const a = 2
  {
      const a = 3;
      a satisfies 2;
  }
  

  (Playground)

  • Expected 2, found 3

  (Playground)

  • Type '3' does not satisfy the expected type '2'.

• Unintialised variables are undefined

  let b;
  b satisfies string;
  

  (Playground)

  • Expected string, found undefined

  (Playground)

• TDZ in statements

  let first = second;
  let second = 2;
  

  (Playground)

  • Variable 'second' used before declaration

  (Playground)

  • Block-scoped variable 'second' used before its declaration.

• var can be reregistered

  {
      // Fine
      var x = 2;
      x satisfies 2;
      var x = 3;
      x satisfies 3;
  }
  
  {
      let b = 2;
      var b = 2;
  }
  

  (Playground)

  • Cannot redeclare variable 'b'

  (Playground)

  • Type 'number' does not satisfy the expected type '2'.
  • Type 'number' does not satisfy the expected type '3'.
  • Cannot initialize outer scoped variable 'b' in the same scope as block scoped declaration 'b'.

Properties

• Property exists

  let my_obj = { a: 3 }
  const a = my_obj.a
  const b = my_obj.b
  

  (Playground)

  • No property 'b' on { a: 3 }

  (Playground)

  • Property 'b' does not exist on type '{ a: number; }'.

• Reading property (via accessor)

  const my_obj = { a: 2 }
  const three: 3 = my_obj.a
  

  (Playground)

  • Type 2 is not assignable to type 3

  (Playground)

  • Type 'number' is not assignable to type '3'.

• Property updates registered

  let my_obj = { a: 3 }
  my_obj.a = 4
  let b: 3 = my_obj.a
  

  (Playground)

  • Type 4 is not assignable to type 3

  (Playground)

  • Type 'number' is not assignable to type '3'.

• Objects checks

  const my_obj: { b: 3 } = { b: 4 }
  

  (Playground)

  • Type { b: 4 } is not assignable to type { b: 3 }

  (Playground)

  • Type '4' is not assignable to type '3'.

• Getters

  let global: number = 0;
  const object = {
      // This getter has an impure side effect
      get value() {
          return ++global
      },
  }
  
  object.value satisfies string
  object.value satisfies boolean
  

  (Playground)

  • Expected string, found 1
  • Expected boolean, found 2

  (Playground)

  • Type 'number' does not satisfy the expected type 'string'.
  • Type 'number' does not satisfy the expected type 'boolean'.

• Getter this

  const object = {
      x: 4,
      get value(this: { x: number }) {
          return this.x
      },
  }
  
  object.value satisfies string
  

  (Playground)

  • Expected string, found 4

  (Playground)

  • 'get' and 'set' accessors cannot declare 'this' parameters.
  • Type 'number' does not satisfy the expected type 'string'.

• Setter this

  let a = 2;
  const obj = {
      x: 5,
      set value(this: { x: number }, v) {
          this.x = v;
      }
  }
  
  obj.value = "some value";
  obj.x satisfies 5;
  

  (Playground)

  • Expected 5, found "some value"

  (Playground)

  • 'get' and 'set' accessors cannot declare 'this' parameters.
  • Type 'number' does not satisfy the expected type '5'.

• Setter assignment type

  const obj = {
      set value(v: string) { }
  }
  
  obj.value = 5;
  

  (Playground)

  • Argument of type 5 is not assignable to parameter of type string (in setter)

  (Playground)

  • Type 'number' is not assignable to type 'string'.

• Setter side effect

  let a = 2;
  const obj = {
      x: 5,
      set value(v) {
          a = v;
      }
  }
  
  obj.value = "some value";
  a satisfies 2;
  

  (Playground)

  • Expected 2, found "some value"

  (Playground)

  • Type 'number' does not satisfy the expected type '2'.

• Setter return

  const result = ({ set value(a) { return { a: 3 } }}).value = 5;
  result satisfies string;
  

  (Playground)

  • Expected string, found 5

  (Playground)

  • Setters cannot return a value.
  • Type 'number' does not satisfy the expected type 'string'.

• Object spread

  const obj1 = { a: 2, b: 3 };
  const obj2 = { b: 4, ...obj1, a: 6 };
  
  obj2.b satisfies 100;
  obj2.a satisfies boolean;
  

  (Playground)

  • Expected 100, found 3
  • Expected boolean, found 6

  (Playground)

  • Type 'number' does not satisfy the expected type '100'.
  • Type 'number' does not satisfy the expected type 'boolean'.

• Set property with key

  const obj: { a?: number, b?: number } = { a: 2 }
  
  function setProperty(key: "a" | "b", value: number) {
      obj[key] = value;
  }
  
  setProperty("b", 6)
  obj satisfies string;
  

  (Playground)

  • Expected string, found { a: 2, b: 6 }

  (Playground)

  • Type '{ a?: number; b?: number; }' does not satisfy the expected type 'string'.

• Delete properties

  const x = { a: 2, b: 3 }
  delete x.b;
  const b = x.b;
  

  (Playground)

  • No property 'b' on { a: 2 }

  (Playground)

• Spread condition

  declare let condition: boolean;
  
  const obj = {
      foo: 1,
      ...(condition ? {
          bar: 2,
          non_existent: 3,
      } : {}),
  };
  
  obj.foo satisfies number;
  obj.bar satisfies string;
  

  (Playground)

  • Expected string, found 2 | undefined

  (Playground)

  • Type 'number' does not satisfy the expected type 'string'.

• And on properties

  declare type U = { a: 2 } & { b: 3 }
  declare let x: U;
  x.b satisfies 3;
  
  ({ a: 2, b: 3 } satisfies U);
  ({ b: 3 } satisfies U);
  

  (Playground)

  • Expected U, found { b: 3 }

  (Playground)

  • Type '{ b: 3; }' does not satisfy the expected type 'U'.

• Properties on or

  declare let key: "a" | "b";
  
  const object = { a: "apple", b: "banana" };
  object[key] satisfies boolean;
  

  (Playground)

  • Expected boolean, found "apple" | "banana"

  (Playground)

  • Type 'string' does not satisfy the expected type 'boolean'.

• Properties on big or

  function func(idx: number) {
      const array = [1, 2, 3];
      array[idx] satisfies string;
  }
  

  (Playground)

  • Expected string, found 1 | 2 | 3 | undefined

  (Playground)

  • Type 'number' does not satisfy the expected type 'string'.

• Properties matched against continous type become conditional

  declare let strings: { [a: string]: number };
  declare let record: Record<string, number>;
  declare let d: { [a: "a" | "b"]: number };
  
  strings.a satisfies number | undefined;
  record.a satisfies boolean;
  d.a satisfies number;
  

  (Playground)

  • Expected boolean, found number | undefined

  (Playground)

  • An index signature parameter type cannot be a literal type or generic type. Consider using a mapped object type instead.
  • Type 'number' does not satisfy the expected type 'boolean'.
  • Property 'a' does not exist on type '{}'.

• Un-delete-able property

  const x: { a?: number } = { a: 4 };
  // Fine
  delete x.a;
  
  const y: { a: number } = { a: 4 };
  // Bad
  delete y.a;
  
  const z = {};
  Object.defineProperty(z, "a", { value: 4 });
  delete z.a;
  

  (Playground)

  • Cannot delete from object constrained to { a: number }
  • Cannot delete from non-configurable property

  (Playground)

  • Property 'a' does not exist on type '{}'.

• Order of numerical properties

  let x = {}; x.something = null; x[4] = null; x["eight"] = null; x["2"] = null;
  x satisfies string;
  

  (Playground)

  • Expected string, found { 2: null, 4: null, something: null, eight: null }

  (Playground)

  • Property 'something' does not exist on type '{}'.
  • Type '{}' does not satisfy the expected type 'string'.

• Order of properties after assignment

  const obj = { a: 1, b: 2 };
  obj.a = 2; obj.c = 6; obj.b = 4;
  obj satisfies boolean;
  

  (Playground)

  • Expected boolean, found { a: 2, b: 4, c: 6 }

  (Playground)

  • Property 'c' does not exist on type '{ a: number; b: number; }'.
  • Type '{ a: number; b: number; }' does not satisfy the expected type 'boolean'.

• Assigning to getter

  const obj = { get prop() { return 2 } };
  obj.prop = "hi";
  obj.prop satisfies 2;
  

  (Playground)

  • Cannot write to property 'prop' as it is a getter

  (Playground)

  • Cannot assign to 'prop' because it is a read-only property.
  • Type 'number' does not satisfy the expected type '2'.

• Assinging to non existent property

  const obj = { prop: 1 };
  // Fine
  obj.non_existent = 6;
  
  function func(param: { prop: number }) {
      param.notProp = 5;
  }
  

  (Playground)

  • Cannot write to non-existent property 'notProp'

  (Playground)

  • Property 'non_existent' does not exist on type '{ prop: number; }'.
  • Property 'notProp' does not exist on type '{ prop: number; }'.

• Function and class name

  function a() { }
  class B { }
  let c = class { }
  
  a.name satisfies "a"
  B.name satisfies "B"
  c.name satisfies "sea"
  

  (Playground)

  • Expected "sea", found "c"

  (Playground)

  • Property 'name' does not exist on type '() => void'.
  • Property 'name' does not exist on type 'typeof B'.
  • Property 'name' does not exist on type 'typeof c'.

• Getters AND setter

  let global: number = 0;
  const object = {
      get value() {
          return global
      },
      set value(newValue: number) {
          global = newValue;
      }
  }
  
  object.value satisfies string;
  object.value = 10;
  object.value satisfies 10;
  global satisfies 10
  

  (Playground)

  • Expected string, found 0

  (Playground)

  • Type 'number' does not satisfy the expected type 'string'.
  • Type 'number' does not satisfy the expected type '10'.
  • Type 'number' does not satisfy the expected type '10'.

• Getters AND setter can be type via Object.defineProperty

  function func(get: () => number) {
      const obj = {};
      Object.defineProperty(obj, "value", { get });
      obj.value satisfies string
  }
  

  (Playground)

  • Expected string, found number

  (Playground)

  • Property 'value' does not exist on type '{}'.

• enumerable in for in

  const obj = { n: 1, b: 2 };
  Object.defineProperty(obj, "c", { value: 3, enumerable: false });
  Object.defineProperty(obj, "d", { value: 4, enumerable: true });
  
  let keys: string = "";
  for (const key in obj) {
      keys += key;
  }
  keys satisfies boolean
  

  (Playground)

  • Expected boolean, found "nbd"

  (Playground)

  • Type 'string' does not satisfy the expected type 'boolean'.

• Object.defineProperty writable

  const obj = {};
  Object.defineProperty(obj, 'property', {
      value: 42,
      writable: false,
  });
  obj.property satisfies string;
  obj.property = 70;
  

  (Playground)

  • Expected string, found 42
  • Cannot write to property 'property'

  (Playground)

  • Property 'property' does not exist on type '{}'.
  • Property 'property' does not exist on type '{}'.

• Descriptor carries across assignments

  const obj = {};
  Object.defineProperty(obj, 'property', {
      value: 42,
      enumerable: false,
      // needed as all properties default to false
      writable: true,
  });
  obj.property = 70;
  Object.getOwnPropertyDescriptor(obj, 'property') satisfies string;
  

  (Playground)

  • Expected string, found { value: 70, writable: true, enumerable: false, configurable: false }

  (Playground)

  • Property 'property' does not exist on type '{}'.
  • Type 'PropertyDescriptor' does not satisfy the expected type 'string'.

• Object.defineProperty getter and setter

  const obj = {};
  let b = 0;
  Object.defineProperty(obj, 'property', {
      get: () => b,
  });
  obj.property satisfies 0;
  b++;
  obj.property satisfies string;
  

  (Playground)

  • Expected string, found 1

  (Playground)

  • Property 'property' does not exist on type '{}'.
  • Property 'property' does not exist on type '{}'.

• Object.defineProperty configurable

  const obj = {};
  Object.defineProperty(obj, 'property', { value: 6 });
  Object.defineProperty(obj, 'property', { value: "hi" });
  

  (Playground)

  • Property 'property' not configurable

  (Playground)

• Object.getOwnPropertyDescriptor

  const obj = { a: "something" };
  Object.defineProperty(obj, 'b', { value: 42 });
  
  Object.getOwnPropertyDescriptor(obj, 'a') satisfies string;
  Object.getOwnPropertyDescriptor(obj, 'b').writable satisfies false;
  

  (Playground)

  • Expected string, found { value: "something", writable: true, enumerable: true, configurable: true }

  (Playground)

  • Type 'PropertyDescriptor' does not satisfy the expected type 'string'.
  • Type 'boolean' does not satisfy the expected type 'false'.

• Object.assign

  const obj = { a: 1 };
  Object.assign(obj, { b: 2, c: 3 });
  obj satisfies string;
  

  (Playground)

  • Expected string, found { a: 1, b: 2, c: 3 }

  (Playground)

  • Property 'assign' does not exist on type 'ObjectConstructor'. Do you need to change your target library? Try changing the 'lib' compiler option to 'es2015' or later.
  • Type '{ a: number; }' does not satisfy the expected type 'string'.

• Object.freeze

  const obj = {}
  let result = Object.freeze(obj);
  (obj === result) satisfies true;
  obj.property = 2;
  Object.isSealed(obj) satisfies true;
  

  (Playground)

  • Cannot write to property 'property'

  (Playground)

  • Type 'boolean' does not satisfy the expected type 'true'.
  • Property 'property' does not exist on type '{}'.
  • Type 'boolean' does not satisfy the expected type 'true'.

• Object.seal

  const obj = { a: 2 }
  let result = Object.seal(obj);
  (obj === result) satisfies true;
  
  // Allowed
  obj.a = 4;
  // Not allowed
  obj.property = 2;
  
  Object.isSealed(obj) satisfies true;
  Object.isFrozen(obj) satisfies false;
  

  (Playground)

  • Cannot write to property 'property'

  (Playground)

  • Type 'boolean' does not satisfy the expected type 'true'.
  • Property 'property' does not exist on type '{ a: number; }'.
  • Type 'boolean' does not satisfy the expected type 'true'.
  • Type 'boolean' does not satisfy the expected type 'false'.

• Object.preventExtensions

  const obj = { a: 2 }
  let result = Object.preventExtensions(obj);
  (obj === result) satisfies true;
  
  // Allowed
  obj.a = 4;
  // Not allowed
  obj.property = 2;
  
  Object.isFrozen(obj) satisfies false;
  Object.isSealed(obj) satisfies false;
  

  (Playground)

  • Cannot write to property 'property'

  (Playground)

  • Type 'boolean' does not satisfy the expected type 'true'.
  • Property 'property' does not exist on type '{ a: number; }'.
  • Type 'boolean' does not satisfy the expected type 'false'.
  • Type 'boolean' does not satisfy the expected type 'false'.

• Object.isExtensible

  {
      const obj = {}
      Object.isExtensible(obj) satisfies true;
      Object.preventExtensions(obj);
      Object.isExtensible(obj) satisfies false;
  }
  {
      const obj = {}
      Object.seal(obj);
      Object.isExtensible(obj) satisfies false;
  }
  {
      const obj = {}
      Object.freeze(obj);
      Object.isExtensible(obj) satisfies 5;
  }
  

  (Playground)

  • Expected 5, found false

  (Playground)

  • Type 'boolean' does not satisfy the expected type 'true'.
  • Type 'boolean' does not satisfy the expected type 'false'.
  • Type 'boolean' does not satisfy the expected type 'false'.
  • Type 'boolean' does not satisfy the expected type '5'.

Excess properties

• Excess property at declaration

  interface MyObject { property: string }
  
  const a: MyObject = { property: "hello", another: 2 }
  

  (Playground)

  • 'another' is not a property of MyObject

  (Playground)

  • Object literal may only specify known properties, and 'another' does not exist in type 'MyObject'.

• Excess property at argument

  interface MyObject { property: string }
  
  function process(param: MyObject) {}
  
  process({ property: "hello", another: 2 });
  
  function func<T>(a: T) { }
  
  func<MyObject>({ property: "hello", "something else": 2 })
  

  (Playground)

  • 'another' is not a property of MyObject
  • 'something else' is not a property of MyObject

  (Playground)

  • Object literal may only specify known properties, and 'another' does not exist in type 'MyObject'.
  • Object literal may only specify known properties, and '"something else"' does not exist in type 'MyObject'.

• Excess property at return type

  interface MyObject { property: string }
  
  function returnNewObject(): MyObject {
      return { property: "hello", another: 67 }
  }
  

  (Playground)

  • 'another' is not a property of MyObject

  (Playground)

  • Object literal may only specify known properties, and 'another' does not exist in type 'MyObject'.

• Excess property checks through spread and condition

  type MyObject = { foo: number; bar?: number };
  
  const b: MyObject = {
      foo: 1,
      ...{
          bar: 2,
          invalid: 3,
      },
  };
  
  declare let condition: boolean;
  
  const c: MyObject = {
      foo: 1,
      ...(condition ? {
          bar: 2,
          non_existent: 3,
      } : {}),
  };
  

  (Playground)

  • 'invalid' is not a property of MyObject
  • 'non_existent' is not a property of MyObject

  (Playground)

Constant evaluation

• Arithmetic

  const x: 4 = 2 + 3
  const y: 6 = 2 * 3
  const z: 8 = (2 * 3) - 2
  

  (Playground)

  • Type 5 is not assignable to type 4
  • Type 4 is not assignable to type 8

  (Playground)

  • Type 'number' is not assignable to type '4'.
  • Type 'number' is not assignable to type '6'.
  • Type 'number' is not assignable to type '8'.

• Bitwise arithmetic

  const x: 2 = 2 & 3
  const y: 6 = 2 ^ 7
  const z: 14 = 8 | 4
  

  (Playground)

  • Type 5 is not assignable to type 6
  • Type 12 is not assignable to type 14

  (Playground)

  • Type 'number' is not assignable to type '2'.
  • Type 'number' is not assignable to type '6'.
  • Type 'number' is not assignable to type '14'.

• Logical operators

  const x: 2 = 3 && 2
  const y: 6 = 3 && false
  const z: false = true || 4
  

  (Playground)

  • Expression is always true
  • Expression is always true
  • Type false is not assignable to type 6
  • Expression is always true
  • Type true is not assignable to type false

  (Playground)

  • Type '0 | 2' is not assignable to type '2'.
  • Type 'false' is not assignable to type '6'.
  • Type 'true | 4' is not assignable to type 'false'.

• Equality

  (4 === 2) satisfies true;
  (4 !== 5) satisfies string;
  

  (Playground)

  • Expected true, found false
  • Expected string, found true

  (Playground)

  • This comparison appears to be unintentional because the types '4' and '2' have no overlap.
  • Type 'boolean' does not satisfy the expected type 'true'.
  • This comparison appears to be unintentional because the types '4' and '5' have no overlap.
  • Type 'boolean' does not satisfy the expected type 'string'.

• Inequality

  (Math.PI > 3) satisfies true;
  (4 < 2) satisfies true;
  (4 > 2) satisfies number;
  (6 >= 2) satisfies string;
  (6 <= 2) satisfies 5;
  

  (Playground)

  • Expected true, found false
  • Expected number, found true
  • Expected string, found true
  • Expected 5, found false

  (Playground)

  • Type 'boolean' does not satisfy the expected type 'true'.
  • Type 'boolean' does not satisfy the expected type 'true'.
  • Type 'boolean' does not satisfy the expected type 'number'.
  • Type 'boolean' does not satisfy the expected type 'string'.
  • Type 'boolean' does not satisfy the expected type '5'.

• String operations (constant functions can use this)

  "hi".toUpperCase() satisfies number
  

  (Playground)

  • Expected number, found "HI"

  (Playground)

  • Type 'string' does not satisfy the expected type 'number'.

• Math operations

  Math.cos(0) satisfies 0
  Math.sqrt(16) satisfies 1
  Math.floor(723.22) satisfies 2;
  

  (Playground)

  • Expected 0, found 1
  • Expected 1, found 4
  • Expected 2, found 723

  (Playground)

  • Type 'number' does not satisfy the expected type '0'.
  • Type 'number' does not satisfy the expected type '1'.
  • Type 'number' does not satisfy the expected type '2'.

• Updating assignments

  let a = 5, b = 6;
  a++;
  a satisfies 4;
  b *= 4;
  b satisfies 23;
  

  (Playground)

  • Expected 4, found 6
  • Expected 23, found 24

  (Playground)

  • Type 'number' does not satisfy the expected type '4'.
  • Type 'number' does not satisfy the expected type '23'.

• Index into string

  ("something"[2]) satisfies number;
  

  (Playground)

  • Expected number, found "m"

  (Playground)

  • Type 'string' does not satisfy the expected type 'number'.

Function checking

• Type of parameter

  function func(a: number) {
      a satisfies string
  }
  

  (Playground)

  • Expected string, found number

  (Playground)

  • Type 'number' does not satisfy the expected type 'string'.

• Default parameter value type check

  function outer(a: number) {
      function inner(b: string = Math.floor(a)) {
      }
  }
  

  (Playground)

  • Cannot use a default value of type number for parameter of type string

  (Playground)

  • Type 'number' is not assignable to type 'string'.

• (simple) return type checking

  function func(): string {
      return 2
  }
  

  (Playground)

  • Cannot return 2 because the function is expected to return string

  (Playground)

  • Type 'number' is not assignable to type 'string'.

• Type checking basic function types

  function func(a: string, b: number): boolean {
      return true
  }
  func satisfies (a: string, b: number) => boolean;
  func satisfies (a: string, b: number) => string;
  func satisfies (a: number, b: number) => boolean;
  

  (Playground)

  • Expected (a: string, b: number) => string, found (a: string, b: number) => boolean
  • Expected (a: number, b: number) => boolean, found (a: string, b: number) => boolean

  (Playground)

  • Type '(a: string, b: number) => boolean' does not satisfy the expected type '(a: string, b: number) => string'.
  • Type '(a: string, b: number) => boolean' does not satisfy the expected type '(a: number, b: number) => boolean'.

• Return generics mismatch

  function getSecond1<T, U>(p1: T, p2: U): U {
      return p1
  }
  
  function getSecond2<T, U>(p1: T, p2: U): U {
      return p2
  }
  

  (Playground)

  • Cannot return T because the function is expected to return U

  (Playground)

  • Type 'T' is not assignable to type 'U'.

• Use of generics in function body

  function setFirst1<T, U>(a: T, b: U) {
      const a2: T = a;
  }
  
  function setFirst2<T, U>(a: T, b: U) {
      const a2: U = a;
  }
  

  (Playground)

  • Type T is not assignable to type U

  (Playground)

  • Type 'T' is not assignable to type 'U'.

• Generics as property

  function createObject1<T, U>(a: T, b: U): { a: T, b: U } {
      return { a, b }
  }
  
  function createObject2<T, U>(a: T, b: U): { a: U, b: U } {
      return { a, b }
  }
  

  (Playground)

  • Cannot return { a: T, b: U } because the function is expected to return { a: U, b: U }

  (Playground)

  • Type 'T' is not assignable to type 'U'.

• Expected parameter from variable declaration

  const x: (a: string) => number = a => a.to;
  

  (Playground)

  • No property 'to' on string

  (Playground)

  • Property 'to' does not exist on type 'string'.

• Expected argument from parameter declaration

  function map(a: (a: number) => number) {}
  
  // No annotation on `a`. But error comes from body
  // (rather than parameter assignment)
  map(a => a.t)
  

  (Playground)

  • No property 't' on number

  (Playground)

  • Property 't' does not exist on type 'number'.

• Assignment to parameter

  function alterParameter(a: number, b: { prop: string }) {
      a = 2;
      a = "hi";
  
      b.prop = 3;
  
      b.prop = "hello";
      // Observed. TODO disabled because of possible impure (getters etc)
      // b.prop satisfies "hello";
  }
  

  (Playground)

  • Type "hi" is not assignable to type number
  • Type 3 does not meet property constraint string

  (Playground)

  • Type 'string' is not assignable to type 'number'.
  • Type 'number' is not assignable to type 'string'.

• Variadic function parameter type

  function variadic(...r: string[]) {
      r satisfies boolean;
  }
  

  (Playground)

  • Expected boolean, found Array

  (Playground)

  • Type 'string[]' does not satisfy the expected type 'boolean'.

• Destructuring parameter

  function myFunction({ a }: { a: number }) {
      a satisfies boolean;
      return a
  }
  
  myFunction({ a: 6 }) satisfies string;
  

  (Playground)

  • Expected boolean, found number
  • Expected string, found 6

  (Playground)

  • Type 'number' does not satisfy the expected type 'boolean'.
  • Type 'number' does not satisfy the expected type 'string'.

• Return type annotation is used in constraint

  function getNumber1(): number {
      return 4
  }
  
  function getNumber2() {
      return 6
  }
  
  getNumber1 satisfies () => 4;
  getNumber2 satisfies () => 6;
  
  getNumber1() satisfies 4;
  getNumber2() satisfies 6;
  

  (Playground)

  • Expected () => 4, found () => number

  (Playground)

  • Type '() => number' does not satisfy the expected type '() => 4'.
  • Type '() => number' does not satisfy the expected type '() => 6'.
  • Type 'number' does not satisfy the expected type '4'.
  • Type 'number' does not satisfy the expected type '6'.

• Function hoisting

  function x() {
      getString(3)
  }
  
  function y() {
      getString("something") satisfies string;
  }
  
  function getString(param: string): string {
      return "hi"
  }
  

  (Playground)

  • Argument of type 3 is not assignable to parameter of type string

  (Playground)

  • Argument of type 'number' is not assignable to parameter of type 'string'.

Inferred return types

• Simple

  function id(a: number) {
      return a
  }
  
  function simple() {
      return "hello world"
  }
  
  id satisfies (n: number) => number;
  simple satisfies () => number;
  

  (Playground)

  • Expected () => number, found () => "hello world"

  (Playground)

  • Type '() => string' does not satisfy the expected type '() => number'.

• Conditional

  function func<T extends boolean>(condition: T) {
      if (condition) {
          return 4
      } else {
          return 3
      }
  }
  
  func satisfies string;
  

  (Playground)

  • Expected string, found (condition: T) => T ? 4 : 3

  (Playground)

  • Type '(condition: T) => 4 | 3' does not satisfy the expected type 'string'.

• Early return

  function func(value: number) {
      if (value === 3) {
          return "is three"
      }
      console.log("hi")
      return "another"
  }
  
  func satisfies (a: number) => "is three" | "another";
  
  function loop(value: number) {
      for (let i = 0; i < 10; i++) {
          if (value === i) {
              return "something"
          }
      }
      return "another"
  }
  
  loop satisfies (a: number) => "something" | "another";
  
  function sometimes(a: boolean) {
      if (a) {
          return "sometimes"
      }
  }
  
  sometimes satisfies (a: boolean) => string;
  

  (Playground)

  • Expected (a: boolean) => string, found (a: boolean) => "sometimes" | undefined

  (Playground)

  • Cannot find name 'console'. Do you need to change your target library? Try changing the 'lib' compiler option to include 'dom'.

• throw in body

  function throwSomething() {
      throw "to implement!"
  }
  
  throwSomething satisfies string;
  

  (Playground)

  • Expected string, found () => never

  (Playground)

  • Type '() => void' does not satisfy the expected type 'string'.

Function calling

• Argument type against parameter

  function func(a: number) {}
  func("hello world")
  

  (Playground)

  • Argument of type "hello world" is not assignable to parameter of type number

  (Playground)

  • Argument of type 'string' is not assignable to parameter of type 'number'.

• Parameters retain argument values

  function id(a) {
      return a
  }
  
  const d: 3 = id(2)
  

  (Playground)

  • Type 2 is not assignable to type 3

  (Playground)

• Get value of property on parameter

  function getA(obj: { a: string }) {
      return obj.a
  }
  
  const d: 3 = getA({ a: "hi" })
  

  (Playground)

  • Type "hi" is not assignable to type 3

  (Playground)

  • Type 'string' is not assignable to type '3'.

• Missing argument

  function func(p1: number, p2: string) {}
  
  func(4)
  

  (Playground)

  • Missing argument

  (Playground)

  • Expected 2 arguments, but got 1.

• Excess argument

  function func(p1: number) {}
  
  func(4, "extra")
  

  (Playground)

  • Excess argument

  (Playground)

  • Expected 1 arguments, but got 2.

• Calling non-callable

  const x = "hi"
  x()
  

  (Playground)

  • Cannot call type "hi"

  (Playground)

  • This expression is not callable.

• Calling higher order function

  function addTwoToResult(func: (n: number) => number) {
      return func(4) + 2
  }
  
  addTwoToResult((a: number) => a * 4) satisfies 5
  

  (Playground)

  • Expected 5, found 18

  (Playground)

  • Type 'number' does not satisfy the expected type '5'.

• Calling higher order function that is constant

  function call(func: (n: number) => number) {
      return func(9)
  }
  
  call(Math.sqrt) satisfies 2
  

  (Playground)

  • Expected 2, found 3

  (Playground)

  • Type 'number' does not satisfy the expected type '2'.

• Constant call and operation with a parameter

  function floorPlusB(a: number, b: number) {
      return Math.floor(a) + b
  }
  
  floorPlusB(100.22, 5) satisfies 8
  

  (Playground)

  • Expected 8, found 105

  (Playground)

  • Type 'number' does not satisfy the expected type '8'.

• This in object literal

  const obj = {
      a: 4,
      getA(this: { a: any }) {
          return this.a
      }
  }
  
  obj.a = 5;
  obj.getA() satisfies 6;
  

  (Playground)

  • Expected 6, found 5

  (Playground)

• This passed around

  function getToUpperCase(s: string) {
      return s.toUpperCase
  }
  
  getToUpperCase("hi")() satisfies "HEY";
  

  (Playground)

  • Expected "HEY", found "HI"

  (Playground)

  • Type 'string' does not satisfy the expected type '"HEY"'.

• This as generic argument

  function callToUpperCase(s: string) {
      return s.toUpperCase()
  }
  
  callToUpperCase("hi") satisfies "HEY";
  

  (Playground)

  • Expected "HEY", found "HI"

  (Playground)

  • Type 'string' does not satisfy the expected type '"HEY"'.

• String internal this unbinding error

  const { toUpperCase } = "hi";
  
  toUpperCase();
  

  (Playground)

  • The 'this' context of the function is expected to be string, found undefined

  (Playground)

• Calling new on a function

  function MyClass(value) {
      this.value = value
  }
  
  new MyClass("hi").value satisfies "hello"
  

  (Playground)

  • Expected "hello", found "hi"

  (Playground)

• new on function with assigned prototype

  function MyClass(value) {
      this.value = value
  }
  
  MyClass.prototype.other = 2;
  
  const object = new MyClass("hi");
  object.value satisfies "hi";
  object.other satisfies "hello";
  

  (Playground)

  • Expected "hello", found 2

  (Playground)

• Checking with function prototype

  function MyClass(this: { other: string }) { }
  
  MyClass.prototype.other = 2;
  
  const m = new MyClass();
  

  (Playground)

  • The 'this' context of the function is expected to be { other: string }, found { other: 2 }

  (Playground)

• Arguments in to rest parameter

  function myRestFunction(...r: string[]) {
      return r
  }
  
  myRestFunction("hello ", "world") satisfies number;
  

  (Playground)

  • Expected number, found ["hello ", "world"]

  (Playground)

  • Type 'string[]' does not satisfy the expected type 'number'.

• Default parameter

  function withDefault(x: number = 1) {
      return x
  }
  
  withDefault() satisfies 2;
  withDefault(3) satisfies 3;
  

  (Playground)

  • Expected 2, found 1

  (Playground)

  • Type 'number' does not satisfy the expected type '2'.
  • Type 'number' does not satisfy the expected type '3'.

• Default parameter side effect

  let b: number = 0
  function doThing(a: number = (b += 2)) {
      return a
  }
  
  doThing(7);
  b satisfies 0;
  doThing();
  b satisfies 1;
  

  (Playground)

  • Expected 1, found 2

  (Playground)

  • Type 'number' does not satisfy the expected type '0'.
  • Type 'number' does not satisfy the expected type '1'.

• Optional parameter type

  function optionally(p?: number) {
      p satisfies string;
  }
  

  (Playground)

  • Expected string, found number | undefined

  (Playground)

  • Type 'number' does not satisfy the expected type 'string'.

• Calling optional parameter type

  function optionally(p?: number) {
      return p
  }
  
  // Fine
  optionally() satisfies undefined;
  optionally(5) satisfies 5;
  
  optionally("hello world");
  

  (Playground)

  • Argument of type "hello world" is not assignable to parameter of type number | undefined

  (Playground)

  • Type 'number' does not satisfy the expected type 'undefined'.
  • Type 'number' does not satisfy the expected type '5'.
  • Argument of type 'string' is not assignable to parameter of type 'number'.

• Default parameter side effect on parameter

  function doThing(a: number, b: number = (a += 2)) {
      return a
  }
  
  doThing(3) satisfies 2;
  doThing(6, 1) satisfies 6;
  

  (Playground)

  • Expected 2, found 5

  (Playground)

  • Type 'number' does not satisfy the expected type '2'.
  • Type 'number' does not satisfy the expected type '6'.

• Canceled generics

  declare function func<T>(prop: { a: number, b: T, c: string } | { a: number, b: string, c: T }): T;
  
  func({ a: 3, b: "hi", c: false }) satisfies string;
  

  (Playground)

  • Expected string, found false

  (Playground)

  • Type 'boolean' is not assignable to type 'string'.

• Template literal calling error

  function myTag(static_parts: Array<string>, count: number) {
  }
  
  myTag`Count is ${"not a number!!"}`;
  

  (Playground)

  • Argument of type "not a number!!" is not assignable to parameter of type number (in template literal)

  (Playground)

  • Argument of type 'TemplateStringsArray' is not assignable to parameter of type 'string[]'.

• Generics on dependent type

  function createNew(cb: { f<T>(t: T): { a: T }}["f"]) {
      return cb(4)
  }
  
  createNew satisfies string;
  

  (Playground)

  • Expected string, found (cb: (t: T) => { a: T }) => { a: 4 }

  (Playground)

  • Type '(cb: (t: T) => { a: T; }) => { a: number; }' does not satisfy the expected type 'string'.

• Builder pattern

  class StringBuilder {
      s: string = ""
  
      append(s: string) {
          this.s += s;
          return this
      }
  
      finish() {
          return this.s
      }
  }
  
  (new StringBuilder).append("Hello ").append("Ben").finish() satisfies number
  

  (Playground)

  • Expected number, found "Hello Ben"

  (Playground)

  • Type 'string' does not satisfy the expected type 'number'.

• Dependent operations

  function isFive(a: number): boolean {
      return a === 5
  }
  
  isFive(5) satisfies true;
  isFive(6) satisfies string;
  
  function hasPropertyX(obj: object): boolean {
      return "x" in obj;
  }
  
  hasPropertyX({ a: 2 }) satisfies false;
  hasPropertyX({ x: 5 }) satisfies number;
  

  (Playground)

  • Expected string, found false
  • Expected number, found true

  (Playground)

  • Type 'boolean' does not satisfy the expected type 'true'.
  • Type 'boolean' does not satisfy the expected type 'string'.
  • Type 'boolean' does not satisfy the expected type 'false'.
  • Type 'boolean' does not satisfy the expected type 'number'.

Effects

• Assignment to free variable

  let a: number = 0
  function func() {
      a = 4;
      // Important that subsequent reads use the
      // new value, not the same free variable
      a satisfies 4;
  }
  
  func()
  let b: 2 = a
  

  (Playground)

  • Type 4 is not assignable to type 2

  (Playground)

  • Type 'number' does not satisfy the expected type '4'.
  • Type 'number' is not assignable to type '2'.

• Assignment from parameter

  let a: number = 0
  function func(c: number) {
      a = c
  }
  
  func(4)
  let b: 2 = a
  

  (Playground)

  • Type 4 is not assignable to type 2

  (Playground)

  • Type 'number' is not assignable to type '2'.

• Free variable property update object inside function

  const obj: { a: number } = { a: 2 }
  function func(value: number) {
      obj.a = value
  }
  
  obj.a satisfies 2
  func(4)
  obj.a satisfies 3
  

  (Playground)

  • Expected 3, found 4

  (Playground)

  • Type 'number' does not satisfy the expected type '2'.
  • Type 'number' does not satisfy the expected type '3'.

• Effects carry through dependent calls

  let a: number = 2
  function runFunctionTwice(func: () => void) {
      func()
      func()
  }
  
  a satisfies 2
  runFunctionTwice(() => { a++ })
  a satisfies string
  

  (Playground)

  • Expected string, found 4

  (Playground)

  • Type 'number' does not satisfy the expected type '2'.
  • Type 'number' does not satisfy the expected type 'string'.

• Updates recognised inside of events

  let a: number = 2
  function runFunctionTwice(func: () => void): number {
      func()
      const b = a
      func()
      return b;
  }
  
  a satisfies 2
  const out = runFunctionTwice(() => { a++ });
  a satisfies 4
  out satisfies string
  

  (Playground)

  • Expected string, found 3

  (Playground)

  • Type 'number' does not satisfy the expected type '2'.
  • Type 'number' does not satisfy the expected type '4'.
  • Type 'number' does not satisfy the expected type 'string'.

• TDZ from free variable (across function)

  function getX() {
      return x
  }
  
  getX satisfies () => number;
  
  getX();
  
  let x: number = 5;
  

  (Playground)

  • Variable 'x' used before declaration

  (Playground)

• TDZ errors through nested getter

  function func(obj: { prop: number }) {
      return obj.prop
  }
  
  func({ get prop() { return b } });
  
  let b: number = 0;
  

  (Playground)

  • Variable 'b' used before declaration

  (Playground)

• Assignment to union

  let myObject: { a: number } = { a: 4 }
  
  function readA(someObject: { a: number | string }) {
      return someObject.a;
  }
  
  function setAtoString(someObject: { a: number | string }) {
      someObject.a = "hi";
  }
  
  // Allowed
  readA(myObject);
  setAtoString({ a: 6 });
  setAtoString(myObject);
  

  (Playground)

  • Invalid assignment through parameter

  (Playground)

• Property assignment from conditional

  function getObject(condition: boolean) {
      const mainObject = { a: 2 };
      const object = condition ? mainObject : { b: 3 };
      object.c = 4;
      mainObject.c satisfies string;
      return mainObject
  }
  

  (Playground)

  • Expected string, found 4

  (Playground)

  • Property 'c' does not exist on type '{ a: number; } | { b: number; }'.
  • Property 'c' does not exist on type '{ a: number; }'.

• Assigning to parameter observed via effect

  function add_property(obj: { prop: number }) {
      obj.prop += 2;
  }
  
  const obj = { prop: 4 };
  add_property(obj);
  obj.prop satisfies 8;
  

  (Playground)

  • Expected 8, found 6

  (Playground)

  • Type 'number' does not satisfy the expected type '8'.

• Functions create objects

  function newObject() {
      return { prop: 2 }
  }
  
  const a = newObject(), b = newObject();
  const c = a;
  (a === c) satisfies false;
  (a === b) satisfies string;
  

  (Playground)

  • Expected false, found true
  • Expected string, found false

  (Playground)

  • Type 'boolean' does not satisfy the expected type 'false'.
  • Type 'boolean' does not satisfy the expected type 'string'.

• Unconditional throw warning

  function safeDivide(num: number, denom: number) {
      if (denom === 0) {
          throw new Error("Cannot divide by zero");
      }
      return num / denom
  }
  
  function func() {
      safeDivide(8, 4) satisfies 2;
      // ahh
      safeDivide(10, 0);
  }
  

  (Playground)

  • Conditional '[Error] { message: "Cannot divide by zero" }' was thrown in function

  (Playground)

  • Type 'number' does not satisfy the expected type '2'.

• Unreachable statement

  function throwGreeting() {
      throw "Hello";
      return "Unreachable!"
  }
  
  function doSomething() {
      throwGreeting()
      const unreachable = 2;
  }
  

  (Playground)

  • Unreachable statement
  • Unreachable statement

  (Playground)

• throw short-circuit

  let x: number = 2;
  
  function func(cb: () => void) {
      try {
          cb();
          x = 10;
          return "not-thrown"
      } catch {
          return "thrown"
      }
  }
  
  func(() => { throw "error" }) satisfies "thrown";
  x satisfies string;
  

  (Playground)

  • Expected string, found 2

  (Playground)

  • Type '"not-thrown" | "thrown"' does not satisfy the expected type '"thrown"'.
  • Type 'number' does not satisfy the expected type 'string'.

• delete as an effect

  function dewete(param: { prop?: string }) {
      const { prop } = param;
      delete param.prop;
      return prop
  }
  
  const obj = { prop: "hi" };
  dewete(obj);
  
  obj.prop;
  

  (Playground)

  • No property 'prop' on {}

  (Playground)

• Optional effect key

  let i: number = 0;
  ({ a: true})?.[i++, "a"] satisfies true;
  i satisfies 1;
  
  null?.[i++, "a"];
  i satisfies string;
  

  (Playground)

  • Expression is always false
  • Expression is always true
  • Expected string, found 1

  (Playground)

  • Type 'boolean' does not satisfy the expected type 'true'.
  • Type 'number' does not satisfy the expected type '1'.
  • The value 'null' cannot be used here.
  • Type 'number' does not satisfy the expected type 'string'.

• Effects across functions

  let value: number = 2;
  function a() { value = 8; }
  function b() { a() }
  
  let func = () => {};
  
  function c() { b() }
  function d(newCb: () => void, then: () => void) { func = newCb; then() }
  
  value satisfies 2;
  d(a, c);
  value satisfies boolean;
  

  (Playground)

  • Expected boolean, found 8

  (Playground)

  • Type 'number' does not satisfy the expected type '2'.
  • Type 'number' does not satisfy the expected type 'boolean'.