Logical Not

The ! (logical NOT) operator is a unary prefix operator that performs logical negation on a boolean expression. It evaluates to true if the operand is false, and false if the operand is true.

val isFalse = !true

Under the Hood: Operator Overloading

Kotlin implements operators as syntactic sugar for specific member or extension function calls. The compiler translates the ! prefix operator into a call to the not() function.

val isTrue = true

// Syntactic sugar
val a = !isTrue

// Compiler translation
val b = isTrue.not()

Nullability Constraints

Because the ! operator translates to a standard method call (not()), it is bound by Kotlin’s null safety rules. You cannot apply the ! operator directly to a nullable Boolean? receiver. Doing so results in a compilation error because the underlying not() call is not safe.

val flag: Boolean? = true

// Compilation Error: Reference has a nullable type 'Boolean?'
// val inverted = !flag 

// Correct: Explicit safe call to the underlying function
val invertedSafe = flag?.not() 

Custom Type Overloading

Because the operator is resolved via the not() function, it is not restricted to primitive booleans. You can apply the ! operator to any custom class by defining an operator fun not() member or extension function. The return type of the overloaded function is not required to be a Boolean.

class BinaryState(val state: Int) {
    // Overloading the ! operator
    operator fun not(): BinaryState {
        return BinaryState(if (state == 0) 1 else 0)
    }
}

val high = BinaryState(1)
val low = !high // Resolves to high.not()

Precedence

As a unary prefix operator, ! has a higher precedence than multiplicative, additive, and logical binary operators (like && and ||). When combined with binary operations, the negation is applied to the immediate right-hand operand before the binary operation is evaluated, unless overridden by parentheses.

val a = true
val b = false

// Evaluates as (!a) && b
val result = !a && b 

// Evaluates the binary expression first, then negates the result
val resultGrouped = !(a && b) 

Master Kotlin with Deep Grasping Methodology!

Learn More