Support inferred string-modified union types

I ran into an interesting situation that I wanted to run by the community to see if there's a way to add a new feature into TypeScript to support. I'll grant that it's an edge-case, but it seems like something that could be kind of neat.

Here's the code:

Code

// From Library 1
type status = "success" | "error" | "warning" | "info";

// From Library 2
type statusColor = "success" | "success-dark" | "error" | "error-dark" | "warning" | "warning-dark" | "info" | "info-dark";

// My library
function getColorFromStatus(status: status): statusColor {

    // ideal case: doesn't work:
    return status + "-dark";    // Error TS2322	Type 'string' is not assignable to type 'statusColor'

    // compromise: compiles but not type-safe. Changes to "status" type won't be caught.
    return status + "-dark" as statusColor;

    // safe case: works but extra code + runtime penalty:
    switch (status) {
        case "success": return "success-dark";
        case "error": return "error-dark";
        case "warning": return "warning-dark";
        case "info": return "info-dark";
    }
}

I think it would be neat if the expression:

status + "-dark"

could be automatically inferred to be of type:

"success-dark" | "error-dark" | "warning-dark" | "info-dark";

It's probably a lot more complex than it seems. And there's probably a heck of a lot of issues dealing with what happens with other string operations or if a runtime function like .toUpperCase() is called on the string, and what happens if any item in the union isn't a string, etc, etc. But still.

Any thoughts?

I believe this is roughly the same idea as proposed in #16746 (comment)

I think it is a great idea, but might be highly complex.

I would say it is not an edge case because, if generalized somewhat, it could allow for something like (syntax is just something I made up)

interface Outer {
  details: Inner
}
interface Inner {
  name: string;
}

type Delimiter = ".";

type DeepKey<T, OKey extends keyof T, IKey extends keyof T[OKey]> = OKey + Delimiter + IKey;

function pick<T, OKey extends keyof T, IKey extends keyof T[OKey]>(o: T, key: DeepKey<T, OKey, IKey>) {
  const [outer, inner] = key.split(".");
  return o[outer][inner];
}

declare const o: Outer;

const name = pick(o, "details" + "." + "name");

Another related issue #12940.

As well as #12754

We'd either have to invent a completely new kind of type (a deferred-expansion union), which would be a ton of work, or risk people accidently creating combinatorially explosive literal types. This doesn't seem to come up often enough to warrant either scenario.

Navigation Menu

Repository navigation

Support inferred string-modified union types #17512

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Support inferred string-modified union types #17512

Description

Activity

aluanhaddad commented on Jul 30, 2017

gcnew commented on Jul 30, 2017

DanielRosenwasser commented on Aug 2, 2017

RyanCavanaugh commented on Oct 10, 2017

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions