#Keywords and Operators

Last modified: 04 May 2026

---

#Hard Keywords

The following tokens are always interpreted as keywords and cannot be used as identifiers:

• as
• Used for type casts.
• Specifies an alias for an import.

• as? is used for safe type casts.
• break terminates the execution of a loop.
• class declares a class.
• continue proceeds to the next step of the nearest enclosing loop.
• do begins a do/while loop (a loop with a postcondition).
• else defines the branch of an if expression that is executed when the condition is false.
• false specifies the 'false' value of the Boolean type.
• for begins a for loop.
• fun declares a function.
• if begins an if expression.
• in
• Specifies the object being iterated in a for loop.
• Used as an infix operator to check that a value belongs to a range, a collection, or another entity that defines a contains method.
• Used in when expressions for the same purpose.
• Marks a type parameter as contravariant.

• !in
• Used as an operator to check that a value does NOT belong to a range or collection.
• Used in when expressions for the same purpose.

• interface declares an interface.
• is
• Checks that a value has a certain type.
• Used in when expressions for the same purpose.

• !is
• Checks that a value does NOT have a certain type.
• Used in when expressions for the same purpose.

• null is a constant representing an object reference that doesn't point to any object.
• object declares a class and its instance at the same time.
• package specifies the package for the current file.
• return returns from the nearest enclosing function or anonymous function.
• super
• Refers to the superclass implementation of a method or property.
• Calls the superclass constructor from a secondary constructor.

• this
• Refers to the current receiver.
• Calls another constructor of the same class from a secondary constructor.

• throw throws an exception.
• true specifies the 'true' value of the Boolean type.
• try begins an exception-handling block.
• typealias declares a type alias.
• typeof is reserved for future use.
• val declares a read-only property or local variable.
• var declares a mutable property or local variable.
• when begins a when expression (executes one of the given branches).
• while begins a while loop (a loop with a precondition).

---

#Soft Keywords

The following tokens act as keywords in specific contexts but can be used as identifiers in others:

• by
• Delegates the implementation of an interface to another object.
• Delegates the implementation of the accessors for a property to another object.

• catch begins a block that handles a specific exception type.
• constructor declares a primary or secondary constructor.
• delegate is used as an annotation use-site target.
• dynamic references a dynamic type in Kotlin/JS code.
• field is used as an annotation use-site target.
• file is used as an annotation use-site target.
• finally begins a block that is always executed when a try block exits.
• get
• Declares the getter of a property.
• Is used as an annotation use-site target.

• import imports a declaration from another package into the current file.
• init begins an initializer block.
• param is used as an annotation use-site target.
• property is used as an annotation use-site target.
• receiver is used as an annotation use-site target.
• set
• Declares the setter of a property.
• Is used as an annotation use-site target.

• setparam is used as an annotation use-site target.
• value with the class keyword declares an inline class.
• where specifies the constraints for a generic type parameter.

---

#Modifier Keywords

These tokens act as keywords in modifier lists but can be used as identifiers elsewhere:

• abstract marks a class or member as abstract.
• actual denotes a platform-specific implementation in multiplatform projects.
• annotation declares an annotation class.
• companion declares a companion object.
• const marks a property as a compile-time constant.
• crossinline forbids non-local returns in a lambda.
• data instructs the compiler to generate canonical members for a class.
• enum declares an enumeration.
• expect marks a declaration as platform-specific.
• external marks a declaration as implemented outside of Kotlin (JNI/JS).
• final forbids overriding a member.
• infix allows calling a function using infix notation.
• inline tells the compiler to inline a function and its lambdas.
• inner allows referring to an outer class instance from a nested class.
• internal marks a declaration as visible in the current module.
• lateinit allows initializing a non-nullable property later.
• noinline turns off inlining for a specific lambda.
• open allows subclassing or overriding.
• operator marks a function as overloading an operator.
• out marks a type parameter as covariant.
• override marks a member as an override.
• private marks visibility as private to the class or file.
• protected marks visibility as private to the class and subclasses.
• public marks visibility as global.
• reified marks a type parameter as accessible at runtime.
• sealed declares a sealed class.
• suspend marks a function or lambda as usable as a coroutine.
• tailrec marks a function for tail-call optimization.
• vararg allows passing a variable number of arguments.

---

#Special Identifiers

• field is used inside a property accessor to refer to the backing field.
• it is used inside a lambda to refer to its parameter implicitly.

---

#Operators and Special Symbols