0

假设我有以下代码：

trait Trait[T <: Trait[T]] {
  def merge(t: T): T
}

case class A[T <: Trait[T]](t: T, i: Int)
case class B[T <: Trait[T]](t: T, str: String)

有没有办法可以定义一种类型来缩写我对 A 类和 B 类的定义？

所以像：

type T2 = _ <: Trait[T2] // ???
case class A[T2](t: T2, i: Int)
case class B[T2](t: T2, str: String)
4

1 回答 1

3

实际上，你不想要一个类型的别名，你想要一个绑定的别名。

请参阅如何避免重复在 Scala 中绑定的类型

简而言之，您应该在任何需要的地方保留 F-bounds。实际上，这不是代码重复。T, Trait,A的类型参数B实际上是三个不同的类型参数，可以有不同的界限。

但是理论上你可以用宏注解来缩写 bounds ，虽然这不值得而且通常是危险的，因为这可能会让你的队友感到惊讶，会使调试变得更加复杂，并且会混淆你的 IDE

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

@compileTimeOnly("enable macro annotations")
class fbound extends StaticAnnotation {
  def macroTransform(annottees: Any*): Any = macro FBoundMacro.impl
}

object FBoundMacro {
  def impl(c: blackbox.Context)(annottees: c.Tree*): c.Tree = {
    import c.universe._

    def addFBound(tparam: Tree): Tree = tparam match {
      case q"$mods type $name[..$tparams] >: $low <: $high" =>
        val tparamsNames = tparams.map {
          case q"$_ type $nme[..$_] >: $_ <: $_" => nme
        }
        val fBound = tq"Trait[$name[..$tparamsNames]]"
        val high1 = high match {
          case tq"$EmptyTree" => fBound
          case tq"..$withTypes { ..$refinements }" =>
            val withTypes1 = withTypes :+ fBound
            tq"..$withTypes1 { ..$refinements }"
          case tq"$typ" => tq"$typ with $fBound"
        }
        q"$mods type $name[..$tparams] >: $low <: $high1"
    }

    annottees match {
      case q"$mods class $tpname[..$tparams] $ctorMods(...$paramss) extends { ..$earlydefns } with ..$parents { $self => ..$stats }" :: tail =>
        val tparams1 = addFBound(tparams.head) :: tparams.tail
        q"""
          $mods class $tpname[..$tparams1] $ctorMods(...$paramss) extends { ..$earlydefns } with ..$parents { $self => ..$stats }
          ..$tail
        """
    }
  }
}

用法：

trait Trait[T <: Trait[T]] {
  def merge(t: T): T
}

@fbound case class A[T](t: T, i: Int)
@fbound case class B[T](t: T, str: String)

//scalac: {
//  case class A[T <: Trait[T]] extends scala.Product with scala.Serializable {
//    <caseaccessor> <paramaccessor> val t: T = _;
//    <caseaccessor> <paramaccessor> val i: Int = _;
//    def <init>(t: T, i: Int) = {
//      super.<init>();
//      ()
//    }
//  };
//  ()
//}
//scalac: {
//  case class B[T <: Trait[T]] extends scala.Product with scala.Serializable {
//    <caseaccessor> <paramaccessor> val t: T = _;
//    <caseaccessor> <paramaccessor> val str: String = _;
//    def <init>(t: T, str: String) = {
//      super.<init>();
//      ()
//    }
//  };
//  ()
//}
于 2020-10-07T14:16:36.097 回答