Волшебство Kotlin

Пьер-Ив Сомон

Волшебство Kotlin

The Joy of Kotlin

PIERRE-YVES SAUMONT

Волшебство Kotlin

ПЬЕР-ИВ СОМОН

Москва, 2020

УДК 004.43Kotlin
ББК 32.972
С61

Сомон. П.-И.
С61 
Волшебство Kotlin / пер. с англ. А. Н. Киселева. – М.: ДМК Пресс, 2020. – 536 с.: 
ил. 

ISBN 978-5-97060-801-2

Kotlin – один из самых новых языков в экосистеме Java, устраняющий многие 
ограничения Java и гораздо более универсальный. Среди его преимуществ: полная 
совместимость с Java и возможность интеграции на уровне исходного кода, широкая 
поддержка парадигмы функционального программирования, помогающая писать 
надежный и безопасный код, лаконичность синтаксиса, а также, что весьма немаловажно, гарантии поддержки со стороны IT-гиганта Google.
Пьер-Ив Сомон, опытный разработчик на Java, в своей книге подробно освещает 
нюансы программирования на Kotlin, переходя от общего описания языка к его 
характерным особенностям и возможностям, включая приемы функционального 
программирования.
Издание предназначено для разработчиков, знакомых с Java и стремящихся повысить безопасность своих программ, а также упростить их написание, тестирование 
и сопровождение.

УДК 004.43Kotlin
ББК 32.972

Original English language edition published by Manning Publications USA, USA. Copyright © 2018 
by Manning Publications Co. Russian-language edition copyright © 2020 by DMK Press. All rights 
reserved.

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

ISBN 978-1-617-29536-2 (англ.) 
 Copyright © 2018 by Manning Publications Co.
ISBN 978-5-97060-801-2 (рус.) 
© Оформление, издание, перевод, ДМК Пресс, 2020

Оглавление

 1  Создание безопасных программ ...........................................................31
 2  Функциональное программирование на Kotlin: обзор ........................46
 3  Программирование с функциями .........................................................81
 4  Рекурсия, сорекурсия и мемоизация ..................................................120
 5  Обработка данных с использованием списков ..................................161
 6  Необязательные данные ......................................................................197
 7  Обработка ошибок и исключений .......................................................222
 8  Дополнительные операции со списками ............................................248
 9  Ленивые вычисления ...........................................................................282
 10  Обработка данных с использованием деревьев .................................323
 11  Решение задач с использованием усовершенствованных деревьев ...363
 12  Функциональный ввод/вывод .............................................................392
 13  Общее изменяемое состояние и акторы .............................................420
 14  Решение типичных проблем функциональным способом ................448

Содержание

Оглавление .....................................................................................................5
Предисловие .................................................................................................15
Благодарности ............................................................................................19
О книге .........................................................................................................20
Об авторе ....................................................................................................28
Об иллюстрации на обложке .......................................................................29

1 

Создание безопасных программ ..............................................31
1.1 
Программные ловушки ................................................................33
1.1.1 Безопасная обработка эффектов ..........................................35
1.1.2 Увеличение безопасности программ за счет ссылочной  
 
прозрачности .........................................................................36

1.2 
Выгоды безопасного программирования ................................37
1.2.1 Использование подстановочной модели в рассуждениях  
 
о программе ............................................................................39
1.2.2 Применение принципов соблюдения безопасности  
 
на простом примере ..............................................................40
1.2.3 Максимальное использование абстракций ............................44

Итоги ..........................................................................................................45

2 

Функциональное программирование на Kotlin:  
 
обзор .........................................................................................................46
2.1 
Поля и переменные в Kotlin ........................................................47
2.1.1 Тип можно опустить для простоты .....................................47
2.1.2 Изменяемые поля ...................................................................47
2.1.3 Отложенная инициализация .................................................48

2.2 
Классы и интерфейсы в Kotlin ....................................................49
2.2.1 Еще большее сокращение кода ...............................................51
2.2.2 Реализация интерфейса или расширение класса ..................51

Содержание

2.2.3 Создание экземпляра класса ..................................................52
2.2.4 Перегрузка конструкторов ....................................................52
2.2.5 Создание методов equals и hashCode .....................................53
2.2.6 Деструктуризация объектов данных ....................................55
2.2.7 Реализация статических членов в Kotlin ...............................55
2.2.8 Синглтоны .............................................................................56
2.2.9 Предотвращение создания экземпляров служебных  
 
классов ....................................................................................56

