Что нового в 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. В файле класса такие члены будут подняты в соответствующий интерфейс и помечены как 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
    }
}

Функция main без параметров

По соглашению, точка входа в программу 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
}

Инструменты