Operator '+' cannot be applied to types 'T' and 'T'.

[Jameskmonger]

TypeScript Version: 2.1.1 / nightly (2.2.0-dev.201xxxxx)

Code

function add<T extends string | number>(x: T, y: T): T {
  return x + y;
}

add<string>("a", "b");
add<number>(5, 3);
add("a", "b");
add(5, 3);

Expected behavior:

Code to compile fine, because T is of type string | number and therefore can have the + operator applied.

Actual behavior:

Operator '+' cannot be applied to types 'T' and 'T'.

[arusakov]

Also doesn't work correctly for simple union type:

type X = number | string;

function add(a: X, b: X) {
    return a + b; // Error: Operator '+' cannot be applied to types 'X' and 'X'.
}

[DanielRosenwasser]

For those who want to tackle this, you might need to use getConstraintOfTypeParameter.

[arusakov]

@DanielRosenwasser

type U = string | number;
declare const x: U;
declare const y: U;
declare const s: string;
declare const n: number;

x + y; // resultType is U
x + s; // resultType is string
x + n; // resultType is U

Am I right?

[Jameskmonger]

@mhegazy I noticed that your comment in #13073 said this should be relaxed for x + y when x and y are both string | number, but I'm not sure that aligns correctly with the behaviour in Chrome.

function SomeClass (val) {
    this.val = val;
}

SomeClass.prototype.toString = function () {
    return `value [${this.val}]`;
};

var x = new SomeClass(3);

var z = (x + x);
console.log(z); // "value [3]value [3]"

[mhegazy]

looking at this again, i do not think this is as simple as i originally thought. we need to talk about the new rules for the operator.

[DanielRosenwasser]

type U = string | number;
declare const x: U;
declare const y: U;
declare const s: string;
declare const n: number;

x + y; // resultType is U
x + s; // resultType is string
x + n; // resultType is U

@arusakov To expand that out:

x + y; // resultType is `string | number`
x + s; // resultType is `string`
x + n; // resultType is `string | number`

that looks correct. However, if U was a type parameter whose constraint was string | number, I don't think necessarily think U would stick around.

[mhegazy]

what about U + T where both are constrained to string | number.

[Jameskmonger]

I think it should be string | number | T where T is any object with a toString method.

[DanielRosenwasser]

You don't know specifically whether each was a number or a string - so it sounds like that would become string | number unless you wanted to create a delayed type construct like T + U which only flattens when it has concrete types on both sides, but I think that seems a little overboard.

[RyanCavanaugh]

Accepting PRs for the rules:

• T + T where T is constrained to string should return string (not T)
• T + T where T is constrained to number should return number (not T)
• Same rule above applies for all the other math binary and unary operators

T + T where T extends string | number is still disallowed -- we don't feel this is a good use case because whether you get concatenation or addition is not predictable, thus something that people shouldn't be doing.

[Jameskmonger]

@RyanCavanaugh surely if T extends string | number and you perform T + T you will either be doing string + string or number + number depending on the value of T, thus making it predictable?

For example in my example I know that whatever I use as the generic type T will be the basis for the + operator's behaviour.

[RyanCavanaugh]

@Jameskmonger if T extends string | number then T can be string | number which means one value of type T can be string a different value of type T can be a number.

It really sounds like you should use overloads here rather than a type parameter.

[Jameskmonger]

Ah of course @RyanCavanaugh - I was misunderstanding how generic types work with union types. Thanks for explaining 😄

[jack-williams]

Can this be closed? I think the rules @RyanCavanaugh gave are currently satisfied:

function addString<T extends string>(x: T, y: T): string {
  return x + y;
}

function addNum<T extends number>(x: T, y: T): number {
  let a = x * y;
  let b = x - y;
  let z = x++;
  return x + y;
}

addString("a", "b");
addNum(1, 2);

Playground

[mhegazy]

thanks!