Unions - only as constraints (like go) or everywhere (like ts)?

[emil14]

Consider this valid TS code:

function f(a, b number | string) {}
f("42", 42) 

It's impossible to do so in Go because

1. union can only be used as a constraint:
2. values of the same generic type must have same concrete type

type C interface { int | string }

func f[T C](a, b T) {}

// f("42", 42) // won't compile because compiler "can't infer type"
f(42, 42) // will compile, compiler infers `f[int]`

Let's look at that f("42", 42) line. It says compiler can't infer type because the type here would be f[int | string] and Go doesn't allow union to be used that way. You can't use union anywhere but inside interface that is used as a type constraint.

Go approach

Makes impossible situations like string + int. Go is a strong-typed language which means you must explicitly cast one type into another in such situations. Go does have operators that are builtin functions with predefined syntax. You won't find type declarations for them like you can for builtin functions like make or new but their behavior is described in the spec. Operator + e.g. works for both numeric types and strings but both arguments must be of the same type.

TS approach

On the other hand TypeScript is a superset of JS which is a weakly-typed language. You can sum numbers with strings and much more. That's why using unions everywhere makes sense. However, such implicit type casts works not everywhere. E.g. you can't - from string to number. This leads to situations like this:

function f(a, b number | string) {
  a - b // compile error
}
f("42", 42) 

You can probably do function f<T number | string>(a, b T) which shouldn't change anything here.

[emil14]

It's all about operators

At the lowest level message is passed to an operator. Operator can have type int|str. What will happen if we'll have messages of different types? Or with the same?

[emil14]

dupl of #407