Что нового в 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³² - 1

• kotlin.ULong: целое беззнаковое 64-битное число, значения от 0 до 2⁶⁴ - 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
}

Средства разработки