Сегодня я решил написать о самых главных нововведениях в Kotlin 1.4.0. Думаю, что начинающим Android разработчикам будет очень интересна данная тема и они смогут применить новые фишки в своих приложениях. Также, я надеюсь, что моя статья будет полезна и для профессиональных разработчиков, которые очень любят и помогают развивать Kotlin.

Основные темы, которые я затрону:

• Нововведения в синтаксисе

• Новые инструменты в IDE

• Новый компилятор

• Качество и производительность

Ну что ж, предлагаю вам налить себе кофе или чай, запастись сладеньким и можно начинать)

Немного о релизах Kotlin

На момент написания статьи самыми новыми релизами были:

Нововведения в синтаксисе

SAM - интерфейсы

Одной из самых важных и довольно полезных фишек является добавление нового синтаксиса для SAM интерфейсов (SAM - Single Abstract Method, также интерфейс с одним методом называют функциональным).

Чтобы указать компилятору Kotlin о том, что перед нами SAM интерфейс нужно использовать ключевое слов fun, как ниже в примере:

fun interface ItemSelectListener {
		fun onItemSelect(position: Int): String
}

val items = listOf("Item 1", "Item 2", "Item 3")

val myListener = ItemSelectListener { position ->
		items[position]
}

fun main() {
    print("selected item -> ${myListener.onItemSelect(0)}")
}

Одно из применений: передача обработчиков событий в адаптер RecyclerView для отслеживания нажатия на элемент списка.

Данный подход сокращает количество строк кода и вводит дополнительные удобства.

Явный API режим

Kotlin предлагает новый явный API режим для разработчиков библиотек.

Основные моменты:

1. Явный API режим помогает делать API библиотек чистым и последовательным

2. Накладывает различные требования и ограничения на публичные API:

   1. Строгое использование модификаторов доступа

   2. Явное указание типов для свойств и функций, которые являются частью публичного API

3. Некоторые определения исключены из проверок: свойства data классов, первичные конструкторы и т.д.

Более подробно

Смешанные именованные и позиционные параметры

Довольно легко объяснить на примере. До Kotlin 1.4.0 нельзя было делать так:

fun foo(a: Int, b: String = "", c: Int) {}

fun main() {
		foo(a = 10, "Hello, World", c = 100000)
}

В данном примере мы сначала указываем именованный параметр, а потом позиционный (строка "Hello, World"). В ранних версиях Kotlin нужно было всегда указывать сначала позиционные.

Конечная запятая

Довольное удобно при обмене строк или копировании параметров функций

fun reformat(str: String, 
             wordSeparator: Char = ' ', // конечная запятая
) {
  // TODO
}

Улучшения вызываемых ссылок на функции

Теперь вы можете использовать ссылки на функции, которые имеют default аргументы:

fun foo(a: Int = 0): String = "value -> $a" // параметр 'a' имеет значение по умолчанию 0

fun apply(f: () -> String): String = f()

fun main() {
    println(apply(::foo))
}

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

Например у нас есть функция foo, которая принимает другую функцию, которая ничего не возращает (Unit). Мы можем передать ей любую ссылку на функцию, у которой совпадает количество аргументов, а возвращаемый тип может быть любой:

fun foo(f: () -> Unit) { }
fun returnValue(): Int = 42

fun main() {
    foo { returnValue() } // Так было до Kotlin 1.4.0
    foo(::returnValue) // начиная с Kotlin 1.4.0 можно передать сюда функцию, 
  									  // которая возвращает любой тип
}

Вы можете адаптировать ссылки на функции, когда передается переменное количество аргументов:

fun foo(a: Int, vararg words: String) {}

fun useCase0(f: (Int) -> Unit) {}
fun useCase1(f: (Int, String) -> Unit) {}
fun useCase2(f: (Int, String, String) -> Unit) {}

fun test() {
    useCase0(::foo) 
    useCase1(::foo) 
    useCase2(::foo) 
}

В дополнение появилась поддержка передачи ссылки на функцию там, где используется ключевое слово suspend

fun lockUI() {}
fun takeSuspend(f: suspend () -> Unit) {}

fun test() {
    takeSuspend { lockUI() } // до Kotlin 1.4.0
    takeSuspend(::lockUI) // В Kotlin 1.4.0 можно сделать так
}

Использование break and continue внутри when выражений, включенных в цикл for

В Kotlin 1.4.0 вы можете использовать ключевые слова break и continue в операторе when, когда он вложен в циклfor (до этого нужно было создавать метки, более подробно)

fun foo(numbers: List<Int>) {
    for (num in numbers) {
        when {
            num % 2 == 0 -> continue
            num == 10 -> break
            else -> println(x)
        }
    }
}

Новые инструменты в IDE

Новое гибкое окно создания проекта

Теперь вы можете создавать и конфигурировать различные типы проектов Kotlin более гибко и специфично:

Новое окно создания проекта позволяет:

1. Выбрать шаблон проекта (в будущем будет добавлено больше шаблонов)

2. Выбрать систему сборки (Gradle, Maven)

3. Посмотреть структуру проекта до его создания

4. Добавить/удалить модули, поддерживаемые данным шаблоном проекта

5. Настроить JVM версию, framework для тестирования и другие вещи.

Отладчик Корутин

Очень много разработчиков на Kotlin используют всеми известные корутины (а как же без них).

До Kotlin 1.4.0 приходилось полагаться на ведение логов и умственные усилия разработчика, чтобы отлаживать программы с наличием корутин.

Теперь появился новый инструмент, который находится в Debug Tool Window в Intellij IDEA, который позволяет:

1. Легко проверить состояние каждой корутины

2. Посмотреть значения локальных и захваченных переменных для корутин

3. Посмотреть полный стек создания корутины, а также стек внутри корутины (все фрэймы с локальными переменными)

4. Также можно получить полный отчет, воспользовавшись функцией Get Coroutines Dump

Новый компилятор

Главной целью создания нового компилятора было соответствие характеристикам:

1. Скорость

2. Создание общего интерфейса для разных платформ, которые поддерживает Kotlin

3. Обеспечение API для расширения компилятора

Основные улучшения по сравнению с предыдущим компилятором:

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

2. Унифицированный backend компилятора (в Kotlin есть несколько backend, таких как: Kotlin/JVM, Kotlin/JS и Kotlin/Native. Последний был основан на промежуточном представлении (IR) для Kotlin кода)

Сейчас компания JetBrains работает над более производительной frontend реализацией.

Frontend - это часть компилятора, которая разбирает код, разрешает имена, выполняет проверки типов и многое другое.

Качество и производительность

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

Основные улучшения:

1. Было исправлено более 60 ошибок производительности, включая большое количество случаев зависания IDE и утечек памяти

2. Прирост в скорости IDE, который можно увидеть, пройдя по ссылке (здесь время подсвечивания синтаксиса Kotlin при открытии большого проекта). Также на рисунке ниже показано время срабатывания автодополнения (которое уменьшилось по сравнению с предыдущими релизами)

3. И многие другие, которые напрямую связаны с созданием нового компилятора.

Немного полезных ссылок

1. Информация о релизе Kotlin 1.4.0 на блоге JetBrains

2. Нововведения на официальном сайте Kotlin

3. Kotlin 1.4.0 Online Event (на английском)

4. Статистика от StackOverflow Survey 2020

5. Cтатистика от JetBrains