Implementing a Safe pop Operation for Arrays in TypeScript

This challenge focuses on creating a type-safe pop function in TypeScript that accurately reflects the type of the removed element from an array. The standard JavaScript pop() method returns undefined if the array is empty, which can lead to type errors when working with strongly-typed TypeScript arrays. This challenge aims to create a type-safe alternative that provides a more precise return type.

Problem Description

You are tasked with creating a TypeScript function called safePop that mimics the behavior of the JavaScript pop() method but with improved type safety. The function should accept an array of any type and return a union type that includes the type of the last element of the array or undefined if the array is empty. The original array should be mutated (have its last element removed).

Key Requirements:

• Type Safety: The return type must accurately reflect the type of the removed element or undefined.
• Mutation: The original array must be modified by removing the last element.
• Empty Array Handling: If the array is empty, the function should return undefined.
• Generic Type: The function should work with arrays of any type.

Expected Behavior:

The safePop function should take an array as input and return either the last element of the array or undefined. The array should be modified to exclude the last element.

Edge Cases to Consider:

• Empty array: Should return undefined and not modify the array.
• Array of primitive types (number, string, boolean): The return type should accurately reflect the primitive type.
• Array of objects: The return type should be the type of the object.
• Array of mixed types (not recommended, but should still work): The return type should be a union of all possible types in the array.

Examples

Example 1:

Input: number[] = [1, 2, 3]
Output: 3 | undefined
Explanation: The last element (3) is removed from the array and returned. The array becomes [1, 2].

Example 2:

Input: string[] = ["a", "b", "c"]
Output: "c" | undefined
Explanation: The last element ("c") is removed and returned. The array becomes ["a", "b"].

Example 3:

Input: boolean[] = [true, false]
Output: false | undefined
Explanation: The last element (false) is removed and returned. The array becomes [true].

Example 4:

Input: []
Output: undefined
Explanation: The array is empty, so undefined is returned, and the array remains empty.

Example 5:

Input: ( {name: string, age: number} )[] = [{name: "Alice", age: 30}, {name: "Bob", age: 25}]
Output: {name: string, age: number} | undefined
Explanation: The last element ({name: "Bob", age: 25}) is removed and returned. The array becomes [{name: "Alice", age: 30}].

Constraints

• The function must be written in TypeScript.
• The function must be generic to handle arrays of any type.
• The function must mutate the original array.
• The function must return a union type of the last element type or undefined.
• The function should be reasonably performant (O(1) time complexity for the pop operation).

Notes

Consider using TypeScript's conditional types and utility types (like Extract) to achieve the desired type safety. Think about how to infer the type of the array elements and create a union type that includes both the element type and undefined. The key is to leverage TypeScript's type system to ensure that the return type accurately reflects the possible values that can be returned by the function.