Advanced TypeScript: Implementing a Replace Utility Type

In TypeScript, utility types are powerful tools for manipulating existing types to create new ones. This challenge focuses on creating a custom utility type that can intelligently replace a specific type within another type with a new type. This is a common operation when refactoring code, adapting interfaces, or creating more flexible type definitions.

Problem Description

Your task is to create a TypeScript utility type named Replace<T, U, V>. This type should take three type arguments:

1. T: The original type from which we will be replacing.
2. U: The type to be replaced within T.
3. V: The new type that will replace U.

The Replace type should recursively traverse T and, whenever it encounters a type that is assignable to U, it should replace it with V. This replacement should occur for all properties within object types, elements within array types, and members within union types.

Key Requirements:

• The utility type must be named Replace.
• It must accept three generic type parameters: T, U, and V.
• It should handle object types, array types, and primitive types.
• If T is assignable to U, it should be replaced by V. This is the base case for recursion.
• For object types, it should iterate through properties and recursively apply Replace to their types.
• For array types, it should recursively apply Replace to the element type.
• For union types, it should apply Replace to each member of the union and then reconstruct the union.
• For intersection types, it should recursively apply Replace to each member of the intersection and reconstruct the intersection.
• If a type is not assignable to U and is not a composite type (object, array, union, intersection), it should remain unchanged.

Expected Behavior:

• Replace<string, string, number> should result in number.
• Replace<{ a: string; b: number }, string, boolean> should result in { a: boolean; b: number }.
• Replace<string[] | number, string, boolean> should result in boolean[] | number.
• Replace<{ c: Array<string | number> }, string, null> should result in { c: Array<null | number> }.

Edge Cases to Consider:

• What happens when T itself is assignable to U?
• How are nested structures (objects within objects, arrays within objects, etc.) handled?
• How are union types composed with other types handled?
• What about intersection types?

Examples

Example 1:

// Input Type
type OriginalType1 = {
  name: string;
  age: number;
  address: {
    street: string;
    city: string;
  };
};

type FindType1 = string;
type ReplaceWithType1 = boolean;

// Expected Output Type
type ResultType1 = Replace<OriginalType1, FindType1, ReplaceWithType1>;
// Expected: { name: boolean; age: number; address: { street: boolean; city: boolean; } }

Explanation: The Replace type iterates through OriginalType1. Properties name and address.street, address.city are of type string. Since string is assignable to FindType1 (string), they are replaced by ReplaceWithType1 (boolean). The age property remains number as it's not string.

Example 2:

// Input Type
type OriginalType2 = Array<string | number>;

type FindType2 = string;
type ReplaceWithType2 = null;

// Expected Output Type
type ResultType2 = Replace<OriginalType2, FindType2, ReplaceWithType2>;
// Expected: Array<null | number>

Explanation: The Replace type operates on the element type of the array OriginalType2, which is string | number. It then recursively applies to the union members. string is replaced by null, while number remains unchanged, resulting in null | number as the new element type.

Example 3:

// Input Type
type OriginalType3 = {
  id: number;
  tags: string[];
  metadata: {
    author: string;
    version: number;
  } | null;
};

type FindType3 = string | { author: string; version: number };
type ReplaceWithType3 = undefined;

// Expected Output Type
type ResultType3 = Replace<OriginalType3, FindType3, ReplaceWithType3>;
// Expected: { id: number; tags: undefined[]; metadata: undefined | null; }

Explanation: In this case, FindType3 is a union. The Replace type needs to handle this.

• OriginalType3.tags is string[]. The element type string is assignable to FindType3 (since string is assignable to string | ...), so it's replaced by undefined, resulting in undefined[].
• OriginalType3.metadata is a union: { author: string; version: number } | null. The first part of the union { author: string; version: number } is assignable to FindType3, so it's replaced by undefined. null remains null. The resulting type for metadata is undefined | null.

Constraints

• The solution must be implemented using TypeScript's built-in utility types and conditional types.
• No external libraries or dependencies are allowed.
• The solution should be as efficient as possible within the constraints of TypeScript's type system.
• The Replace type should be robust enough to handle common TypeScript type structures.

Notes

• Consider how to handle recursive types. While full recursion detection can be complex, aim for a solution that handles nested structures reasonably.
• Think about the order of checks in your conditional types. For example, checking if the entire type T is assignable to U is a good starting point.
• For object types, you might need to use mapped types to iterate over properties.
• For union types, you'll likely want to distribute the Replace operation over the union members.
• Intersection types require careful handling; consider how & operates.