Harnessing TypeScript’s Advanced Type Inference for Cleaner Error Handling

Error handling is a crucial part of programming, and TypeScript can make it much safer and cleaner with its advanced type inference features. By leveraging TypeScript’s ability to infer types, you can write error handling code that is both easy to read and less prone to mistakes. In this article, we’ll explore how to harness these features in a beginner-friendly way.

Consider a common pattern in JavaScript where a function may return either a successful value or an error. Traditionally, developers rely on throwing errors or using simple return values, which can be hard to manage and unsafe. TypeScript allows us to define a discriminated union type for these results, helping us leverage type inference to make error handling more explicit and reliable.

type Result<T, E> =
  | { success: true; value: T }
  | { success: false; error: E };

Here, the `Result` type is a union type with two variants: one representing success and the other failure. The `success` boolean acts as a discriminant, letting TypeScript automatically infer which variant we are dealing with. Now let’s see how we can use this pattern in a simple function that parses JSON.

function parseJson(jsonString: string): Result<any, string> {
  try {
    const parsed = JSON.parse(jsonString);
    return { success: true, value: parsed };
  } catch (error) {
    return { success: false, error: (error as Error).message };
  }
}

When you call `parseJson`, the returned object clearly indicates whether the operation was successful. Using an if-statement TypeScript fully understands the type within each branch:

const result = parseJson('{"name":"Alice"}');

if (result.success) {
  // TypeScript knows 'result' is the success variant
  console.log('Parsed object:', result.value);
} else {
  // Here, TypeScript knows it's the error variant
  console.error('Parsing error:', result.error);
}

This approach helps the compiler catch mistakes early. For example, if you try to access `result.value` inside the `else` block, TypeScript will warn you because this property doesn’t exist for errors. This leads to more robust and easier-to-maintain code.

To make this even more reusable, you can define a generic function to handle this pattern across your project. This way, all functions that can succeed or fail will have a consistent return type and benefit from TypeScript’s inference.

function safeExecute<T>(fn: () => T): Result<T, string> {
  try {
    return { success: true, value: fn() };
  } catch (error) {
    return { success: false, error: (error as Error).message };
  }
}

const safeResult = safeExecute(() => {
  // Your safe code here
  return JSON.parse('{"id":1}');
});

if (safeResult.success) {
  console.log("Success:", safeResult.value);
} else {
  console.error("Error:", safeResult.error);
}

In summary, using TypeScript’s union types with discriminants lets you write clearer and safer error handling code. Type inference helps by narrowing down the type automatically based on runtime checks, reducing bugs and improving developer experience. Try implementing this pattern in your next project to see the benefits firsthand!