Create a Cast utility type

[calebdwilliams]

Search Terms

Casting, type casting, functional type casting, cast, string as number, cast utility type

This is similar to #15048, but I think the proposal is different enough to warrant a new issue (if the community disagrees, I'm happy to close the issue).

Suggestion

This might not be a practical idea, but I'd love to see the inclusion of some sort of Cast type that takes a generic argument similar to Partial. So running Cast<number> would return things that can be generally cast as numbers.

Use Cases

I came across a need for this while developing a polyfill for the ElementInternals spec. As part of that specification there are ARIA properties to interact with an element's Accessibility Object Model, so things like ariaValueMax. Run the following code in Chrome and notice the last line yields a string.

class X extends HTMLElement {
  internals = this.attachInternals();
}
customElements.define('x-x', X);
let x = new X();
x.internals.ariaValueMax = 5000;
x.internals.ariaValueMax; // returns '5000'

Granted, this is bizarre behavior, but I was hoping there would be a way to accept 5000 | '5000', but not 'five thousand' as part of the type checking.

Examples

I would imagine this could be used like the following:

interface AriaValues {
  ariaValueMax: Cast<number>;
  ariaValueMin: Cast<number>;
  ariaValueNow: Cast<number>;
  ariaValueText: string;
}

Another trivial example would be a concatenate function where users might be able to concatenate different types together:

function concatenate(first: Cast<string>, last: Cast<string>): string {
  return first.toString() + last.toString();
}

Checklist

My suggestion meets these guidelines:

• 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, etc.)
• This feature would agree with the rest of TypeScript's Design Goals.

[RyanCavanaugh]

This would be #2521

[typescript-bot]

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

[calebdwilliams]

@RyanCavanaugh, I fail to see how this is a duplicate of #2521.

[RyanCavanaugh]

@calebdwilliams Maybe I'm misunderstanding what you want, since "a thing with toString" is already a thing you can describe ({ toString(): string })

[calebdwilliams]

I’m looking for something like a functional type that will allow both 4 and '4', if a variable can be effectively and logically cast from one type to another.

Again, based on how the DOM works, I might have an object like this

{
  ariaValue: string|number;
}

But for that particular property, the value 'foo' would be invalid. 42 or '42' could be equally valid based on how the DOM specifications work. I’d like something where I could indicate to the type system that anything castable from one type to another would be evaluated as valid.

[RyanCavanaugh]

There's nothing called "casting" in JS or TS, so I'm still not sure what you're going for. But anyway this doesn't really fit with something that's needed in a programming language, since if you are writing the string in code you should just write 42 instead of "42", whereas if you're taking the input as data you'd reasonably want to know when you're performing conversions, and TS wouldn't be able to know in the first place whether that data conformed to some schema like "Converts to a JS number that isn't NaN" or "Converts to a nonnegative integer" or "Converts to a number representable in 32 bit" or whatever specific kind of resultant "number" the target property accepts.