Волшебство Kotlin
Покупка
Новинка
Тематика:
Программирование на Java
Издательство:
ДМК Пресс
Автор:
Сомон Пьер-Ив
Перевод:
Киселев А. Н.
Год издания: 2020
Кол-во страниц: 538
Возрастное ограничение: 12+
Дополнительно
Вид издания:
Практическое пособие
Уровень образования:
Дополнительное профессиональное образование
ISBN: 978-5-97060-801-2
Артикул: 882728.01.99
Kotlin — один из самых новых языков в экосистеме Java, устраняющий многие ограничения Java и гораздо более универсальный. Среди его преимуществ: полная совместимость с Java и возможность интеграции на уровне исходного кода, широкая поддержка парадигмы функционального программирования, помогающая писать надежный и безопасный код, лаконичность синтаксиса, а также, что весьма немаловажно, гарантии поддержки со стороны IT-гиганта Google.
Пьер-Ив Сомон, опытный разработчик на Java, в своей книге подробно освещает нюансы программирования на Kotlin, переходя от общего описания языка к его характерным особенностям и возможностям, включая приемы функционального программирования.
Издание предназначено для разработчиков, знакомых с Java и стремящихся повысить безопасность своих программ, а также упростить их написание, тестирование и сопровождение.
Скопировать запись
Фрагмент текстового слоя документа размещен для индексирующих роботов
Пьер-Ив Сомон Волшебство 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
Являются ли мемоизованные функции чистыми?...............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
Приемы использования типа 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