2.3 
В Kotlin нет элементарных типов ..............................................57

2.4 
Два типа коллекций в Kotlin .......................................................57

2.5 
Пакеты в Kotlin ...............................................................................59

2.6 
Видимость в Kotlin  .......................................................................60

2.7 
Функции в Kotlin ............................................................................61
2.7.1 
Объявление функций ...............................................................61
2.7.2 
Локальные функции ................................................................62
2.7.3 
Переопределение функций ......................................................63
2.7.4 
Функции-расширения .............................................................63
2.7.5 
Лямбда-выражения ................................................................64

2.8 
Пустое значение null в Kotlin ......................................................66
2.8.1 Приемы работы с типами, поддерживающими null .............66
2.8.2 Оператор Элвис и значение по умолчанию ............................67

2.9 
Поток выполнения программы и управляющие  
 
структуры ........................................................................................67
2.9.1 Условная конструкция ...........................................................68
2.9.2 Использование конструкций с несколькими условиями .........69
2.9.3 Циклы .....................................................................................70
2.9.4 Какие проблемы может вызывать поддержка  
 
вариантности? ......................................................................76
2.9.5 Когда использовать объявления ковариантности  
 
и контрвариантности ..........................................................77
2.9.6 Объявление вариантности в точке определения  
 
и точке использования ...........................................................78

Итоги ..........................................................................................................79

3 

Программирование с функциями ...........................................81
3.1 
Что такое функция? ......................................................................82
3.1.1 Отношения между двумя областями функций .....................83
3.1.2 Обратные функции в Kotlin ...................................................84
3.1.3 Частичные функции ...............................................................85
3.1.4 Композиция функций ..............................................................86
3.1.5 Функции нескольких аргументов ...........................................86
3.1.6 Каррирование функций ..........................................................87
3.1.7 Частично-примененные функции ..........................................87
3.1.8 Функции не имеют эффектов ................................................88

3.2 
Функции в Kotlin ............................................................................89

Содержание

3.2.1 Функции как данные ...............................................................89
3.2.2 Данные как функции ...............................................................89
3.2.3 Конструкторы объектов как функции ..................................89
3.2.4 Использование функций fun в Kotlin .......................................90
3.2.5 Объектная и функциональная нотация ................................93
3.2.6 Использование функций как значений ...................................94
3.2.7 Ссылки на функции .................................................................96
3.2.8 Композиция функций fun ........................................................97
3.2.9 Повторное использование функций .......................................98

3.3 
Дополнительные особенности функций ..................................99
3.3.1 Функции с несколькими аргументами? .................................99
3.3.2 Применение каррированных функций ..................................100
3.3.3 Реализация функций высшего порядка .................................100
3.3.4 Полиморфные функции высшего порядка ............................102
3.3.5 Анонимные функции .............................................................104
3.3.6 Локальные функции ..............................................................106
3.3.7 Замыкания ............................................................................106
3.3.8 Частичное применение функций и автоматическое  
 
каррирование .......................................................................107
3.3.9 Перестановка аргументов частично примененных  
 
функций ................................................................................112

Итоги ........................................................................................................119

4 

Рекурсия, сорекурсия и мемоизация ...................................120
4.1 
Рекурсия и сорекурсия ...............................................................121
4.1.1 Реализация сорекурсии .........................................................121
4.1.2 Реализация рекурсии ............................................................123
4.1.3 Различия между рекурсивными и сорекурсивными  
 
функциями ............................................................................124
4.1.4 Выбор между рекурсией и сорекурсией .................................125

4.2 
Удаление хвостового вызова ....................................................127
4.2.1 Использование механизма удаления хвостового вызова .....128
4.2.2 Преобразование циклов в хвостовую рекурсию ...................128
4.2.3 Рекурсивные функции-значения ...........................................132

4.3 
Рекурсивные функции и списки ..............................................135
4.3.1 Дважды рекурсивные функции .............................................137
4.3.2 Абстракция рекурсии в списках ...........................................140
4.3.3 Обращение списка ................................................................143
4.3.4 Сорекурсивные списки ..........................................................145
4.3.5 Опасность строгости..........................................................149

4.4 
Мемоизация .................................................................................149
4.4.1 Мемоизация в программировании на основе циклов ...........149
4.4.2 Мемоизация рекурсивных функций ......................................150
4.4.3 Неявная мемоизация ............................................................152
4.4.4 Автоматическая мемоизация .............................................154
4.4.5 Мемоизация функций нескольких аргументов ....................157

Содержание

