Building Blocks for Dynamic Data Structures: Distributed Conditional Types

In TypeScript, we often need to create types that dynamically adjust based on certain conditions. While conditional types are powerful, applying them to union types directly can lead to unexpected results because the condition is evaluated on the entire union rather than each member individually. This challenge focuses on leveraging distributed conditional types to precisely control how transformations are applied to individual members of a union.

Problem Description

Your task is to implement a TypeScript utility type called DistributeConditional that takes a union type T and a conditional type C. This utility type should apply the conditional type C to each member of the union T individually, and then recombine the results into a new union.

Key Requirements:

1. Distribution: The core functionality is to ensure the conditional logic within C is applied to each constituent type of the union T.
2. Recombination: The results of applying the conditional logic to each member of T should be collected and formed into a new union type.
3. Generic Constraints: The utility type should be generic enough to handle various types for T and C.

Expected Behavior:

When DistributeConditional<T, C> is used, and T is a union (e.g., A | B | C), the conditional type C (which itself is a conditional type like X extends Y ? TrueType : FalseType) should be evaluated for A, B, and C separately. The final result should be a union of the outcomes for each individual type.

Edge Cases to Consider:

• What happens if T is not a union (e.g., a single type)?
• How does the type handle complex conditional types for C?

Examples

Example 1: Basic String/Number Transformation

Let's define a conditional type TransformStringOrNumber<U> that transforms strings into Uppercase<U> and leaves numbers as they are.

// Helper conditional type to demonstrate the distribution effect
type TransformStringOrNumber<U> = U extends string ? Uppercase<U> : U;

// Input Union Type
type MyUnion = "hello" | 123 | "world";

// Applying the standard conditional type directly
type DirectApplication = TransformStringOrNumber<MyUnion>;
// Expected: "HELLO" | 123 | "WORLD" (This is the desired outcome, but it needs to be achieved correctly)

// Applying our target utility type (which we will implement)
type DistributedResult = DistributeConditional<MyUnion, TransformStringOrNumber<any>>; // C needs to be a *template* for the conditional

// Let's refine the problem: C should be a *conditional type constructor*, not an instantiated conditional type.
// A better way to represent C for the problem is a conditional type that *takes* a type parameter.
// For example: type MyConditional<T> = T extends string ? Uppercase<T> : T;

// Corrected approach for the problem:
// DistributeConditional<UnionType, ConditionalTypeConstructor>

type TransformConditional<T> = T extends string ? Uppercase<T> : T;

// Input Union Type
type MyUnion = "hello" | 123 | "world";

// Our target utility type will be used like this:
// type DistributedResult = DistributeConditional<MyUnion, TransformConditional>;

// Expected Output:
// "HELLO" | 123 | "WORLD"

Explanation:

The TransformConditional type, when applied to "hello", yields "HELLO". When applied to 123, it yields 123. When applied to "world", it yields "WORLD". The DistributeConditional type should take these individual results ("HELLO", 123, "WORLD") and combine them into a union.

Example 2: Filtering Union Members

Consider a conditional type that keeps only string types.

// Conditional type constructor
type KeepStrings<T> = T extends string ? T : never;

// Input Union Type
type MixedData = string | number | boolean | { name: string };

// Applying our target utility type
// type FilteredResult = DistributeConditional<MixedData, KeepStrings>;

// Expected Output:
// string

Explanation:

KeepStrings applied to string yields string. KeepStrings applied to number yields never. KeepStrings applied to boolean yields never. KeepStrings applied to { name: string } yields never. The union of string | never | never | never simplifies to string.

Example 3: Handling Non-Union Types

// Conditional type constructor
type DoubleIfNumber<T> = T extends number ? T * 2 : T;

// Input Type (not a union)
type SingleType = number;

// Applying our target utility type
// type SingleResult = DistributeConditional<SingleType, DoubleIfNumber>;

// Expected Output:
// number (This is ambiguous without the actual value, but conceptually it means the type *could* become a doubled number. For type challenges, we focus on type manipulation.)
// Let's refine this to show a specific outcome. If DoubleIfNumber<5> is 10, then for type 5, the result should be related to 10.
// For the *type challenge*, if the input is `5`, the output type should reflect the conditional application.

// A better example for a non-union type:
type IncrementIfEven<T> = T extends number ? (T % 2 === 0 ? T + 1 : T) : T;

type InputNumber = 4;
// type IncrementedResult = DistributeConditional<InputNumber, IncrementIfEven>;
// Expected Output: 5

type InputString = "test";
// type IncrementedStringResult = DistributeConditional<InputString, IncrementIfEven>;
// Expected Output: "test"

Explanation:

When the input type T to DistributeConditional is not a union, the conditional type C should be applied directly to T. For InputNumber = 4, IncrementIfEven<4> evaluates to 5. For InputString = "test", IncrementIfEven<"test"> evaluates to "test".

Constraints

• T can be any valid TypeScript type, including union types, primitive types, object types, etc.
• C must be a conditional type constructor. This means it should be defined as a generic type with at least one type parameter that is subject to a conditional check (e.g., type MyConditional<X> = X extends ... ? ... : ...).
• The solution should be purely a type-level operation; no runtime code is required.
• The solution should handle the distribution of conditional types correctly for unions of up to 100 members without significant compilation time degradation.

Notes

The key to solving this challenge lies in understanding how TypeScript distributes conditional types over unions. When a conditional type A extends B ? C : D is applied to a union type X | Y | Z, it is automatically distributed such that it's equivalent to (A extends B ? C : D<X>) | (A extends B ? C : D<Y>) | (A extends B ? C : D<Z>).

Your task is to replicate this distributive behavior for a given conditional type constructor C applied to a union type T.

Consider how you can use mapped types or other advanced type manipulation techniques to achieve this. Think about how to "unwrap" the union T into its constituent parts, apply the conditional type C to each part, and then "rewrap" the results into a new union.