Is it possible to extract parts of a larger type into subtypes?

Question

It's trivial if you have 3 subtypes to put them together into one large one:

type Strings = {
  a: string;
  b: string;
  c: string;
  ...
};
type Numbers = {
  one: number;
  two: number;
  ...
};
type Booleans = {
  True: boolean;
  ...
};
type All = Strings & Numbers & Booleans;

but what if you start with the combined Type?

type All = {
  a: string;
  b: string;
  c: string;
  one: number; 
  two: number;
  True: boolean;
  ...
}

Is it possible to split All into the 3 sub types above based on the type of the values for each key?

I thought maybe this could work but it does not

type noNumbers= Exclude<All, { [key: string]: number }>;

TSplayground

This is neat and all, but is there some pressing reason you can't just refactor the code? — Jared Smith, Mar 10 '20 at 18:03
The type comes from a Library, it's big and Its a general question about the possibility of arbitrarily grouping a type. — lonewarrior556, Mar 10 '20 at 18:30
You want [Pick](https://www.typescriptlang.org/docs/handbook/utility-types.html#picktk) — Jared Smith, Mar 10 '20 at 19:44

score 1 · Accepted Answer · answered Mar 10 '20 at 21:58

We can make custom type level function in order to achieve or omitting by value type or picking by value type. Below both options:

// picks given values
type PickByValue<T, V, _Keys extends keyof T = {
  [K in keyof T]: T[K] extends V ? K : never
}[keyof T]> = Pick<T, _Keys>

type Numbers = PickByValue<All, number>
type Strings = PickByValue<All, string>

// omits given values
type OmitByValue<T, V, _Keys extends keyof T = {
  [K in keyof T]: T[K] extends V ? K : never
}[keyof T]> = Omit<T, _Keys>

type Bools = OmitByValue<All, number | string>

The key to the success is how union type treads never, its neutral element for | operator, it means it is just skipped and has no impact at the type. Consider small proove:

type X = 'a' | never | 'b' // evaluates to just 'a' | 'b'

Thanks to that we can use never in order to skip some keys. That is exactly visible in this part:

{
  [K in keyof T]: T[K] extends V ? K : never
}[keyof T]

What is happening exactly is - we create mapped type with values equal keys, but only if the value type is ok, if not we use never, and after that we take these values by index [keyof T]. Lets recap step by step what is happening:

mapped type makes mapped type key-> (key | never)
[keyof T] gathers all value type as union (and never elements are not considered)
we now have all keys which were not skipped by never
we use these keys in utility type Pick or Omit

score 0 · Answer 2 · answered Mar 10 '20 at 18:39

Not sure if there's an easier or better way but this works.

type PickOut<T, K> = {
    [P in keyof T]: T[P] extends K ? P : never
}[keyof T]

type NumberKeys = PickOut<All, number>
type BooleanKeys = PickOut<All, boolean>
type StringKeys = PickOut<All, string>

type justNumbers = Pick<All, NumberKeys>
type justBooleans = Pick<All, BooleanKeys >
type justStrings = Pick<All, StringKeys >

TSplayground

Is it possible to extract parts of a larger type into subtypes?

2 Answers2