Document Text Contents
Page 1
Kotlin Language Documentation
Page 2
Table of Contents
Getting Started
Basic Syntax
Idioms
Coding Conventions
Basics
Basic Types
Packages
Control Flow
Returns and Jumps
Classes and Objects
Classes and Inheritance
Properties and Fields
Interfaces
Visibility Modifiers
Extensions
Data Classes
Generics
Generic functions
Generic constraints
Nested Classes
Enum Classes
Object Expressions and Declarations
Delegation
Delegated Properties
Functions and Lambdas
Functions
Higher-Order Functions and Lambdas
Inline Functions
Other
4
4
10
15
17
17
23
24
27
29
29
35
39
41
43
49
51
55
55
57
58
60
63
64
67
67
73
78
81
2
Page 75
The parameter less is of type (T, T) -> Boolean , i.e. a function that takes two parameters of type T and returns a
Boolean : true if the first one is smaller than the second one.
In the body, line 4, less is used as a function: it is called by passing two arguments of type T .
A function type is written as above, or may have named parameters, if you want to document the meaning of each parameter.
val compare: (x: T, y: T) -> Int = ...
The full syntactic form of lambda expressions, i.e. literals of function types, is as follows:
val sum = { x: Int, y: Int -> x + y }
A lambda expression is always surrounded by curly braces, parameter declarations in the full syntactic form go inside
parentheses and have optional type annotations, the body goes after an -> sign. If we leave all the optional annotations
out, what’s left looks like this:
val sum: (Int, Int) -> Int = { x, y -> x + y }
It’s very common that a lambda expression has only one parameter. If Kotlin can figure the signature out itself, it allows us
not to declare the only parameter, and will implicitly declare it for us under the name it :
ints.filter { it > 0 } // this literal is of type '(it: Int) -> Boolean'
Note that if a function takes another function as the last parameter, the lambda expression argument can be passed outside
the parenthesized argument list. See the grammar for callSuffix.
One thing missing from the lambda expression syntax presented above is the ability to specify the return type of the function.
In most cases, this is unnecessary because the return type can be inferred automatically. However, if you do need to specify
it explicitly, you can use an alternative syntax: an anonymous function.
fun(x: Int, y: Int): Int = x + y
An anonymous function looks very much like a regular function declaration, except that its name is omitted. Its body can be
either an expression (as shown above) or a block:
fun(x: Int, y: Int): Int {
return x + y
}
The parameters and the return type are specified in the same way as for regular functions, except that the parameter types
can be omitted if they can be inferred from context:
ints.filter(fun(item) = item > 0)
75
Page 76
The return type inference for anonymous functions works just like for normal functions: the return type is inferred
automatically for anonymous functions with an expression body and has to be specified explicitly (or is assumed to be
Unit ) for anonymous functions with a block body.
Note that anonymous function parameters are always passed inside the parentheses. The shorthand syntax allowing to
leave the function outside the parentheses works only for lambda expressions.
One other difference between lambda expressions and anonymous functions is the behavior of non-local returns. A return
statement without a label always returns from the function declared with the fun keyword. This means that a return inside
a lambda expression will return from the enclosing function, whereas a return inside an anonymous function will return
from the anonymous function itself.
A lambda expression or anonymous function (as well as a local function and an object expression) can access its closure,
i.e. the variables declared in the outer scope. Unlike Java, the variables captured in the closure can be modified:
var sum = 0
ints.filter { it > 0 }.forEach {
sum += it
}
print(sum)
Kotlin provides the ability to call a function literal with a specified receiver object. Inside the body of the function literal, you
can call methods on that receiver object without any additional qualifiers. This is similar to extension functions, which allow
you to access members of the receiver object inside the body of the function. One of the most important examples of their
usage is Type-safe Groovy-style builders.
The type of such a function literal is a function type with receiver:
sum : Int.(other: Int) -> Int
The function literal can be called as if it were a method on the receiver object:
1.sum(2)
The anonymous function syntax allows you to specify the receiver type of a function literal directly. This can be useful if you
need to declare a variable of a function type with receiver, and to use it later.
val sum = fun Int.(other: Int): Int = this + other
Lambda expressions can be used as function literals with receiver when the receiver type can be inferred from context.
76
Kotlin Language Documentation
Page 2
Table of Contents
Getting Started
Basic Syntax
Idioms
Coding Conventions
Basics
Basic Types
Packages
Control Flow
Returns and Jumps
Classes and Objects
Classes and Inheritance
Properties and Fields
Interfaces
Visibility Modifiers
Extensions
Data Classes
Generics
Generic functions
Generic constraints
Nested Classes
Enum Classes
Object Expressions and Declarations
Delegation
Delegated Properties
Functions and Lambdas
Functions
Higher-Order Functions and Lambdas
Inline Functions
Other
4
4
10
15
17
17
23
24
27
29
29
35
39
41
43
49
51
55
55
57
58
60
63
64
67
67
73
78
81
2
Page 75
The parameter less is of type (T, T) -> Boolean , i.e. a function that takes two parameters of type T and returns a
Boolean : true if the first one is smaller than the second one.
In the body, line 4, less is used as a function: it is called by passing two arguments of type T .
A function type is written as above, or may have named parameters, if you want to document the meaning of each parameter.
val compare: (x: T, y: T) -> Int = ...
The full syntactic form of lambda expressions, i.e. literals of function types, is as follows:
val sum = { x: Int, y: Int -> x + y }
A lambda expression is always surrounded by curly braces, parameter declarations in the full syntactic form go inside
parentheses and have optional type annotations, the body goes after an -> sign. If we leave all the optional annotations
out, what’s left looks like this:
val sum: (Int, Int) -> Int = { x, y -> x + y }
It’s very common that a lambda expression has only one parameter. If Kotlin can figure the signature out itself, it allows us
not to declare the only parameter, and will implicitly declare it for us under the name it :
ints.filter { it > 0 } // this literal is of type '(it: Int) -> Boolean'
Note that if a function takes another function as the last parameter, the lambda expression argument can be passed outside
the parenthesized argument list. See the grammar for callSuffix.
One thing missing from the lambda expression syntax presented above is the ability to specify the return type of the function.
In most cases, this is unnecessary because the return type can be inferred automatically. However, if you do need to specify
it explicitly, you can use an alternative syntax: an anonymous function.
fun(x: Int, y: Int): Int = x + y
An anonymous function looks very much like a regular function declaration, except that its name is omitted. Its body can be
either an expression (as shown above) or a block:
fun(x: Int, y: Int): Int {
return x + y
}
The parameters and the return type are specified in the same way as for regular functions, except that the parameter types
can be omitted if they can be inferred from context:
ints.filter(fun(item) = item > 0)
75
Page 76
The return type inference for anonymous functions works just like for normal functions: the return type is inferred
automatically for anonymous functions with an expression body and has to be specified explicitly (or is assumed to be
Unit ) for anonymous functions with a block body.
Note that anonymous function parameters are always passed inside the parentheses. The shorthand syntax allowing to
leave the function outside the parentheses works only for lambda expressions.
One other difference between lambda expressions and anonymous functions is the behavior of non-local returns. A return
statement without a label always returns from the function declared with the fun keyword. This means that a return inside
a lambda expression will return from the enclosing function, whereas a return inside an anonymous function will return
from the anonymous function itself.
A lambda expression or anonymous function (as well as a local function and an object expression) can access its closure,
i.e. the variables declared in the outer scope. Unlike Java, the variables captured in the closure can be modified:
var sum = 0
ints.filter { it > 0 }.forEach {
sum += it
}
print(sum)
Kotlin provides the ability to call a function literal with a specified receiver object. Inside the body of the function literal, you
can call methods on that receiver object without any additional qualifiers. This is similar to extension functions, which allow
you to access members of the receiver object inside the body of the function. One of the most important examples of their
usage is Type-safe Groovy-style builders.
The type of such a function literal is a function type with receiver:
sum : Int.(other: Int) -> Int
The function literal can be called as if it were a method on the receiver object:
1.sum(2)
The anonymous function syntax allows you to specify the receiver type of a function literal directly. This can be useful if you
need to declare a variable of a function type with receiver, and to use it later.
val sum = fun Int.(other: Int): Int = this + other
Lambda expressions can be used as function literals with receiver when the receiver type can be inferred from context.
76
