Infer "stringable" or "numerable" objects without explicit declaration

[nexusprime-here]

🔍 Search Terms

TypeScript infer toString valueOf type

TypeScript primitive coercion support

TypeScript object implicit conversion

TypeScript toString type inference

TypeScript valueOf type inference

TypeScript custom primitive type support

TypeScript implicit type conversion issue

TypeScript Symbol.toPrimitive inference

✅ Viability Checklist

• This wouldn't be a breaking change in existing TypeScript/JavaScript code
• This wouldn't change the runtime behavior of existing JavaScript code
• This could be implemented without emitting different JS based on the types of the expressions
• This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, new syntax sugar for JS, etc.)
• This isn't a request to add a new utility type: https://github.com/microsoft/TypeScript/wiki/No-New-Utility-Types
• This feature would agree with the rest of our Design Goals: https://github.com/Microsoft/TypeScript/wiki/TypeScript-Design-Goals

⭐ Suggestion

Allow the compiler to infer that objects with consistently implemented toString() or valueOf() methods can be used directly as string or number without requiring explicit conversion, like is on javascript.

Benefits:

• Reduces verbosity and the need for manual conversion.
• Improves developer experience when working with objects that can behave as primitives.

Thank you for your consideration!

📃 Motivating Example

Currently, TypeScript does not automatically infer that objects with custom toString() or valueOf() methods can be used as string or number. This forces developers to perform explicit conversions, which can make the code more verbose.

Example:

class MyObject {
  valueOf() {
    return true;
  }
}

const obj = new MyObject();
if (!obj) {...}  // invalid

💻 Use Cases

1. What do you want to use this for?
   I want TypeScript to infer when an object can behave as a string or number based on its toString() or valueOf() methods. This would allow objects with well-defined conversions to be used more naturally without requiring explicit casts or manual conversions.
2. What shortcomings exist with current approaches?
   Currently, TypeScript does not respect toString() or valueOf() for type inference. Even if an object defines these methods correctly, the compiler still treats it as its declared type rather than allowing implicit conversion. This leads to unnecessary type assertions or explicit calls, making the code more verbose.
3. What workarounds are you using in the meantime?

• Manually calling .toString() or .valueOf() when needed.
• Using type assertions (as string or as number), which can be unsafe.
• Wrapping objects in utility functions to handle conversions explicitly.

[MartinJohns]

Duplicate of #2361.

[typescript-bot]

This issue has been marked as "Duplicate" and has seen no recent activity. It has been automatically closed for house-keeping purposes.