🔥 TypeScript with Throws Clause Support

✨ Features

📝 Syntax Examples

Basic Exception Declaration

// Declare that a function can throw specific error typesfunctionparseNumber(input:string):numberthrowsTypeError,RangeError{if(typeofinput!=='string'){thrownewTypeError('Input must be a string');// ✅ Valid - TypeError is declared}constnum=parseInt(input);if(isNaN(num)){thrownewRangeError('Invalid number format');// ✅ Valid - RangeError is declared}returnnum;}// Or let TypeScript infer the throws clause from the function bodyfunctionparseNumber(input:string)/* throws TypeError, RangeError */{if(typeofinput!=='string'){thrownewTypeError('Input must be a string');// Inferred: TypeError}constnum=parseInt(input);if(isNaN(num)){thrownewRangeError('Invalid number format');// Inferred: RangeError}returnnum;}// and when you call it, TypeScript will check if the function throws the correct error typesfunctiontest(){// ❌ Error: Function does not declare throwsparseNumber('123');}functiontest2()throws{// ✅ Valid - no error, pass through any exceptionsparseNumber('123');}

Empty Throws Clause (Function Can Rethrow)

// Empty throws clause allows rethrowing any caught exceptionsfunctionsafeOperation<T>(fn:()=>T):Tthrows{try{returnfn();}catch(error){// Log error and rethrowconsole.error('Operation failed:',error);throwerror;// ✅ Valid - empty throws clause allows rethrowing}}

Union Types in Throws Clauses

// Multiple exception types using union syntaxfunctionprocessData(data:unknown):stringthrowsTypeError|ValidationError{if(typeofdata!=='object'){thrownewTypeError('Data must be an object');// ✅ Valid}if(!isValid(data)){thrownewValidationError('Invalid data format');// ✅ Valid}returnJSON.stringify(data);}

Generic Throws Clauses with Conditional Types

// Conditional exception types based on generic parametersfunctionconvert<Textendsstring|number>(value:T):stringthrowsTextendsstring ?TypeError :RangeError{if(typeofvalue==='string'){if(value.length===0){thrownewTypeError('Empty string not allowed');// ✅ Valid when T extends string}returnvalue;}else{if(value<0){thrownewRangeError('Negative numbers not allowed');// ✅ Valid when T extends number}returnvalue.toString();}}

Interface Method Signatures

interfaceDataProcessor{// Method signatures can include throws clausesprocess(data:string):ProcessedDatathrowsValidationError;// Optional throws clause with multiple typesvalidate?(input:unknown):booleanthrowsTypeError,ValidationError;}classMyProcessorimplementsDataProcessor{process(data:string):ProcessedDatathrowsValidationError{if(!data.trim()){thrownewValidationError('Data cannot be empty');// ✅ Valid}return{processed:data.trim()};}}

Type Inference and Validation

functionriskyOperation():stringthrowsError{if(Math.random()>0.5){thrownewTypeError('Random failure');// ❌ Error: TypeError not declared in throws clause}thrownewError('Expected failure');// ✅ Valid - Error is declared}// Function without throws clause cannot throwfunctionsafeFunction():string{thrownewError('Oops');// ❌ Error: Function does not declare any exceptions in throws clause}

Throws Clause Inference from Function Body

// TypeScript can infer throws clause from explicit throws in function bodyfunctioninferredThrower(value:unknown)/* throws TypeError | RangeError */{if(typeofvalue!=='number'){thrownewTypeError('Value must be a number');// Inferred: TypeError}if(value<0){thrownewRangeError('Value must be non-negative');// Inferred: RangeError}returnvalue.toString();}// TypeScript infers: function inferredThrower(value: unknown): string throws TypeError | RangeError// Mixed explicit and inferred throwsfunctionmixedThrower(data:string):numberthrowsSyntaxError{if(!data){thrownewTypeError('Data is required');// ❌ Error: TypeError not in explicit throws clause}if(data==='invalid'){thrownewSyntaxError('Invalid data format');// ✅ Valid - SyntaxError is declared}returnparseInt(data);}// Conditional throws inferencefunctionconditionalInference(condition:boolean){if(condition){thrownewError('Condition failed');// Inferred: Error}// TypeScript infers: throws Error (only when condition is true)return'success';}####ArrowFunctionswithThrowsClauses```typescript// Arrow functions support throws clauses tooconstasyncParser=async(input:string):Promise<number>throwsTypeError=>{if(!input){thrownewTypeError('Input is required');// ✅ Valid}returnparseInt(input);};// Generic arrow function with conditional throwsconstconditionalThrower=<T>(value:T):stringthrowsTextendsError ?never :TypeError=>{if(valueinstanceofError){returnvalue.message;// No exception thrown when T extends Error}if(typeofvalue!=='string'){thrownewTypeError('Value must be string or Error');// ✅ Valid when T doesn't extend Error}returnvalue;};

🚨 Important: Explicit Throws Declaration Required

// ❌ Functions without throws clauses cannot call throwing functionsfunctioncaller(){parseNumber('123');// Error: Function throws but not declared in throws clause}// ✅ Explicit empty throws clause allows any exceptionsfunctioncallerWithEmptyThrows()throws{parseNumber('123');// Valid - can rethrow any exceptions}// ✅ Explicit specific throws clause must be compatiblefunctioncallerWithSpecificThrows()throwsTypeError,RangeError{parseNumber('123');// Valid - throws clause covers TypeError and RangeError}

🔗 Original TypeScript

Installing

npm install -D typescript

npm install -D typescript@next

Contribute

Documentation

Roadmap