DEV Community

kouta222
kouta222

Posted on

Understanding the Nothing Type in Kotlin

#kotlin #java #webdev

In Kotlin, the Nothing type plays a unique role that is essential for writing expressive, safe, and clear code. To understand Nothing, it's helpful to also compare it to Kotlin's Any and Unit types.

What is Nothing?

The Nothing type in Kotlin is a special type that has no instances. It literally represents a value that never exists.

When a function returns Nothing, it means it will never return normally—either because it always throws an exception, enters an infinite loop, or the program terminates.

Example:

fun fail(message: String): Nothing {
    throw IllegalArgumentException(message)
}

fun main() {
    fail("This is an error!") // This line will throw an exception.
    println("This will never be printed.") // Unreachable code warning.
}
Enter fullscreen mode Exit fullscreen mode

Nothing makes it explicit to the compiler and developers that the function will not return.

The compiler warns about unreachable code after a Nothing-returning function.

Relationship Between Any and Nothing

Any: The Most Abstract Type

  • Any is the root of the Kotlin class hierarchy
  • All classes in Kotlin implicitly inherit from Any
  • Similar to Object in Java
  • Every Kotlin object is a subtype of Any 
// Source Code (Simplified)
public open class Any {
    public open operator fun equals(other: Any?): Boolean
    public open fun hashCode(): Int
    public open fun toString(): String
}
Enter fullscreen mode Exit fullscreen mode

Nothing: The Most Specific Type

  • Nothing is the opposite of Any
  • It is a subtype of all types, but no type is a subtype of Nothing
  • Nothing cannot have any instances
  • Every other type can safely accept Nothing, but you can never create a Nothing value
Concept Any Nothing
Meaning Root type Bottom type
Inheritance All classes inherit Any Nothing inherits all classes (theoretically)
Instance Can have instances Cannot have instances
Example val x: Any = "hello" fun fail(): Nothing

Key Intuition:

  • Any = "Universal Superclass"
  • Nothing = "Universal Subclass" (but has no instances)

Difference Between Unit and Nothing

Unit: Like Java's void, but an actual type

  • Represents a function that returns no meaningful value
  • Default return type when no return type is specified
  • Can be instantiated—it has a singleton value Unit 
fun printHello(): Unit {
    println("Hello")
}

fun main() {
    val result: Unit = printHello()
    println(result) // Output: kotlin.Unit
}
Enter fullscreen mode Exit fullscreen mode

Nothing: Represents the impossibility of returning

  • Used for functions that never return normally
  • No instance, no value
  • Compiler knows that after this function, the code is unreachable 
fun fail(): Nothing {
    throw Exception("Error!")
}

fun example(): String {
    return fail() // Allowed: fail() never returns
}
Enter fullscreen mode Exit fullscreen mode

If fail() returned Unit instead, this would cause a compile error:

// Compile Error: Type mismatch
fun fail(): Unit { throw Exception() }

fun example(): String {
    return fail() // Error: Unit cannot be returned where String is expected
}
Enter fullscreen mode Exit fullscreen mode

Key Difference:

Feature Unit Nothing
Purpose No meaningful return value Function never returns normally
Instantiable Yes (singleton: Unit) No
Java Equivalent void None
Example Use Case Logging, printing Error handling, TODO placeholders

Practical Use Cases for Nothing

  1. Exception-throwing functions 
fun fail(): Nothing { throw Exception("Failure") }
Enter fullscreen mode Exit fullscreen mode
  1. Infinite loops 
fun infiniteLoop(): Nothing { while (true) {} }
Enter fullscreen mode Exit fullscreen mode
  1. TODO placeholders 
fun getName(): String = TODO("Not implemented yet")
Enter fullscreen mode Exit fullscreen mode

TODO() in Kotlin actually returns Nothing. This helps the compiler understand that it's a placeholder and that no valid value will be returned.

Summary

Type Purpose Returnable Instances
Any Supertype of all types Yes Yes
Unit No meaningful return value Yes Yes
Nothing No value, function never returns No No
  • Any: Represents everything
  • Nothing: Represents nothing
  • Unit: Represents "I don't return anything meaningful, but I still exist"

References

Top comments (0)