Custom syntax for distributive conditional

[yarden-app]

🔍 Search Terms

Distributive conditional, large type with numerous(10,20+) union types limitation, union type aggregation

✅ Viability Checklist

• 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, new syntax sugar for JS, etc.)
• This isn't a request to add a new utility type: https://github.com/microsoft/TypeScript/wiki/No-New-Utility-Types
• This feature would agree with the rest of our Design Goals: https://github.com/Microsoft/TypeScript/wiki/TypeScript-Design-Goals

⭐ Suggestion

My suggestion is to improve the current syntax of the awesome 'distributive conditional' feature.
This feature is pretty much hidden due to the verbosity required to use it and the inability to reason with the syntax.

My example may show an idea for how a syntax may look, it isn't covering everything (like for example the scope of distribution like T extends {SCOPE}, typically 'any')

📃 Motivating Example

type A = {
  A1: {
    Type: "type.1";
    Sub: {
      Type: "type.1.sub.1" | "type.1.sub.2"
    };
  };
  A2: {
    Type: "type.2";
    Sub: {
      Type: "type.2.sub.1" | "type.2.sub.2"
    };
  }
}

// With generics it is simple
export namespace generic_example {
  type B<MainType extends A[keyof A]["Type"]> = {
    MainType: MainType;
    SubType: (A[keyof A] & {Type: MainType})["Sub"]["Type"]
  };

  // Results in a safe type when given a single type
  const b:B<"type.1"> = {
    MainType: "type.1",
    SubType: "type.1.sub.1"
  }
}

// Just a demonstration of a generally invalid example
export namespace invalid_example {
  type B = {
    MainType: A[keyof A]["Type"];
    SubType: A[keyof A]["Sub"]["Type"]
  };

  // As expected, there are no type error, even though type.1.sub.1 is not part of type.2
  const b:B = {
    MainType: "type.2",
    SubType: "type.1.sub.1"
  }
}

// With distributive conditional
export namespace wild_syntax_example {
  type theUnion = A[keyof A];

  type B = theUnion extends infer U ? U extends {Type: any; Sub: {
    Type: any
  }} ? {
    MainType: U["Type"];
    SubType: U["Sub"]["Type"]
  } : never : never;

  const b:B = {
    MainType: "type.1",
    SubType: "type.1.sub.1"
  }

  const b_invalid:B = { //<-- Correctly guards the type, but can you really work like this?
    MainType: "type.2",
    SubType: "type.1.sub.1"
  }
}

// Some ideas for syntax that can simplify it
export namespace suggested_syntax {
  // You wont have access to the main A anymore but adding optional alias can solve it like A.<A_DISTRIBUTED>{}
  type Syntax1 = A.{
    MainType: A["Type"];
    SubType: A["Sub"]["Type"];
  }

  // Similar to destructure which could fit here nicely
  type Syntax2 = {
    ...A {
      Type,
        Sub: {
          Type
      }
    }
  }
}

💻 Use Cases

1. What do you want to use this for?
   I think this is a missing/hidden piece in typescript and should be added as soon as possible. Please let me know if you think otherwise.
2. What shortcomings exist with current approaches?
   Long, easy to forget, super messy syntax for very "simple" things ( at least in most of my use cases )

🍭 Bonus addition

1. Optionally, add the option to specify something like proprietaryDistributiveConditional=true in tsconfig to allow to disable the current distributive conditional syntax so it is possible to use statements like T extends Union without distributing it.

[DanielRosenwasser]

Are you asking for some way for generic_example.B to distribute on union inputs types instead of using a conditional type?

[RyanCavanaugh]

Duplicate #43694, I think?

[yarden-app]

@DanielRosenwasser
You can look at the 'wild_syntax_example' namespace, it is what I want to achieve with a simpler syntax.

@RyanCavanaugh
I think it is similar, both threads look for way to make distributive conditional easier to work with.
The linked issue seem to talk about creating iterator syntax(like 'for') but I think it is a bit out of scope from what I am suggesting which is simplifying the
<LocalType> extends <ReductionScope> ? <LocalType 'magically' distributing over ReductionScope> : never

[DanielRosenwasser]

But what is specifically being suggested? What triggers the distribution?

