Link types in union with type in union of type guard

[Fryuni]

Suggestion

🔍 Search Terms

union of type guards
type guard union
list of type guards

✅ Viability 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 (but would allow removing workarounds)
• 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 feature would agree with the rest of TypeScript's Design Goals.

⭐ Suggestion

Link the type of a type guard within a union with the type of the element, so they can be used with each other, even though narrowing is not possible.

📃 Motivating Example

type Foo = {foo: string};
type Bar = {bar: number};

type WorkTypes = Foo | Bar;

type GuardedWorker<All, T extends All> = {
  guard: (value: All) => value is T,
  process: (value: T) => void
};

type GuardedWorkers = GuardedWorker<WorkTypes, Foo> | GuardedWorker<WorkTypes, Bar>;

function doWork<T extends WorkTypes>(workers: GuardedWorkers[], value: T) {
  for (const worker of workers) {
    if (worker.guard(value)) {
      // worker is still a union and value is still T since this can't narrow the type
      // but TS knows thy are of the same Work type, whatever it is. So this works.
      worker.process(value);
    }
  }
}

💻 Use Cases

The example above is a simplification of a real word example where this would be used.

Currently, we need to do a casting like this the example to work:

function doWork<T extends WorkTypes>(workers: GuardedWorkers[], value: T) {
  for (const worker of workers) {
    if (worker.guard(value)) {
      const narrowedWorker = worker as unknown as GuardedWorker<WorkTypes, T>;

      narrowedWorker.process(value);
    }
  }
}

In our real use case, we don't need the unknown because the type containing the guard is generic a string literal, and that doesn't cause a conflict. This is the real world use case that prompted this feature request:

export function resolveNode<T extends NodeTypeNames>(id: IdOfNode<T>): NodeSource<T> {
    for (const [prefix, resolution] of Object.entries(nodeResolutionMap)) {
        if (resolution.idTest(id)) {
            // TS don't narrow the type guard itself, so we need to cast the resolution.
            const typedResolution = resolution as NodeResolution<T>;

            // Do a bunch of things to validate the ID

            const node = resolution.nodeResolver(id)

            // Do a bunch of things to validate the Node

            return node;
        }
    }

    throw new Error('Unsupported ID type.');
}

[RyanCavanaugh]

There's not really a sound way of doing this without creating an entirely new kind of narrowing. From TypeScript's perspective, there's not a difference between the provided code (which is OK by construction) and this code, which is broken:

function doWork<T extends WorkTypes>(workers: GuardedWorkers[], value: T) {
  const worker1 = workers[0];
  const worker2 = workers[1];
  if (worker1.guard(value)) {
    worker2.process(value); // Unsound call
  }
}
declare const gwFoo: GuardedWorker<WorkTypes, Foo>;
declare const gwBar: GuardedWorker<WorkTypes, Bar>;
doWork([gwFoo, gwBar], { foo: "" }); // Fails

So it's not enough / not correct to narrow T, it has to be a narrowing in the context of a particular value. We haven't needed anything like that yet, and even if we had it, it wouldn't really be usable on mutable bindings like worker anyway.

[jcalz]

Seems like another instance of #30581. If so, then the approach described in #47109 works here also, with the introduction of a helper mapping type, like this:

interface WorkMapper {
    foo: Foo;
    bar: Bar;
}

type GuardedWorkers<K extends keyof WorkMapper> =
    { [P in K]: GuardedWorker<WorkTypes, WorkMapper[P]> }[K];

function doWork<K extends keyof WorkMapper>(workers: GuardedWorkers<K>[], value: WorkTypes) {
    for (const worker of workers) {
        if (worker.guard(value)) {
            worker.process(value); // okay
        }
    }
}

declare const gwFoo: GuardedWorker<WorkTypes, Foo>;
declare const gwBar: GuardedWorker<WorkTypes, Bar>;
doWork([gwFoo, gwBar], { foo: "" });

Playground link

It's also something that existential types would help ( #14466 ) and the various emulations of existential types also apply (with various runtime refactorings if you want type safety)

const someGuardedWorker = <A, T extends A>(worker: GuardedWorker<A, T>) =>
    (value: A) => { if (worker.guard(value)) worker.process(value) }

type SomeGuardedWorker = (value: WorkTypes) => void

function doWork(workers: SomeGuardedWorker[], value: WorkTypes) {
    for (const worker of workers) {
        worker(value)
    }
}

declare const gwFoo: GuardedWorker<WorkTypes, Foo>;
declare const gwBar: GuardedWorker<WorkTypes, Bar>;
doWork([someGuardedWorker(gwFoo), someGuardedWorker(gwBar)], { foo: "" })

Playground link to code

[Fryuni]

So if the workers themselves were to take the generic parameter and not the value it would work? I'll try that, thanks.

[typescript-bot]

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