Что нового в Kotlin 1.3

Выпуск сопроцедур

После длительных и обширных испытаний сопроцедуры теперь выпущены! Это означает, что начиная с Kotlin 1.3 поддержка языка и API являются полностью стабильными. Ознакомьтесь с новой страницей обзора сопроцедур.

Kotlin 1.3 включает вызываемые ссылки на приостановленные функции и поддержку сопроцедур в API рефлексии.

Kotlin/Native

Kotlin 1.3 продолжает улучшать и дорабатывать целевую платформу Native. Подробности см. в обзоре Kotlin/Native.

Многоплатформенные проекты

В версии 1.3 мы полностью переработали модель многоплатформенных проектов для повышения выразительности и гибкости, а также для упрощения совместного использования общего кода. Кроме того, Kotlin/Native теперь поддерживается как одна из платформ!

Основные отличия от старой модели:

• В старой модели общий и платформоспецифичный код необходимо было размещать в отдельных модулях, связанных expectedBy зависимостями. Теперь общий и платформоспецифичный код размещаются в разных корневых каталогах одного модуля, что упрощает настройку проектов.

• Теперь имеется большое количество предустановленных конфигураций платформ для различных поддерживаемых платформ.

• Изменена конфигурация зависимостей; теперь зависимости указываются отдельно для каждого корневого каталога.

• Наборы исходного кода теперь можно совместно использовать между произвольным подмножеством платформ (например, в модуле, который ориентирован на JS, Android и iOS, вы можете иметь набор исходного кода, который совместно используется только между Android и iOS).

• Публикация многоплатформенных библиотек теперь поддерживается.

Для получения дополнительной информации см. документацию по многоплатформенному программированию.

Контракты

Компилятор Kotlin выполняет обширный статический анализ для предоставления предупреждений и сокращения рутинной работы. Одна из наиболее заметных особенностей — интеллектуальные преобразования типов — с возможностью автоматического выполнения преобразования на основе выполненных проверок типов:

fun foo(s: String?) {
    if (s != null) s.length // Compiler automatically casts 's' to 'String'
}

Однако, как только эти проверки извлекаются в отдельную функцию, все интеллектуальные преобразования типов сразу исчезают:

fun String?.isNotNull(): Boolean = this != null

fun foo(s: String?) {
    if (s.isNotNull()) s.length // No smartcast :(
}

Чтобы улучшить поведение в таких случаях, Kotlin 1.3 вводит экспериментальный механизм под названием контракты.

Контракты позволяют функции явно описать свое поведение таким образом, чтобы это понимал компилятор. В настоящее время поддерживаются две широкие категории случаев:

• Улучшение анализа интеллектуальных преобразований типов путём объявления связи между результатом вызова функции и значениями переданных аргументов:

fun require(condition: Boolean) {
    // This is a syntax form which tells the compiler:
    // "if this function returns successfully, then the passed 'condition' is true"
    contract { returns() implies condition }
    if (!condition) throw IllegalArgumentException(...)
}

fun foo(s: String?) {
    require(s is String)
    // s is smartcast to 'String' here, because otherwise
    // 'require' would have thrown an exception
}

• Улучшение анализа инициализации переменных при наличии функций высшего порядка:

fun synchronize(lock: Any?, block: () -> Unit) {
    // It tells the compiler:
    // "This function will invoke 'block' here and now, and exactly one time"
    contract { callsInPlace(block, EXACTLY_ONCE) }
}

fun foo() {
    val x: Int
    synchronize(lock) {
        x = 42 // Compiler knows that lambda passed to 'synchronize' is called
               // exactly once, so no reassignment is reported
    }
    println(x) // Compiler knows that lambda will be definitely called, performing
               // initialization, so 'x' is considered to be initialized here
}

//sampleStart
fun bar(x: String?) {
    if (!x.isNullOrEmpty()) {
        println("length of '$x' is ${x.length}") // Yay, smartcast to not-null!
    }
}
//sampleEnd
fun main() {
    bar(null)
    bar("42")
}

fun String?.isNullOrEmpty(): Boolean {
    contract {
        returns(false) implies (this@isNullOrEmpty != null)
    }
    return this == null || isEmpty()
}

