Advanced Type Utilities: Function Parameter and Return Type Extraction

This challenge focuses on building advanced TypeScript type utility functions that manipulate function types. Understanding how to extract and transform function types is crucial for creating reusable and type-safe components, especially when dealing with higher-order functions, callbacks, and event handlers. You'll be implementing utilities to extract parameter types and return types from function types.

Problem Description

You are tasked with creating three TypeScript type utility functions: ExtractFunctionParameters, InferReturnType, and FunctionType. These utilities will allow you to analyze and manipulate function types in a type-safe manner.

• ExtractFunctionParameters<T>: This utility should take a function type T as input and return a tuple type representing the types of the function's parameters. If the function has no parameters, it should return an empty tuple type.
• InferReturnType<T>: This utility should take a function type T as input and return the type of the function's return value.
• FunctionType<T>: This utility should take a type T and, if T is a function type, return that function type. Otherwise, it should return unknown. This acts as a type guard to ensure you're working with a function type.

Key Requirements:

• The utilities must be implemented using conditional types and other advanced TypeScript type features.
• The utilities must be type-safe and provide accurate results for various function types, including those with optional parameters, rest parameters, and default parameter values.
• The utilities should handle edge cases gracefully, such as functions with no parameters or functions with complex return types.

Expected Behavior:

The utilities should behave as described above, accurately extracting and inferring function types. The FunctionType utility should correctly identify and return function types, and return unknown otherwise.

Edge Cases to Consider:

• Functions with no parameters.
• Functions with optional parameters.
• Functions with rest parameters.
• Functions with default parameter values.
• Functions with complex return types (e.g., union types, generic types).
• Types that are not functions.

Examples

Example 1:

type MyFunc = (a: number, b: string) => boolean;

type Params = ExtractFunctionParameters<MyFunc>;
// Expected Output: [number, string]

type ReturnType = InferReturnType<MyFunc>;
// Expected Output: boolean

type IsFunction = FunctionType<MyFunc>;
// Expected Output: (a: number, b: string) => boolean

type NotAFunction = string;
type IsFunction2 = FunctionType<NotAFunction>;
// Expected Output: unknown

Example 2:

type NoParamsFunc = () => void;

type Params2 = ExtractFunctionParameters<NoParamsFunc>;
// Expected Output: []

type ReturnType2 = InferReturnType<NoParamsFunc>;
// Expected Output: void

Example 3:

type OptionalParamsFunc = (a: number, b?: string) => string;

type Params3 = ExtractFunctionParameters<OptionalParamsFunc>;
// Expected Output: [number, string | undefined]

type ReturnType3 = InferReturnType<OptionalParamsFunc>;
// Expected Output: string

Constraints

• The solutions must be implemented using TypeScript's type system. No runtime code is allowed.
• The solutions must be concise and efficient in terms of type complexity.
• The solutions must be compatible with TypeScript 4.0 or later.
• The solutions should not rely on external libraries or packages.

Notes

• Consider using conditional types (T extends ... ? ... : ...) to handle different scenarios.
• The Parameters<T> and ReturnType<T> utility types already exist in TypeScript, but the goal here is to implement them from scratch to understand the underlying type manipulation techniques.
• Think about how to handle the case where a type is not a function type in FunctionType.
• Pay close attention to the order of parameters when extracting them in ExtractFunctionParameters.