typescript interface unsoundness wat

typescript-interface-wat.ts

import test from "node:test";
import assert from "node:assert";

interface IExperiment {
  foo(opts: {}): void;
}

class Experiment implements IExperiment {
  // Wat?!
  // Why is Experiment allowed to implement IExperiment (the typechecker doesn't complain)
  // even though IExperiment.foo doesn't guarantee that opts.bar is defined?
  
  foo(opts: { bar: string }): void {
    // foo needs opts.bar to be there
    assert.ok(opts.bar);
  }
}

test.only("experiment", async () => {
  const experiment = new Experiment();
  experiment.foo({ bar: "baz" });
});

test.only("experiment 2", async () => {
  let experiment: IExperiment;
  experiment = new Experiment();
  experiment.foo({}); // oops, we called foo without passing bar, causing a runtime error
});

/*
How do I change the code so that I can be sure that every class that implements IExperiment
is safe to use with through the interface?
*/

https://github.com/Microsoft/TypeScript/wiki/FAQ#why-are-function-parameters-bivariant

microsoft/TypeScript#46999

https://www.typescriptlang.org/docs/handbook/type-compatibility.html#comparing-two-functions

https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-6.html#note

https://www.totaltypescript.com/method-shorthand-syntax-considered-harmful

Ok, so the solution is (and would've never expected this) a subtle change in the interface declaration:

❌ This uses method shorthand syntax and is liable to lead to unsoundness

interface IExperiment {
  foo(opts: {}): void;
}

✅ This uses object property syntax and doesn't allow methods with narrower param types to implement the interface:

interface IExperiment {
  foo = (opts: {}) => void;
}

A subtle change makes a big difference in the type checks!

Thanks to Matt Pollock for pointing me in the right direction https://bsky.app/profile/mattpocock.com