Алгебраические типы данных (ADT)

Алгебраические типы данных (ADT) могут быть созданы с помощью конструкции enum

Концепция enum

является достаточно общей, чтобы также поддерживать алгебраические типы данных (ADT) и их обобщенную версию (GADT). Вот пример, показывающий, как тип Option может быть представлен в виде ADT:

enum Option[+T]:
  case Some(x: T)
  case None

В этом примере создается Option

enum с параметром ковариантного типа T, состоящим из двух вариантов: Some и None. Some параметризуются параметром значения x; это сокращение для написания case класса, который расширяет Option. Поскольку None не параметризован, он обрабатывается как обычное значение enum.

Предложения extends

, которые были опущены в предыдущем примере, также могут быть указаны явно:

enum Option[+T]:
  case Some(x: T) extends Option[T]
  case None       extends Option[Nothing]

Как и в случае с обычными значениями enum

, case enum определяются в сопутствующем объекте перечисления, поэтому они называются Option.Some и Option.None (если только определения не "вытягиваются" при импорте):

Option.Some("hello")
// res0: Option[String] = Some(x = "hello")
Option.None
// res1: Option[Nothing] = None

Обратите внимание, что тип приведенных выше выражений всегда Option

. Как правило, тип case enum будет расширен до базового типа enum, если не ожидается более конкретный тип. Это тонкая разница по сравнению с обычными case class-ами. Классы, составляющие case enum, существуют, и их можно использовать, либо создав их непосредственно с помощью new, либо явно указав ожидаемый тип.

new Option.Some(2)
// res2: Some[Int] = Some(x = 2)
val x: Option.Some[Int] = Option.Some(3)
// x: Some[Int] = Some(x = 3)

Как и в других случаях использования перечисления, АТД могут определять дополнительные методы. Например, вот снова Option

с методом isDefined и конструктором Option(...) в сопутствующем объекте:

enum Option[+T]:
  case Some(x: T)
  case None

  def isDefined: Boolean = this match
    case None => false
    case Some(_) => true

object Option:
  def apply[T >: Null](x: T): Option[T] =
    if (x == null) None else Some(x)

Перечисления и ADT используют одну и ту же синтаксическую конструкцию, поэтому их можно рассматривать просто как два конца спектра, и вполне возможно создавать гибриды. Например, приведенный ниже код дает реализацию Color

либо с тремя значениями перечисления, либо с параметризованным case, который принимает значение RGB:

enum Color(val rgb: Int):
  case Red   extends Color(0xFF0000)
  case Green extends Color(0x00FF00)
  case Blue  extends Color(0x0000FF)
  case Mix(mix: Int) extends Color(mix)

Рекурсивные перечисления

До сих пор все перечисления состояли только из различных вариантов значений или case class-ов. Перечисления также могут быть рекурсивными, как показано в приведенном ниже примере кодирования натуральных чисел:

enum Nat:
  case Zero
  case Succ(n: Nat)

Например, значение Succ(Succ(Zero))

представляет число 2 в унарной кодировке. Очень похожим образом могут быть определены списки:

enum List[+A]:
  case Nil
  case Cons(head: A, tail: List[A])

Обобщенные алгебраические типы данных (GADT)

Приведенная выше нотация для перечислений очень лаконична и служит идеальной отправной точкой для моделирования типов данных. Также возможно выразить гораздо более мощные типы: обобщенные алгебраические типы данных (GADTs).

Вот пример GADT, где параметр типа (T

) определяет содержимое, хранящееся в поле:

enum Box[T](contents: T):
  case IntBox(n: Int) extends Box[Int](n)
  case BoolBox(b: Boolean) extends Box[Boolean](b)

Сопоставление с шаблоном в конкретном конструкторе (IntBox

или BoolBox) восстанавливает информацию о типе:

def extract[T](b: Box[T]): T = b match
  case IntBox(n)  => n + 1
  case BoolBox(b) => !b

Безопасно возвращать Int

только в первом случае, так как из сопоставления с шаблоном известно, что b был IntBox.

Дешугаризация перечислений

Концептуально перечисления можно рассматривать как определение sealed

класса вместе с сопутствующим объектом. Посмотрим на дешугаризацию перечисления Color:

sealed abstract class Color(val rgb: Int) extends scala.reflect.Enum
object Color:
  case object Red extends Color(0xFF0000) { def ordinal = 0 }
  case object Green extends Color(0x00FF00) { def ordinal = 1 }
  case object Blue extends Color(0x0000FF) { def ordinal = 2 }
  case class Mix(mix: Int) extends Color(mix) { def ordinal = 3 }

  def fromOrdinal(ordinal: Int): Color = ordinal match
    case 0 => Red
    case 1 => Green
    case 2 => Blue
    case _ => throw new NoSuchElementException(ordinal.toString)

Вышеописанная дешугаризация упрощена, детали доступны по ссылке.

Хотя перечисления можно кодировать вручную с помощью других конструкций, использование enum

является более кратким, а также включает несколько дополнительных утилит (таких как метод fromOrdinal).

Ссылки:

scalabook

Алгебраические типы данных (ADT)

Рекурсивные перечисления

Обобщенные алгебраические типы данных (GADT)

Дешугаризация перечислений

Использование cookies