Kotlin Referential Inequality

a !== b

// Conceptual translation
!(a === b)

class DataNode(val id: Int) {
    override fun equals(other: Any?): Boolean {
        return other is DataNode && this.id == other.id
    }
}

val nodeA = DataNode(1)
val nodeB = DataNode(1)
val nodeC = nodeA

// Structural comparison (evaluates equals())
println(nodeA != nodeB)  // false: Contents are identical

// Referential comparison (evaluates memory addresses)
println(nodeA !== nodeB) // true: They are distinct objects in memory
println(nodeA !== nodeC) // false: They point to the exact same object

// Unboxed primitives
val x: Int = 1000
val y: Int = 1000
// COMPILATION ERROR: Identity equality for arguments of types Int and Int is forbidden
println(x !== y) 

// Boxed primitives (Nullable)
val boxedX: Int? = 1000
val boxedY: Int? = 1000
println(boxedX !== boxedY) // true: Distinct boxed object references on the heap

// Boxed primitives within JVM cache range (-128 to 127)
val cachedX: Int? = 42
val cachedY: Int? = 42
println(cachedX !== cachedY) // false: JVM reuses the same cached object reference

@JvmInline
value class Identifier(val id: String)

val id1 = Identifier("user_123")
val id2 = Identifier("user_123")

// COMPILATION ERROR: Identity equality for arguments of types Identifier and Identifier is forbidden
println(id1 !== id2)