TypeScript Pop Type for Array Manipulation

This challenge focuses on creating a utility type in TypeScript that mimics the behavior of the .pop() method on arrays. Understanding and creating such types is crucial for building robust and type-safe data structures and utilities in TypeScript, especially when dealing with generic array operations.

Problem Description

Your task is to create a TypeScript utility type named Pop that takes an array type T as input. This Pop type should return a new type representing the array with its last element removed. The returned type should be a tuple, preserving the order and types of the remaining elements.

Key Requirements:

• The Pop type should accept any array type T.
• It should return a tuple type representing T without its last element.
• If the input array is empty, the Pop type should result in an empty tuple [].

Expected Behavior:

When applied to an array type like [1, 2, 3], Pop<[1, 2, 3]> should resolve to [1, 2]. When applied to ['a', 'b'], Pop<['a', 'b']> should resolve to ['a']. When applied to [], Pop<[]> should resolve to [].

Edge Cases:

• Empty Array: The type must correctly handle an empty input array.
• Single Element Array: The type should correctly reduce a single-element array to an empty array.

Examples

Example 1:

Input: [1, 2, 3, 4, 5]
Output: Pop<[1, 2, 3, 4, 5]>
Resolved Output: [1, 2, 3, 4]
Explanation: The last element (5) is removed from the tuple.

Example 2:

Input: ["hello", "world"]
Output: Pop<["hello", "world"]>
Resolved Output: ["hello"]
Explanation: The last element ("world") is removed.

Example 3:

Input: []
Output: Pop<[]>
Resolved Output: []
Explanation: An empty array remains an empty array after attempting to pop.

Example 4:

Input: [true]
Output: Pop<[true]>
Resolved Output: []
Explanation: A single-element array results in an empty array after the element is removed.

Constraints

• The solution must be a TypeScript utility type.
• The type should be purely declarative and not rely on any runtime JavaScript execution.
• The solution should be efficient in terms of TypeScript's type inference and compilation time.

Notes

Consider how to access elements of a tuple type and how to construct a new tuple type from a subset of existing elements. Recursive conditional types might be a useful pattern here, but explore other possibilities as well. Think about how to identify the "last" element without direct indexing in the type system.