4.5 
Являются ли мемоизованные функции чистыми? ..............159

Итоги ........................................................................................................159

5 

Обработка данных с использованием списков .............161
5.1 
Классификация коллекций данных ........................................162

5.2 
Разные типы списков .................................................................162

5.3 
Производительность списков ...................................................164
5.3.1 Время в обмен на объем памяти и сложность ....................165
5.3.2 Отказ от изменения на месте ............................................165

5.4 
Какие виды списков доступны в Kotlin? ................................167
5.4.1 Использование постоянных структур данных ....................168
5.4.2 Реализация неизменяемого, постоянного, 
односвязного списка ........................................................................168

5.5 
Совместное использование данных в операциях  
 
со списками ..................................................................................172

5.6 
Дополнительные операции со списками ...............................174
5.6.1 Преимущества объектной нотации ....................................175
5.6.2 Объединение списков ............................................................178
5.6.3 Удаление элементов с конца списка ....................................180
5.6.4 Использование рекурсии для свертки списков  
 
с помощью функций высшего порядка ..................................181
5.6.5 Вариантность .....................................................................182
5.6.6 Безопасная рекурсивная версия foldRight .............................191
5.6.7 Отображение и фильтрация списков ..................................193

Итоги ........................................................................................................196

6 

Необязательные данные ............................................................197
6.1 
Проблемы с пустым указателем ..............................................198

6.2 
Как пустые ссылки обрабатываются в Kotlin ........................201

6.3 
Альтернативы пустым ссылкам ...............................................202

6.4 
Тип Option .....................................................................................205
6.4.1 Извлечение значения из Option ............................................207
6.4.2 Применение функций к необязательным значениям ...........209
6.4.3 Композиция функций с типом Option ..................................210
6.4.4 Примеры использования Option ...........................................212
6.4.5 Другие способы комбинирования типа Options ...................215
6.4.6 Комбинирование List и Option ..............................................218
6.4.7 Когда и как использовать тип Option .................................220

Итоги ........................................................................................................221

7 

Обработка ошибок и исключений ........................................222
7.1 
Проблемы с отсутствующими данными ................................223

7.2 
Тип Either ......................................................................................224

7.3 
Тип Result ......................................................................................227

Содержание

7.4 
Приемы использования типа Result .......................................230

7.5 
Дополнительные способы использования Result ................236
7.5.1 
Применение предикатов ......................................................236

7.6 
Преобразование ошибок ...........................................................238

7.7 
Дополнительные фабричные функции ..................................239

7.8 
Применение эффектов ...............................................................240

7.9 
Дополнительные способы комбинирования с типом  
 
Result ..............................................................................................243

Итоги ........................................................................................................247

8 

Дополнительные операции со списками ..........................248
8.1 
Проблемы функции length ........................................................249

8.2 
Проблема производительности ...............................................249

8.3 
Преимущества мемоизации .....................................................250
8.3.1 Недостатки мемоизации.....................................................250
8.3.2 Оценка увеличения производительности ............................252

8.4 
Комбинирование List и Result ..................................................253
8.4.1 Списки, возвращающие Result ..............................................253
8.4.2 Преобразование List<Result> в Result<List> ..........................255

8.5 
Абстракции операций со списками ........................................257
8.5.1 Упаковка и распаковка списков ............................................258
8.5.2 Доступ к элементам по индексам .......................................261
8.5.3 Разбиение списков ................................................................266
8.5.4 Поиск подсписков .................................................................270
8.5.5 Разные функции для работы со списками ............................271

8.6 
Автоматическое распараллеливание операций  
 
со списками ..................................................................................276
8.6.1 Не все вычисления могут выполняться параллельно ..........276
8.6.2 Деление списка на подсписки ...............................................276
8.6.3 Параллельная обработка подсписков ..................................278

Итоги ........................................................................................................280

9 

Ленивые вычисления .....................................................................282
9.1 
Строгий и ленивый подходы ....................................................283

9.2 
Строгие вычисления в Kotlin ....................................................284

9.3 
Ленивые вычисления в Kotlin ...................................................286

9.4 
Реализация ленивых вычислений ...........................................288
9.4.1 Комбинирование ленивых значений .....................................290
9.4.2 Преобразование обычных функций в ленивые ......................294
9.4.3 Отображение ленивых значений .........................................296
9.4.4 Комбинирование типов Lazy и List ......................................298
9.4.5 Обработка исключений ........................................................299

9.5 
Другие способы комбинирования ленивых  
 
вычислений ..................................................................................302