> ## 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 Unary Minus
The `-` operator in Dart functions as both a binary arithmetic operator for subtraction and a prefix unary operator for numeric negation. Its behavior and precedence are determined by the arity of the expression in which it is invoked.
## Binary Subtraction
When used as a binary operator, `-` calculates the difference between a left operand and a right operand. It operates at the additive precedence level with left-to-right associativity.
In Dart's core numeric types (`int` and `double`), the return type depends on the operands: if both are integers, the result is an `int`; if either is a floating-point number, the result is a `double`.
```dart theme={"dark"}
int difference = 10 - 3; // Evaluates to 7
double floatDiff = 10.5 - 2; // Evaluates to 8.5
```
## Unary Negation
When used as a prefix unary operator, `-` reverses the algebraic sign of a single numeric operand. It operates at the unary prefix precedence level, which is higher than multiplicative and additive operators.
```dart theme={"dark"}
int value = 5;
int negated = -value; // Evaluates to -5
int doubleNegated = -(-value); // Evaluates to 5
```
## Operator Overloading
Dart permits custom classes to override the `-` operator. Because the operator serves two distinct arities, Dart uses different syntax signatures to differentiate between binary subtraction and unary negation during operator overloading.
* **Binary Overload:** Defined using `operator -` with a single parameter representing the right operand.
* **Unary Overload:** Defined using the specific syntax `operator unary-` with empty parentheses to indicate the prefix negation.
```dart theme={"dark"}
class Vector {
final int x;
final int y;
const Vector(this.x, this.y);
// Overriding binary subtraction
Vector operator -(Vector other) {
return Vector(x - other.x, y - other.y);
}
// Overriding unary negation
Vector operator unary-() {
return Vector(-x, -y);
}
}
void main() {
Vector v1 = Vector(4, 5);
Vector v2 = Vector(1, 2);
Vector v3 = v1 - v2; // Invokes binary operator -(Vector other)
Vector v4 = -v1; // Invokes unary operator unary-()
}
```
Tired of Poor Dart Skills? Fix That With Deep Grasping!
Learn More
