> ## 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. # Kotlin Not In The `!in` operator is a negated membership operator used to evaluate whether a specific element is absent from a collection, range, or any object that defines a `contains` operator function. It serves as the syntactic inverse of the `in` operator. At compile time, the Kotlin compiler desugars the `!in` expression into a negated method invocation of `contains()` on the right-hand operand. ```kotlin theme={"dark"} val a = 5 val b = listOf(1, 2, 3) // Syntactic expression val isAbsent = a !in b // Desugared JVM equivalent val isAbsentDesugared = !b.contains(a) ``` ## Operator Overloading Because `!in` relies on the `contains` convention, it does not have its own dedicated operator function. To enable `!in` for a custom type, you must implement the `contains` function and mark it with the `operator` modifier. The function must accept the left-hand operand's type and return a `Boolean`. ```kotlin theme={"dark"} class BoundingBox(val min: Int, val max: Int) { // Enables both 'in' and '!in' operator fun contains(point: Int): Boolean { return point in min..max } } val box = BoundingBox(0, 100) val isOutside = 150 !in box // Evaluates to !box.contains(150) ``` ## Type Resolution and Extension Functions The right-hand operand is not strictly required to be a collection. The Kotlin compiler resolves the `contains` method either as a member function or as an extension function. For example, the standard library provides extension functions for `Iterable`, `Array`, and `CharSequence`, allowing `!in` to be evaluated against diverse data structures. ```kotlin theme={"dark"} // Resolves to CharSequence.contains(Char) val notAVowel = 'z' !in "aeiou" // Resolves to Iterable.contains(T) val element = 42 val objectList = listOf(1, 2, 3) val notFound = element !in objectList ``` ## Syntax in Control Flow Beyond standard boolean expressions, `!in` is a recognized branch condition within `when` expressions. In this context, the compiler implicitly applies the `!in` operator against the subject of the `when` block. ```kotlin theme={"dark"} fun handleOutliers() { /* ... */ } fun processStandard() { /* ... */ } val subject = 150 when (subject) { !in 0..100 -> handleOutliers() // Desugars to: !(0..100).contains(subject) else -> processStandard() } ```

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