Где мне это пригодится в жизни или применение Nothing в Kotlin на примере
О чем эта статья?
В данной статье я хочу показать, почему развитая система типов в языке программирования это здорово. Я подробно расскажу как устроен класс Either из библиотеки Arrow, разберу особенности системы типов Kotlin — sealed-иерархии, ковариантность и Nothing, без которых решение задачи становится практически невозможным.
Я попробую провести небольшой ликбез о таких на первый взгляд сложных вещах на понятном практическом примере.
Что такое Either?
Either — это класс, который содержит в себе значение одного из двух типов. По сути, это тип либо A, либо B (either A or B). Далее по тексту я буду делать акцент на фразе либо-либо, чтобы подчеркнуть, что речь идет о типах класса Either.
Важно: не путайте Either с типом пары (Pair), потому что пара содержит в себе два значения одновременно, а Either содержит одно значение одного из двух типов.
Где он может пригодиться? Давайте разбираться на примере.
Допустим, мы выполняем поход в сервис по API и хотим вернуть либо полезные данные, либо сообщить об ошибке, если во время вызова что-то пошло не так.
data class Data(val payload: String)
enum class Error {
UNAUTHORIZED,
FORBIDDEN,
BAD_REQUEST,
INTERNAL_ERROR;
}
interface MyService {
fun getData(): Either
} Мы определили класс Data, содержащий полезные данные, которые возвращаются в случае, если все прошло без ошибок.
Класс Error, который содержит перечисление возможных ошибок.
Интерфейс MyService с функцией getData, которая возвращает либо данные, либо ошибку.
По соглашению, тип ошибки обычно располагается слева и называется Left, а тип полезных данных называется Right и располагается справа (спасибо, кэп).
Казалось бы, в чем проблема? Можно реализовать тип просто в виде пары с проверкой ограничений в конструкторе.
class Either(val a: A?, val b: B?) {
init {
require(a == null && b == null || a != null && b != null) {
"Either should have only one value!"
}
}
}Проблема такого решения в том, что оно не обеспечивает типобезопасность. Мы хотим гарантировать, что предоставлено ровно одно значение, а другого не существует. В примере выше, это свойство проверяется во время исполнения и в случае его нарушения выкидывается исключение.
Еще одна проблема реализации выше — использование null для того, чтобы представить отсутствующее значение. Это ограничивает область применения нашего класса и запрещает использовать опциональные типы.
Если же написать типобезопасную реализацию этого класса, мы сможем гарантировать нужные нам свойства программы еще на этапе компиляции, а не во время исполнения, что снижает количество ошибок во время разработки.
Давайте рассмотрим приемы, необходимые для построения правильного класса Either.
Sealed классы и интерфейсы
Начнем с важной фичи системы типов Kotlin — это sealed-иерархии классов (они же алгебраические типы данных). Объявление класса или интерфейса с модификатором sealed запрещает создание наследников класса (или реализаций интерфейса) в других модулях и делает иерархию полностью известной на этапе компиляции.
Это, например, позволяет компилятору проверять ветки выражения when.
sealed interface Animal {
fun say()
}
class Cat : Animal {
override fun say() = println("meow")
fun purr() = println("cat can purr")
}
class Dog : Animal {
override fun say() = println("woof")
fun howl() = println("dog can howl")
}
fun test(animal: Animal) {
when (animal) {
is Cat -> animal.purr()
is Dog -> animal.howl()
}
}
fun main() {
test(Cat())
test(Dog())
}В данном примере за счет запечатанной (sealed) иерархии классов компилятор понимает, что выражение when перебрало все возможные варианты и нет необходимости в ветке else. При этом если появится какой-то новый наследник, то возникнет ошибка на этапе компиляции, а не во время выполнения.
Вернемся к нашему классу Either. У него всего два состояния — либо значение класса A, либо значение класса B. Попробуем представить его в виде sealed класса.
sealed class Either {
class Left(val a: A)//: Either
class Right(val b: B)//: Either
} Теперь у нашего класса существует два наследника (состояния) и мы на полпути к решению задачи. Однако сейчас они не являются наследниками Either, потому что не реализуют тип для значения B. Возникает проблема — как предоставить ровно одно значение, да еще и любого типа, который указал пользователь? Чтобы решить эту проблему, на помощь приходит ковариантность типов.
Ковариантность типов (in / out)
Ковариантность типов (как и инвариантость, и контрвариантность) используется в классах с generic-параметрами и показывает как именно они наследуются между собой.
В примере ниже, мы объявляем класс Desk с ковариантным параметром User. Это разрешает присваивания класса Desk с любым наследником класса User там, где ожидается Desk
open class User
class Manager : User()
class Engineer : User()
class Desk(val user: U)
fun main() {
val desk: Desk = Desk(Manager())
} Any? Nothing.
Еще одна особенность системы типов в Kotlin — наличие типов Any и Nothing.
С Any более менее все знакомы — это тип, который является родителем любого другого типа. А вот тип Nothing, его полная противоположность, встречается в современных языках программирования реже. Nothing — это тип, который является наследником любого типа.
Само по себе это не имеет смысла — понятно, что невозможно занаследовать все классы сразу, поэтому экземпляр Nothing не может быть создан. Сам класс имеет приватный конструктор, а тип означает значение, которое не существует. Например, функция, которая всегда кидает исключение, будет иметь тип возврата Nothing.
public class Nothing private constructor()Тогда отношение классов из предыдущего примера выглядит следующим образом.
И точно так же выглядит иерархия для классов с generic-параметром Desk за счет ковариантности.
Собираем воедино
Итак, теперь мы знаем, как представить значение, которое не существует и как разрешить подставлять тип-наследник вместо исходного типа за счет ковариантности.
Теперь, вооружившись всем необходимым, напишем свою итоговую реализацию Either.
sealed class Either {
class Left(val value: A): Either()
class Right(val value: B): Either()
}
fun main() {
val a: Either = Either.Left(null)
val b: Either = Either.Right("string")
} Сначала про использование. В примере видно, что в качестве Either
А теперь, рассмотрим три ключевых момента, почему все устроено именно так:
sealed class Either— у нашего класса Either всего два возможных состояния и других быть не может. Для реализации этого свойства и его гарантии на этапе компиляции отлично подходит sealed class.Either— именно за счет Nothing гарантируется, что если у нас есть значение A, то значения B быть не может и наоборот. Значение одного из типов — Nothing.
Именно сочетание этих трех приемов вместе и дает возможность реализовать типобезопасный класс Either.
Заключение
Мы рассмотрели несколько важных аспектов системы типов в Kotlin и смогли написать свою типобезопасную реализацию класса Either. Это моя первая статья, поэтому буду рад любому фидбэку :)
