Parameters, ReturnType, and Awaited

Parameters<F> extracts a function's parameter tuple; ReturnType<F> extracts its declared return type; Awaited<T> recursively unwraps promise-like result types. These are types, not runtime reflections of a function.

Reading the code: Parameters produces [number,string] and spread supplies those values to format. ReturnType is string. Awaited resolves nested Promise types to number, but the program assigns a number directly.

Keep the boundary clear: Awaited<Promise<T>> does not wait for a promise at runtime; use await for actual asynchronous fulfillment.

Save the code as parameters-returntype-awaited.ts. The result below was captured after compiling this exact example with strict TypeScript checking and executing the emitted JavaScript in Node.js.

TypeScript code

function format(id: number, prefix: string): string { return `${prefix}-${id}`; }
type Args = Parameters<typeof format>;
type Result = ReturnType<typeof format>;
type Value = Awaited<Promise<Promise<number>>>;
const args: Args = [8, "ORD"];
const result: Result = format(...args);
const numberValue: Value = 12;
console.log(result);
console.log(numberValue);

Verified output

ORD-8
12

Build: npx tsc --strict --target es2022 --module commonjs --lib es2022,dom,esnext.disposable parameters-returntype-awaited.ts; run: node parameters-returntype-awaited.js. The exact filename may be changed freely. When a multi-file project exists, prefer its tsconfig.json and build scripts.

Parameters produces [number,string] and spread supplies those values to format. ReturnType is string. Awaited resolves nested Promise types to number, but the program assigns a number directly.

The output shown above comes from the initialized values in this program. Replacing a type annotation alone does not transform a JavaScript value.

Awaited<Promise<T>> does not wait for a promise at runtime; use await for actual asynchronous fulfillment.

Check both the TypeScript diagnostic and the emitted JavaScript behavior. A program can compile correctly and still need runtime validation or error handling.

Change format to return an object and observe how ReturnType follows it without editing the alias.

Before running your change, write down the type you expect TypeScript to infer and the output you expect JavaScript to print. Then check both predictions.

Parameters<F> extracts a function's parameter tuple; ReturnType<F> extracts its declared return type; Awaited<T> recursively unwraps promise-like result types.

Try the practice change and re-run the exact program to test your understanding.