Scala программирование уровня уровня - представление иерархии

Ответ 1

Существует множество способов представления гетерогенного дерева в Scala, причем одним из простейших является нечто вроде этого:

type MyTreeShape[A, B, C, D, E] = (A, (B, (C, D), E))

У этого есть некоторые ограничения, хотя (например, тот факт, что вы не можете иметь кортеж как значение листа, поскольку мы используем кортеж в нашем представлении). Для остальной части этого ответа я буду использовать несколько более сложное представление, включающее Shapeless HList:

import shapeless._

type MyTreeShape[A, B, C, D, E] =
  A ::
    (B ::
      (C :: HNil) ::
      (D :: HNil) ::
      HNil) ::
    (E :: HNil) ::
    HNil

Здесь дерево является HList, голова которого является значением, а хвост - HList дочерних деревьев.

Если мы хотим сделать что-то полезное с этими деревьями, нам понадобятся классы типов. В качестве примера я напишу краткую глубину FlattenTree по модели классов типов в пакете Shapeless ops.hlist. Другие типы классов для размера, глубины и т.д. Могут быть реализованы аналогичным образом.

Здесь класс типа и удобный метод, который упростит его использование:

trait FlattenTree[T <: HList] extends DepFn1[T] { type Out <: HList }

def flattenTree[T <: HList](t: T)(implicit f: FlattenTree[T]): f.Out = f(t)

Теперь для экземпляров, которые мы добавим в объект-компаньон:

object FlattenTree {
  type Aux[T <: HList, Out0 <: HList] = FlattenTree[T] { type Out = Out0 }

  implicit def flattenTree[H, T <: HList](implicit
    tf: FlattenForest[T]
  ): Aux[H :: T, H :: tf.Out] = new FlattenTree[H :: T] {
    type Out = H :: tf.Out

    def apply(t: H :: T): H :: tf.Out = t.head :: tf(t.tail)
  }
}

Обратите внимание, что для этого нужен класс вспомогательного типа, FlattenForest:

trait FlattenForest[F <: HList] extends DepFn1[F] { type Out <: HList }

object FlattenForest {
  type Aux[F <: HList, Out0 <: HList] = FlattenForest[F] { type Out = Out0 }

  implicit val hnilFlattenForest: Aux[HNil, HNil] = new FlattenForest[HNil] {
    type Out = HNil

    def apply(f: HNil): HNil = HNil
  }

  implicit def hconsFlattenForest[
    H <: HList,
    OutH <: HList,
    T <: HList,
    OutT <: HList
  ](implicit
    hf: FlattenTree.Aux[H, OutH],
    tf: Aux[T, OutT],
    pp: ops.hlist.Prepend[OutH, OutT]
  ): Aux[H :: T, pp.Out] = new FlattenForest[H :: T] {
    type Out = pp.Out

    def apply(f: H :: T): pp.Out = pp(hf(f.head), tf(f.tail))
  }
}

Теперь мы можем использовать его следующим образом:

val myTree: MyTreeShape[String, Int, Char, Symbol, Double] =
  "foo" :: (10 :: HList('a') :: HList('z) :: HNil) :: HList(0.0) :: HNil

val flattened = flattenTree(myTree)

И пусть показать статический тип уместно:

flattened: String :: Int :: Char :: Symbol :: Double :: HNil

И это именно то, что мы хотим.

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