Sorry if I am missing something, but there's a lot of code in the example you gave, but it's not clear what the exact before/after is to me.

[yarden-app]

I'll try to provide a shorter example:

1. I have the following type, and I want to extract a new type based on it which is based one of union members' ${Type}.${Sub["Type"]}

type Type1 = {
    Type: "type.1";
    Sub: {
      Type: "type.1.sub.1" | "type.1.sub.2"
    };
  }
type Type2 = {
    Type: "type.2";
    Sub: {
      Type: "type.2.sub.1" | "type.2.sub.2"
    };
 }

type Union = Type1 | Type2

2. I only have access to Union currently. I cannot refer to individual union members.
3. Typically I would use distributive conditional syntax:

 type Result = Union extends infer U ? U extends {Type: any; Sub: {
    Type: any
  }} ? `${U["Type"]}.${U["Sub"]["Type"]}` : never : never;

4. This is really hard to use, and I recommend a new syntax for this purpose. I dont have exact idea for one.

do you think this makes sense? I understand the distribution trigger can be more complex but I think the simple case when you just extend 'any's, can and should be simple to write.

also the mixture of syntax of distributive conditional is confusing when you just want conditional type without distribution.
thats why if a new syntax is present, it would be possible to disable the older distributive conditional syntax.

I feel like it is guaranteed that a solution for this will be available someday, its just a matter of time

[yarden-app]

Maybe

`${Type}.${Sub["Type"]}` from A {
    Type: any;
    Sub: {
          Type: any;
    }
};

Or

 `${Result["Type"]}.${Result["Sub"]["Type"]}`  from A {
    ...OtherStuff; // Unrelated, but can be helpful for people having issue with omit for example
    WithoutSpecifyingAny; // The game changer? it wouldnt distribute and not cause confusion
    Type: any;
    Sub: {
          Type: any; 
    }
} as Result;

[mkantor]

@yarden-app not sure if you'll find this easier, but FWIW you could also use a mapped type to generate Result:

type Result = {
  [T in Union as T["Type"]]: `${T["Type"]}.${T["Sub"]["Type"]}`
}[Union["Type"]]

[mkantor]

I think it is similar [to #43694], both threads look for way to make distributive conditional easier to work with. The linked issue seem to talk about creating iterator syntax(like 'for') but I think it is a bit out of scope from what I am suggesting which is simplifying the <LocalType> extends <ReductionScope> ? <LocalType 'magically' distributing over ReductionScope> : never

Reading #43694, it doesn't seem married to specific syntax (e.g. it says "I'm not happy with any of the ideas I have for the syntax but hopefully you can see what I'm going for") and to me it sounds spiritually the same as what you want (e.g. it's summed up as "The expression T extends T ? /* something */ : never is silly enough that I feel it justifies creating a keyword", which sounds like it mirrors your perspective).

[yarden-app]

@yarden-app not sure if you'll find this easier, but FWIW you could also use a mapped type to generate Result:

type Result = {
[T in Union as T["Type"]]: ${T["Type"]}.${T["Sub"]["Type"]}
}[Union["Type"]]

Thank you for the example, its a great one and seem to avoid the conditional clause when you want to distribute over a single property, which is usually what I need.

I think it is similar [to #43694], both threads look for way to make distributive conditional easier to work with. The linked issue seem to talk about creating iterator syntax(like 'for') but I think it is a bit out of scope from what I am suggesting which is simplifying the <LocalType> extends <ReductionScope> ? <LocalType 'magically' distributing over ReductionScope> : never

Reading #43694, it doesn't seem married to specific syntax (e.g. it says "I'm not happy with any of the ideas I have for the syntax but hopefully you can see what I'm going for") and to me it sounds spiritually the same as what you want (e.g. it's summed up as "The expression T extends T ? /* something */ : never is silly enough that I feel it justifies creating a keyword", which sounds like it mirrors your perspective).

Yeah you are right, however I have small addition to your summary:
"The expression T extends T ? /* something */ : never is silly enough that I feel it justifies creating a keyword, and sometimes it gets in the way, having proprietary syntax can allow to disable it"

But why disable it? Because sometime you just want to check conditional type,
Even though usually the distribution will not interfere with your type, it may cause a Typescript error that I encountered, "Union is too big to represent" which is almost unsolvable.