Creating Safe Type Conversions
You'll learn: How to build conditional types that only convert types when it's truly safe, preventing runtime errors by returning never or the original type when conversion would be dangerous.
The Safety Problem
When converting between types, TypeScript can't always verify that the conversion is valid. For example, converting a string to a number might succeed ("42" → 42) or fail ("hello" → NaN). Safe type conversions use conditional types to enforce compile-time checks, ensuring conversions only happen when they make sense structurally.
The Pattern
The core pattern looks like this:
type SafeConvert<T, Target> = T extends Target ? Target : never;
This reads as: "If T is already assignable to Target, convert it. Otherwise, return never (indicating impossibility)."
Real-World Example: Safe String-to-Number
type Numeric = string | number;
type SafeNumber<T> = T extends number
? number
: T extends `${number}`
? number
: never;
type A = SafeNumber<42>; // number
type B = SafeNumber<"123">; // number (string literal that's numeric)
type C = SafeNumber<"hello">; // never (unsafe conversion blocked)
Preserving When Unsafe
Sometimes you want to keep the original type instead of returning never:
type SafeConvertOrKeep<T, Target> = T extends Target ? Target : T;
type Result1 = SafeConvertOrKeep<number, string>; // number (kept original)
type Result2 = SafeConvertOrKeep<number, number>; // number (converted)
This pattern is useful in mapped types where you selectively transform properties but leave incompatible ones unchanged.
Filtering Object Properties Safely
type OnlyNumbers<T> = {
[K in keyof T]: T[K] extends number ? T[K] : never;
};
type Data = { id: number; name: string; count: number };
type Nums = OnlyNumbers<Data>; // { id: number; name: never; count: number }
Key Takeaway: Safe type conversions use conditional types with extends checks to permit conversions only when structurally valid, returning never or the original type to prevent type-level errors from becoming runtime bugs.