Блог

Главная - Вопросы по программированию - Как уменьшить шаблонный код с помощью макросов Scala в Scala 2?

Как уменьшить шаблонный код с помощью макросов Scala в Scala 2?

#scala #shapeless #scala-macros

Вопрос:

Для такого кода существует множество стандартных кодов.

 object TupleFlatten {
  import shapeless._
  import ops.tuple.FlatMapper
  import syntax.std.tuple._

  trait LowPriorityFlat extends Poly1 {
    implicit def default[T] = at[T](Tuple1(_))
  }

  object Flat extends LowPriorityFlat {
    implicit def caseTuple1[P <: Tuple1[_]](implicit fm: FlatMapper[P, Flat.type]): Flat.Case[P] {
      type Result = FlatMapper[P, Flat.type]#Out
    } =
      at[P](_.flatMap(Flat))

    implicit def caseTuple2[P <: Tuple2[_, _]](implicit fm: FlatMapper[P, Flat.type]) =
      at[P](_.flatMap(Flat))

    implicit def caseTuple3[P <: Tuple3[_, _, _]](implicit fm: FlatMapper[P, Flat.type]) =
      at[P](_.flatMap(Flat))

    implicit def caseTuple4[P <: Tuple4[_, _, _, _]](implicit fm: FlatMapper[P, Flat.type]) =
      at[P](_.flatMap(Flat))
  }
}

Есть ли какой-либо способ автоматической генерации кода, как показано ниже, от Tuple1 до Tuple22 

 implicit def caseTupleN[P <: TupleN[???]](implicit fm: FlatMapper[P, Flat.type]) =
      at[P](_.flatMap(Flat))

Как это сделать?

Комментарии:

1. Как насчет использования вместо этого генератора источников?

Ответ №1:

Конечно, вы можете генерировать импликации, например, с помощью аннотации макросов

 import scala.annotation.{StaticAnnotation, compileTimeOnly}
import scala.language.experimental.macros
import scala.reflect.macros.blackbox

object Macros {

  @compileTimeOnly("enable macro annotations")
  class genImplicits(n: Int) extends StaticAnnotation {
    def macroTransform(annottees: Any*): Any = macro genImplicitsMacro.impl
  }

  object genImplicitsMacro {
    def impl(c: blackbox.Context)(annottees: c.Tree*): c.Tree = {
      import c.universe._
      val n = c.prefix.tree match {
        case q"new genImplicits(${n1: Int})" => n1
      }
      val implicits = (1 to n).map { k =>
        val undescores = Seq.fill(k)(tq"${TypeName("_")}")
        q"""
          implicit def ${TermName("caseTuple"   k)}[P <: _root_.scala.${TypeName("Tuple"   k)}[..$undescores]: _root_.shapeless.IsTuple](implicit
            fm: _root_.shapeless.ops.tuple.FlatMapper[P, this.type]
          ): this.Case.Aux[P, fm.Out] = this.at[P].apply[fm.Out](_.flatMap(this))
        """
      }
      annottees match {
        case q"$mods object $tname extends { ..$earlydefns } with ..$parents { $self => ..$body }" :: Nil =>
          q"""
            $mods object $tname extends { ..$earlydefns } with ..$parents { $self =>
              import _root_.shapeless.syntax.std.tuple._
              ..$implicits
              ..$body
            }
          """
      }
    }
  }
}

import Macros.genImplicits
import shapeless.Poly1

trait LowPriorityFlat extends Poly1 {
  implicit def default[T]: Case.Aux[T, Tuple1[T]] = at[T](Tuple1(_))
}

@genImplicits(4)
object Flat extends LowPriorityFlat

Flat(((1, (2, 3), (4, (5, 6, 7))), (8, 9))) // (1,2,3,4,5,6,7,8,9)

Компиляция Flat(((1, (2, 3), (4, (5, 6, 7))), (8, 9))) с @genImplicits(22) занимает слишком много времени, хотя @genImplicits(22) само по себе расширение происходит довольно быстро.

В качестве альтернативы вы можете использовать генерацию кода с бесформенным шаблоном, Scala genprod, sbt-шаблоном или Scalameta.

Но я не вижу, как это будет лучше, чем более простое определение, использующее просто бесформенное с привязкой к контексту IsTuple , а не верхнюю границу

 import shapeless.ops.tuple.FlatMapper
import shapeless.{IsTuple, Poly1}
import shapeless.syntax.std.tuple._

trait LowPriorityFlat extends Poly1 {
  implicit def default[T]: Case.Aux[T, Tuple1[T]] = at[T](Tuple1(_))
}

object Flat extends LowPriorityFlat {
  implicit def caseTuple[P: IsTuple](implicit fm: FlatMapper[P, Flat.type]): Case.Aux[P, fm.Out]  =
    at[P](_.flatMap(Flat))
}

Flat(((1, (2, 3), (4, (5, 6, 7))), (8, 9))) // (1,2,3,4,5,6,7,8,9)

или даже без границ

 import shapeless.ops.tuple.FlatMapper
import shapeless.{IsTuple, Poly1}

trait LowPriorityFlat extends Poly1 {
  implicit def default[T]: Case.Aux[T, Tuple1[T]] = at[T](Tuple1(_))
}

object Flat extends LowPriorityFlat {
  implicit def caseTuple[P](implicit fm: FlatMapper[P, Flat.type]): Case.Aux[P, fm.Out]  =
    at[P](fm(_))
}

Flat(((1, (2, 3), (4, (5, 6, 7))), (8, 9))) // (1,2,3,4,5,6,7,8,9)

Пожалуйста, обратите внимание, что использование возвращаемого типа импликаций с проекциями типа Flat.Case[P] { type Result = FlatMapper[P, Flat.type]#Out } aka Flat.Case.Aux[P, FlatMapper[P, Flat.type]#Out] иногда может привести к проблемам с неявным разрешением (если вы не знаете, что делаете). Лучше использовать типы, зависящие от пути, в типе возвращаемых значений . Flat.Case.Aux[P, fm.Out]

Метки: