> ## 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.
# Dart Subtraction
The `-` operator in Dart functions as both a binary arithmetic operator for subtraction and a unary prefix operator for numeric negation. Its behavior, precedence, and return type are determined by its arity (the number of operands) and the static types of the expressions involved.
## Binary Subtraction
When used as a binary operator, `-` computes the difference between a left operand and a right operand. It evaluates left-to-right and falls under the additive precedence level.
**Type Resolution:**
Dart's type system applies implicit type promotion during binary subtraction based on the `num` class hierarchy:
* `int - int` evaluates to `int`.
* `double - double` evaluates to `double`.
* `int - double` (or vice versa) evaluates to `double`.
```dart theme={"dark"}
int a = 10 - 3; // Evaluates to 7 (int)
double b = 5.5 - 2.0; // Evaluates to 3.5 (double)
double c = 10 - 4.5; // Evaluates to 5.5 (double)
```
## Unary Negation
When used as a unary prefix operator, `-` inverts the algebraic sign of a single numeric operand. It evaluates right-to-left and possesses a higher precedence than binary arithmetic operators.
**Type Resolution:**
Unary negation preserves the static type of the operand. Negating an `int` returns an `int`, and negating a `double` returns a `double`.
```dart theme={"dark"}
int x = 5;
int y = -x; // Evaluates to -5 (int)
double z = -(-3.14); // Evaluates to 3.14 (double)
```
## Operator Overloading
Dart permits the `-` operator to be overridden in user-defined classes. Because the operator serves two distinct arities, Dart distinguishes the binary and unary implementations entirely by the parameter count in the operator declaration.
* **Binary Overload:** Defined using `operator -(Type other)`. It requires exactly one parameter representing the right-hand operand.
* **Unary Overload:** Defined using `operator -()`. It requires zero parameters. The compiler distinguishes it from the binary subtraction overload strictly by the absence of parameters. *(Note: While the internal symbol name used by the VM for `noSuchMethod` is `unary-`, the actual declaration syntax is `operator -()`)*.
```dart theme={"dark"}
class Vector {
final double x, y;
const Vector(this.x, this.y);
// Overloading the binary subtraction operator
Vector operator -(Vector other) {
return Vector(x - other.x, y - other.y);
}
// Overloading the unary negation operator
Vector operator -() {
return Vector(-x, -y);
}
}
void main() {
Vector v1 = Vector(4.0, 5.0);
Vector v2 = Vector(1.0, 2.0);
Vector v3 = v1 - v2; // Invokes binary operator -(Vector other)
Vector v4 = -v1; // Invokes unary operator -()
}
```
Tired of Poor Dart Skills? Fix That With Deep Grasping!
Learn More
