TS's type system is really freaking good.

It's support for Generics is really good, leagues above Java's one for example. Probably out of necessity because TS is intended to allow all the things that you can do in JS but in a type-safe manner, and JS being dynamically typed allows for a lot of things.

The type-inference is crazy good as well, so you get a lot of safety with not a lot of type annotations. Sometimes, type-safe code in TS (with noImplicitAny enabled) is literally the same as what you would write in JS.

For example:

[1, 2, 3].map(x => `cool ${x}`)
// [1, 2, 3] inferred as number[]
// x inferred as number
// whole expression inferred as string[]

I think only Haskell and Rust have more sophisticated type inference.

However, not even Haskell and Rust have proper union types. In TS you can do null-safe programming without banning null/undefined. And you don't have to use wrappers like Maybe or Option to achieve it. For more details on why solving null-safe programming with those wrappers is not ideal, check this talk.

(Null-safe programming using Maybe/Option is still preferable to not doing null-safe programming at all so please Java people keep the transition to Option<T>, and C++ people please keep using std::optional<T>).

The problems mentioned in the talk, such as not being able to relax an interface by making optional a function parameter, or not being able to strengthen your promise by removing optional from the return type (because it breaks callers) are non-issues in TS thanks to proper union types.

TS also has structural typing (as opposed to nominal typing), which allows for easier extension of libraries, and for library authors not needing to defensively create an ISomething for every class just to allow extensibility.

In short, TS's type system is among the best you can find out there. Thanks for coming to my TED talk.