> ## 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 Negated Type Check The `!is` operator is Kotlin's negated runtime type-checking operator. It evaluates to `true` if an object is *not* an instance of a specified type, and `false` if it is. While it is logically equivalent to applying the unary logical NOT operator to a parenthesized standard type-check (`!(expression is Type)`), `!is` is syntactically distinct and functions as a dedicated binary operator in Kotlin's grammar. ## Syntax ```kotlin theme={"dark"} expression !is Type ``` ## Technical Mechanics **Runtime Type Identification (RTTI)** The operator relies on RTTI to inspect the actual runtime class of the object referenced by the `expression`. It does not evaluate the static (compile-time) type of the variable, but rather the instance it points to in memory. **Nullability Rules** The `!is` operator inherently handles nullability based on the right-hand type declaration: * If the target `Type` is non-nullable (e.g., `String`), evaluating `null !is String` returns `true`. * If the target `Type` is nullable (e.g., `String?`), evaluating `null !is String?` returns `false`, because `null` is considered a valid instance of any nullable type. ```kotlin theme={"dark"} val obj: Any? = null val checkOne = obj !is String // true val checkTwo = obj !is String? // false ``` **Type Erasure Constraints** Because Kotlin targets the JVM (among other platforms), `!is` is subject to generic type erasure. Generally, you cannot use `!is` to check against a specific generic instantiation at runtime, requiring the use of star-projected types instead. ```kotlin theme={"dark"} // Compiler Error: Cannot check for instance of erased type val check = obj !is List // Valid: Checks against the star-projected type val validCheck = obj !is List<*> ``` However, there are specific scenarios where `!is` can evaluate generic type arguments: 1. **Reified Type Parameters:** When used inside an `inline` function against a `reified` type parameter, as the type is preserved at the call site. 2. **Statically Known Type Arguments:** When the type arguments of the expression are already statically known by the compiler (e.g., evaluating `collection !is List` when `collection` is statically typed as `Collection`). 3. **Arrays:** `Array` types retain their generic type parameters at runtime, allowing checks like `obj !is Array`. ## Control-Flow Analysis and Smart Casting The Kotlin compiler's control-flow analysis engine heavily utilizes the `!is` operator to perform **smart casting**. While the `is` operator typically smart-casts within the bounds of a conditional block, `!is` is used to trigger smart casting for the remainder of a scope via early exits (such as `return` or `throw`). If the compiler detects that execution only continues when `!is` evaluates to `false`, it automatically safely casts the variable to the target type for all subsequent instructions in that scope. ```kotlin theme={"dark"} fun evaluate(obj: Any) { if (obj !is String) { // 'obj' remains 'Any' in this block return } // Smart cast: 'obj' is statically treated as 'String' from this point forward // No explicit cast (obj as String) is required val length = obj.length } ```

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