Переменная для объекта в выражении when

В Kotlin 1.3 теперь можно поместить when объект в переменную:

fun Request.getBody() =
        when (val response = executeRequest()) {
            is Success -> response.body
            is HttpError -> throw HttpException(response.status)
        }

Хотя это уже было возможно, выделить эту переменную непосредственно перед when, val в when имеет правильно ограниченную область действия в теле when, тем самым предотвращая загрязнение пространства имён. Полную документацию по when см. здесь.

@JvmStatic и @JvmField в компаньонах интерфейсов

В Kotlin 1.3 можно пометить члены companion объекта интерфейсов аннотациями @JvmStatic и @JvmField. В файле class-файла такие члены будут подняты до соответствующего интерфейса и помечены как static.

Например, следующий код Kotlin:

interface Foo {
    companion object {
        @JvmField
        val answer: Int = 42

        @JvmStatic
        fun sayHello() {
            println("Hello, world!")
        }
    }
}

Эквивалентен следующему коду Java:

interface Foo {
    public static int answer = 42;
    public static void sayHello() {
        // ...
    }
}

Вложенные объявления в аннотационных классах

В Kotlin 1.3 аннотации могут содержать вложенные классы, интерфейсы, объекты и компаньоны:

annotation class Foo {
    enum class Direction { UP, DOWN, LEFT, RIGHT }
    
    annotation class Bar

    companion object {
        fun foo(): Int = 42
        val bar: Int = 42
    }
}

Главная функция без параметров

По соглашению, точкой входа в Kotlin-программе является функция с сигнатурой, подобной main(args: Array<String>), где args представляют аргументы командной строки, переданные программе. Однако не каждое приложение поддерживает аргументы командной строки, поэтому этот параметр часто оказывается неиспользуемым.

Kotlin 1.3 ввёл более простой вид main, который не принимает параметров. Теперь "Hello, World" на Kotlin короче на 19 символов!

fun main() {
    println("Hello, world!")
}

Функции с большой арностью

В Kotlin функциональные типы представлены как обобщённые классы, принимающие разное количество параметров: Function0<R>, Function1<P0, R>, Function2<P0, P1, R>, ... Этот подход имеет проблему, заключающуюся в том, что этот список конечен, и в настоящее время заканчивается Function22.

Kotlin 1.3 снимает это ограничение и добавляет поддержку функций с большей арностью:

fun trueEnterpriseComesToKotlin(block: (Any, Any, ... /* 42 more */, Any) -> Any) {
    block(Any(), Any(), ..., Any())
}

Режим поэтапного улучшения

Kotlin уделяет большое внимание стабильности и обратной совместимости кода: политика совместимости Kotlin гласит, что изменения, нарушающие обратную совместимость (например, изменение, которое делает код, который раньше компилировался, теперь не компилируется), могут быть внесены только в крупных выпусках (1.2, 1.3 и т.д.).

Мы считаем, что многие пользователи могли бы использовать более быстрый цикл, где критические исправления ошибок компилятора появляются немедленно, делая код более безопасным и правильным. Поэтому Kotlin 1.3 вводит режим компилятора поэтапного улучшения, который можно включить, передав аргумент -progressive компилятору.

В режиме поэтапного улучшения некоторые исправления семантики языка могут появиться немедленно. Все эти исправления обладают двумя важными свойствами:

• Они сохраняют обратную совместимость исходного кода со старыми компиляторами, что означает, что весь код, который можно скомпилировать с прогрессивным компилятором, будет без проблем компилироваться и с обычным.

• Они лишь делают код более безопасным в некотором смысле — например, некоторые некорректные интеллектуальные преобразования типов могут быть запрещены, поведение сгенерированного кода может быть изменено для повышения предсказуемости/стабильности и так далее.

Включение режима поэтапного улучшения может потребовать переписывания части вашего кода, но это не должно быть слишком сложно — все исправления, включенные в режиме поэтапного улучшения, тщательно отобраны, проверены и снабжены инструментальными средствами для миграции. Мы ожидаем, что режим поэтапного улучшения станет хорошим выбором для всех активно поддерживаемых кодовых баз, которые быстро обновляются до последних версий языка.

