Special Types & the Type Lattice

as forces a value to a type and crashes with an error if it is not that type. as? tries the same but gives back null instead of crashing when the value does not match.

is checks at runtime whether a value is of a given type; !is is the negation. After a successful is check, Kotlin automatically treats the variable as that type, so you can use it without an extra cast. That automatic narrowing is a smart cast.

Nothing is a type with no values at all; it marks code that never returns normally, like throwing an exception. Unit means a function returns but gives back nothing useful, like void.

T is a subtype of T?. Every non-null String is also a valid String?, so a String fits anywhere a String? is expected, just like a child fits where a parent is asked for. No conversion happens.

Unit is Kotlin's type for functions that do work but give back no useful value. If you don't write a return type, the function returns Unit automatically.

If two objects are equal by equals, they must return the same hashCode. data class auto-generates both from the constructor properties, so equal data objects always share a hash code.

At runtime the program does not remember the type inside the list, only that it is a list. So Kotlin can check it is a List but not that it holds Strings. It warns because the cast might wrongly succeed and crash later.

Kotlin won't smart-cast when the value could change between check and use: mutable var properties, properties with custom getters, open properties, and values from other modules. Copy the value into a local val (or use ?.let) and check that instead.

Nothing sits at the bottom of Kotlin's type hierarchy, so it counts as every type at once. That lets a throw or a never-returning call be used wherever any value is expected, like on the right of the elvis operator.

The expression's type is String?. Kotlin takes the common supertype of all branches. One branch is String, the other is null (type Nothing?), and the smallest type covering both is String?.

Unit means the function returns normally but with no useful value. Nothing means the function never returns at all -- it always throws or loops forever. Unit has one value; Nothing has none.

Any is Kotlin's root and only promises equals, hashCode, toString. Object has extra methods like wait, notify, getClass. On the JVM Any maps to Object, so those extras still exist but Kotlin hides them.

Use as? to try a cast and get null if it does not fit, then handle the null with the ?: operator to provide a default or return early. This avoids crashes from a bad cast.

In when, each is Type -> branch smart-casts the subject to that type inside the branch. With a sealed class or enum subject used as an expression, the compiler can require all subtypes to be covered, so no else branch is needed.

Give the function the return type Nothing and make sure every path throws or loops forever. Then the compiler knows code after a call to it is dead and can smart-cast variables, the way TODO() and error() do.

listOf("a", null, "b") is List<String?> because the elements unify to String?. listOf(1, "x") is List<Any> because Int and String share only the supertype Any (or its intersection). The common type of all elements becomes the element type.

Java's void is not a type and has no value. Kotlin's Unit is a real type with one value, so it can be used in generics. On the JVM, Unit-returning functions usually still compile to void methods.

A plain <T> actually means <T : Any?>, so T may be nullable. Writing <T : Any> forces T to be a non-null type, banning String? and friends — useful when null would break your logic.

Casting null to a type that forbids null fails, but casting null to a nullable type is fine. Values coming from Java have an unknown null status, so a careless cast can crash later when a hidden null appears.

Generic type arguments are erased at runtime, so the JVM can't tell a List<String> from a List<Int>. Kotlin forbids is List<String>. Use a star projection is List<*> to check only that it's a list, then verify elements individually if needed.

x is String is true only for non-null Strings; for a nullable you can write is String? to include null. Kotlin also smart-casts via control flow: after if (x !is String) return, the rest of the function treats x as String, because the only way past is when the check held.

The bare null literal has type Nothing?, the nullable bottom type whose only value is null. Because Nothing is below everything, an empty list typed List<Nothing> can stand in for a list of anything.

Nothing is the bottom type: it is a subtype of every type and has no values. Nothing? is its nullable form, sitting just above Nothing, and is a subtype of every nullable type T?. Together they anchor the bottom of the lattice.

When a lambda's expected type returns Unit, Kotlin ignores whatever the last expression produces and treats the result as Unit. So you never need to add return Unit or worry that the last line returns something else.

Default toString leaks little, but data class toString prints every field — including secrets. Arrays compare by identity, not content. And mutable fields used in hashCode corrupt hash-map keys. Override these members carefully.

When a branch ends in something that never returns, the compiler knows execution can't continue down that path, so afterward it can treat variables as non-null or narrowed. This breaks if the variable could change between the check and use.

An unbounded T defaults to bound Any?, so T can already be nullable. Writing T? just guarantees nullability. There is no T?? — nullable is idempotent: making an already-nullable type nullable again changes nothing.

Because the program forgets the inside type of a list at runtime, you cannot fully trust one big cast. Check each element instead, or use a tool that keeps the type, and only silence the warning when something else guarantees the contents are correct.

Use Unit as a generic argument when an API needs a type but there's no meaningful payload, like a result that only signals success. Watch out for Java interop where Unit maps to kotlin.Unit, not java.lang.Void, and for suspend functions whose Unit result still flows through Continuation.