Keywords and operators

as

• is 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.

• is used as an infix operator to check that a value belongs to a range, a collection, or another entity that defines a 'contains' method.

• is used in when expressions for the same purpose.

• marks a type parameter as contravariant.

!in

• is used as an operator to check that a value does NOT belong to a range, a collection, or another entity that defines a 'contains' method.

• is used in when expressions for the same purpose.

interface declares an interface.

is

• checks that a value has a certain type.

• is used in when expressions for the same purpose.

!is

• checks that a value does NOT have a certain type.

• is 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).

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.

actual denotes a platform-specific implementation in multiplatform projects.

abstract marks a class or member as abstract.

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 passed to an inline function.

data instructs the compiler to generate canonical members for a class.

enum declares an enumeration.

expect marks a declaration as platform-specific, expecting an implementation in platform modules.

external marks a declaration as implemented outside of Kotlin (accessible through JNI or in JavaScript).

final forbids overriding a member.

infix allows calling a function using infix notation.

inline tells the compiler to inline a function and the lambdas passed to it at the call site.

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-null property outside of a constructor.

noinline turns off inlining of a lambda passed to an inline function.

open allows subclassing a class or overriding a member.

operator marks a function as overloading an operator or implementing a convention.

out marks a type parameter as covariant.

override marks a member as an override of a superclass member.

private marks a declaration as visible in the current class or file.

protected marks a declaration as visible in the current class and its subclasses.

public marks a declaration as visible anywhere.

reified marks a type parameter of an inline function as accessible at runtime.

sealed declares a sealed class (a class with restricted subclassing).

suspend marks a function or lambda as suspending (usable as a coroutine).

tailrec marks a function as tail-recursive (allowing the compiler to replace recursion with iteration).

vararg allows passing a variable number of arguments for a parameter.

field is used inside a property accessor to refer to the backing field of the property.

it is used inside a lambda to refer to its parameter implicitly.

+, -, *, /, %- mathematical operators

• * is also used to pass an array to a vararg parameter.

=

• assignment operator.

• is used to specify default values for parameters.

+=, -=, *=, /=, %=- augmented assignment operators.

++, --- increment and decrement operators.

&&, ||, !- logical 'and', 'or', 'not' operators (for bitwise operations, use the corresponding infix functions instead).

==, !=- equality operators (translated to calls of equals() for non-primitive types).

===, !==- referential equality operators.

<, >, <=, >=- comparison operators (translated to calls of compareTo() for non-primitive types).

[, ]- indexed access operator (translated to calls of get and set).

!! asserts that an expression is non-null.

?. performs a safe call (calls a method or accesses a property if the receiver is non-null).

?: takes the right-hand value if the left-hand value is null (the elvis operator).

:: creates a member reference or a class reference.

.. creates a range.

: separates a name from a type in a declaration.

? marks a type as nullable.

->

• separates the parameters and body of a lambda expression.

• separates the parameters and return type declaration in a function type.

• separates the condition and body of a when expression branch.

@

• introduces an annotation.

• introduces or references a loop label.

• introduces or references a lambda label.

• references a 'this' expression from an outer scope.

• references an outer superclass.

; separates multiple statements on the same line.

$ references a variable or expression in a string template.

_

• substitutes an unused parameter in a lambda expression.

• substitutes an unused parameter in a destructuring declaration.