Встроенные классы

Kotlin 1.3 вводит новый тип объявления — inline class. Встроенные классы можно рассматривать как ограниченную версию обычных классов, в частности, встроенные классы должны иметь ровно одно свойство:

inline class Name(val s: String)

Компилятор Kotlin будет использовать это ограничение для агрессивной оптимизации представления встроенных классов на этапе выполнения и замены их экземпляров значением базового свойства, где это возможно, удаляя вызовы конструкторов, нагрузку на сборщик мусора и позволяя проводить другие оптимизации:

inline class Name(val s: String)
//sampleStart
fun main() {
    // In the next line no constructor call happens, and
    // at the runtime 'name' contains just string "Kotlin"
    val name = Name("Kotlin")
    println(name.s) 
}
//sampleEnd

См. справочник по встроенным классам для получения подробной информации.

Целочисленные без знака

Kotlin 1.3 вводит типы целочисленных значений без знака:

• kotlin.UByte: целочисленное значение без знака 8 бит, значения от 0 до 255

• kotlin.UShort: целочисленное значение без знака 16 бит, значения от 0 до 65535

• kotlin.UInt: целочисленное значение без знака 32 бит, значения от 0 до 2^32 - 1

• kotlin.ULong: целочисленное значение без знака 64 бит, значения от 0 до 2^64 - 1

Большинство функций для знаковых типов также поддерживаются для их аналогов без знака:

fun main() {
//sampleStart
// You can define unsigned types using literal suffixes
val uint = 42u 
val ulong = 42uL
val ubyte: UByte = 255u

// You can convert signed types to unsigned and vice versa via stdlib extensions:
val int = uint.toInt()
val byte = ubyte.toByte()
val ulong2 = byte.toULong()

// Unsigned types support similar operators:
val x = 20u + 22u
val y = 1u shl 8
val z = "128".toUByte()
val range = 1u..5u
//sampleEnd
println("ubyte: $ubyte, byte: $byte, ulong2: $ulong2")
println("x: $x, y: $y, z: $z, range: $range")
}

Подробности см. в справочнике.

@JvmDefault

Kotlin поддерживает широкий спектр версий Java, включая Java 6 и Java 7, где методы по умолчанию в интерфейсах не разрешены. Для удобства компилятор Kotlin обходит это ограничение, но это решение несовместимо с default методами, введёнными в Java 8.

Это может быть проблемой для межплатформенной совместимости с Java, поэтому Kotlin 1.3 вводит аннотацию @JvmDefault. Методы, помеченные этой аннотацией, будут генерироваться как default методы для JVM:

interface Foo {
    // Will be generated as 'default' method
    @JvmDefault
    fun foo(): Int = 42
}

Стандартная библиотека

import kotlin.random.Random

fun main() {
//sampleStart
    val number = Random.nextInt(42)  // number is in range [0, limit)
    println(number)
//sampleEnd
}

fun main() {
//sampleStart
    val sourceArr = arrayOf("k", "o", "t", "l", "i", "n")
    val targetArr = sourceArr.copyInto(arrayOfNulls<String>(6), 3, startIndex = 3, endIndex = 6)
    println(targetArr.contentToString())
    
    sourceArr.copyInto(targetArr, startIndex = 0, endIndex = 3)
    println(targetArr.contentToString())
//sampleEnd
}

fun main() {
//sampleStart
    val keys = 'a'..'f'
    val map = keys.associateWith { it.toString().repeat(5).capitalize() }
    map.forEach { println(it) }
//sampleEnd
}

fun main() {
//sampleStart
    fun printAllUppercase(data: List<String>) {
        val result = data
        .filter { it.all { c -> c.isUpperCase() } }
            .ifEmpty { listOf("<no uppercase>") }
        result.forEach { println(it) }
    }
    
    printAllUppercase(listOf("foo", "Bar"))
    printAllUppercase(listOf("FOO", "BAR"))
//sampleEnd
}

fun main() {
//sampleStart
    val s = "    \n"
    println(s.ifBlank { "<blank>" })
    println(s.ifBlank { null })
//sampleEnd
}

Инструменты