> ## Documentation Index > Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt > Use this file to discover all available pages before exploring further. # TypeScript Subtraction The `-` operator in TypeScript functions in two distinct contexts: at the type level as a mapping modifier to remove property constraints, and at runtime as a standard arithmetic subtraction and unary negation operator subject to strict static type checking. ## Type-Level Semantics: Mapping Modifiers In TypeScript's type system, the `-` operator is used exclusively within mapped types to subtract (remove) specific modifiers from properties during type transformations. It can be applied to the `readonly` and `?` (optional) modifiers. **Syntax:** ```typescript theme={"dark"} type RemoveModifiers = { -readonly [P in keyof T]-?: T[P]; }; ``` * **`-readonly`**: Strips the `readonly` modifier from the property key, making the resulting property mutable. * **`-?`**: Strips the `?` modifier from the property key, making the resulting property strictly required and removing `undefined` from the property's union type (unless `undefined` is explicitly defined in the base type). **Type Evaluation:** ```typescript theme={"dark"} interface SourceType { readonly id?: number; readonly name?: string; } // The compiler evaluates this by stripping both 'readonly' and '?' type ProcessedType = { -readonly [K in keyof SourceType]-?: SourceType[K]; }; // Resulting type equivalent: // type ProcessedType = { // id: number; // name: string; // } ``` ## Runtime Semantics: Arithmetic and Unary Negation At runtime, TypeScript inherits JavaScript's `-` operator behavior but applies strict static type checking to the operands to prevent unintended implicit type coercion. **Binary Subtraction (`A - B`)** The compiler requires both operands to be of type `number`, `bigint`, `any`, or a numeric `enum`. TypeScript will throw a compilation error if the operands are of incompatible types or if you attempt to mix `number` and `bigint`. ```typescript theme={"dark"} const numA: number = 10; const numB: number = 5; const resultNum: number = numA - numB; // Valid const bigA: bigint = 10n; const bigB: bigint = 5n; const resultBig: bigint = bigA - bigB; // Valid enum Status { Pending = 1, Active = 2 } const resultEnum: number = Status.Active - Status.Pending; // Valid // Compiler Error ts(2365): Operator '-' cannot be applied to types 'number' and 'bigint'. const invalidMixed = numA - bigA; // Compiler Error ts(2362): The left-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type. const invalidString = "10" - 5; ``` **Unary Negation (`-A`)** When used as a unary prefix, the `-` operator converts the operand into a numeric value and negates it. TypeScript enforces that the operand must be of a type mathematically compatible with negation (`number`, `bigint`, `any`, or a numeric `enum`). ```typescript theme={"dark"} const positive: number = 42; const negative: number = -positive; // Evaluates to -42 const bigVal: bigint = 42n; const negBig: bigint = -bigVal; // Evaluates to -42n enum Offset { Base = 5 } const negEnum: number = -Offset.Base; // Evaluates to -5 // Compiler Error ts(2356): An arithmetic operand must be of type 'any', 'number', 'bigint' or an enum type. const invalidUnary = -"hello"; ```

Tired of Poor TypeScript Skills? Fix That With Deep Grasping! Learn More