[krosaen]

I don’t understand the benefit of nominal typing when structural typing is available?

[nine_k]

The idea is that two types with the same structure aren't always the same thing.

This is easily solved by a tagged type in TS [1], though a bit of syntactic sugar over it would be nice.

[1]: https://kubyshkin.name/posts/newtype-in-typescript/

[gherkinnn]

In practice I’m very happy with structural types. It provides all the safety I could wish for and slots in well with the underlying language and broader ecosystem.

Though I do miss an easy way to create something like a type Email of string, as it conforms to a set of rules. But that’s a small price to pay.

[mirekrusin]

Flow has structural typing on types and nominal on classes with correct inheritance semantics, which simply makes sense.

For making Email type distinct from string, you want opaque type (first class in flow) which you can emulate as tagged type in ts.

[gherkinnn]

Oh! Interesting. I was unaware of Flow’s details. Though I never program in an OOP style so I wouldn’t have noticed those nuances anyway.

I know of TS’ opaque types, but it always feels dirty. So here I am, relying on named params instead.

[mirekrusin]

Tagging doesn't solve inheritance problems - object oriented inheritance needs to follow liskov substitution principles, support variance correctly.

Tagging is good for making sum types out of union types, but that's not enough for class inheritance.

Flow does it better by having first class opaque type aliases btw (and having nominal types with oo inheritance support on classes of course).

[mirekrusin]

You can't use `instanceof` ie. for your error types, actually every time you use class that extends something - it'll not be typed correctly. Basically nothing OO/class/inheritance related is typed correctly. Flow does it correctly.