Type-Level Least Common Multiple (LCM) in TypeScript

Calculating the Least Common Multiple (LCM) is a fundamental mathematical operation. This challenge asks you to implement an LCM calculation at the type level in TypeScript, leveraging advanced type manipulations. This allows you to determine the LCM of numbers represented as types, opening possibilities for compile-time calculations and validations.

Problem Description

You need to create a TypeScript type LCM<T extends number, U extends number> that calculates the Least Common Multiple of two number types T and U. The LCM should be represented as a new number type. The solution must utilize type-level programming techniques, avoiding runtime calculations. You'll need to define helper types to facilitate the calculation, likely involving Greatest Common Divisor (GCD) and potentially prime factorization concepts at the type level.

Key Requirements:

• The LCM type must accept two number types, T and U, as generic arguments.
• The result of LCM<T, U> must be a number type representing the LCM of T and U.
• The solution must be purely type-level; no runtime calculations are allowed.
• The solution should be reasonably efficient in terms of type complexity (avoiding excessively complex or deeply nested types if possible).

Expected Behavior:

The type LCM<T, U> should infer the LCM of the number types T and U. For example, LCM<2, 3> should resolve to the type 6.

Edge Cases to Consider:

• One or both inputs are 0. The LCM of any number with 0 is 0.
• One or both inputs are negative. The LCM is always a positive value. You can choose to handle negative inputs by taking their absolute values at the type level.
• Large numbers. While runtime performance isn't a concern, extremely complex type manipulations for very large numbers could lead to TypeScript compilation issues. Consider the practical limits of type-level computations.
• Non-integer inputs (although the problem specifies number types, consider how your solution would behave if it encountered a non-integer).

Examples

Example 1:

Input: LCM<2, 3>
Output: 6
Explanation: The LCM of 2 and 3 is 6.

Example 2:

Input: LCM<4, 6>
Output: 12
Explanation: The LCM of 4 and 6 is 12.

Example 3:

Input: LCM<0, 5>
Output: 0
Explanation: The LCM of 0 and 5 is 0.

Example 4:

Input: LCM<5, 0>
Output: 0
Explanation: The LCM of 5 and 0 is 0.

Example 5:

Input: LCM<(-2), 3>
Output: 6
Explanation: The LCM of -2 and 3 is 6 (absolute values are used).

Constraints

• T and U must be number types.
• The solution should be reasonably type-safe.
• Avoid using external libraries or complex type utilities beyond TypeScript's built-in features.
• While performance isn't a runtime concern, aim for a solution that doesn't create excessively complex types, which could lead to compilation issues.

Notes

• You'll likely need to implement a type-level GCD function as a helper. Euclid's algorithm is a common approach for GCD calculation.
• Consider how you can represent prime factorization at the type level, although this might be overly complex. A GCD-based approach is generally more practical.
• Think about how to handle negative numbers and zero inputs correctly within the type system.
• The core challenge lies in expressing mathematical operations (GCD, multiplication) using only TypeScript's type system.