Cannot extract base type from branded intersection

[shkumbinhasani]

Problem

I use a branded intersection to mark thrown error types and want to strip the brand to recover the base type.

Repro

const errorSymbol: unique symbol = Symbol();
type Throws<E extends Error> = { [errorSymbol]?: E };

type StripThrows<T> = T extends infer R & Throws<any> ? R : T;

type Result = StripThrows<string & Throws<Error>>;

Expected

Result is string.

Actual

Result is string & Throws<Error>.

Use case

This is for a tryCatch helper that returns [data, error] where error includes declared thrown types and data is the base value type. Without stripping the brand, the data side stays intersected.

Version

TypeScript 5.7.2

Question / Request

Is there a supported way to infer the non-branded part of an intersection? If not, could TypeScript provide a utility or type operator for intersection subtraction or for inferring intersection remainders?

[mkantor]

If you use Error (E's constraint) instead of any then you get the behavior you want. I don't immediately know why any doesn't work there.

[shkumbinhasani]

I noticed it still breaks down once the thrown type is a specific error subtype though. Here’s what I’m seeing:

interface User { name: string }

const errorSymbol: unique symbol = Symbol();

class APIError extends Error {
  status = 300;
}

type Throws<E extends Error> = { [errorSymbol]?: E };

type StripThrows<T> = T extends infer R & Throws<Error> ? R : T;

type Result  = StripThrows<User & Throws<Error>>;     // ✅ User
type Result2 = StripThrows<User & Throws<APIError>>;  // ❌ User & Throws<APIError>

So Throws strips nicely, but Throws doesn’t and it seems related to APIError having an instance field (status = 300). If I remove that field, the behavior changes.

Do you know if this is just a limitation of how infer works with intersections (i.e. it can’t reliably infer the “remainder” of T & Brand when the brand is more specific), or is there a supported pattern for “subtracting” an intersection like this?

Typescript playground

[RyanCavanaugh]

Reverse inference from an intersection is not a well-defined operation in a structural type system. The closest you could reasonably get would be this:

// "good" omit
type Omit2<T, DroppedKeys extends PropertyKey> = {
    [K in keyof T as Exclude<K, DroppedKeys>]: T[K];
};
type StripThrows<T> = Omit2<T, typeof errorSymbol>;

type Result  = StripThrows<User & Throws<Error>>;     // ✅ User, structurally
type Result2 = StripThrows<User & Throws<APIError>>;  // ✅ User, structurally

[jcalz]

Looks like #54213 and #57918.

It sounds like some people want an Omit that works on branded primitives, so that MyOmit<"abc" & { x: 0 }, "x"> gives you "abc" and not the steaming entrails of the String interface. I don't think anything currently works like that (and if it does it's probably not supported). Maybe someone should file this as a feature request for the use cases they have, not as bug reports about functionality they wish behaved otherwise?