通过scala中的反射检查两种类型是否等效

我有一些代码：

导入scala.concurrent.Future
导入scala.concurrent.ExecutionContext.Implicits.global
特征逻辑单元
特征Ezib扩展逻辑单元
特征Zieb扩展逻辑单元
对象逻辑单元{
@内联
def联合收割机[A这里有许多问题：

这些测试不太可能对性能产生任何影响，因为创建和运行未来的

是一项更复杂的操作，并且将主导整个时间

类型参数是不必要的，因为值始终被视为

逻辑单元

，因此签名可以是：

def combine(arg1: LogicUnit, arg2: LogicUnit): Future[LogicUnit]

最好使用

match

而不是

isInstanceOf

，因为编译器会知道参数的类型

第一个版本不依赖于arg1的类型，因此无需对其进行测试：

def combine(arg1: LogicUnit, arg2: LogicUnit): Future[LogicUnit] =
  arg2 match {
    case _: Ezib => Future(new Ezib {})
    case _: Zieb => Future(new Zieb {})
  }

如果确实需要测试这两个参数，请嵌套测试，以便不重复第一个测试：

def combine(arg1: LogicUnit, arg2: LogicUnit): Future[LogicUnit] =
  arg1 match {
    case a1: Ezib =>
      arg2 match {
        case a2: Ezib => Future(???)
        case a2: Zieb => Future(???)
      }
    case a1: Zieb =>
      arg2 match {
        case a2: Ezib => Future(???)
        case a2: Zieb => Future(???)
      }
  }

此公式清晰易读，允许每个分支使用编译器已知的已匹配特定类型的

a1

和

a2

值

也可能是使用多态版本的

combine

会提高性能：

def combine(arg1: Ezib, arg2: Ezib): Future[LogicUnit] = ???
def combine(arg1: Ezib, arg2: Zieb): Future[LogicUnit] = ???
def combine(arg1: Zieb, arg2: Ezib): Future[LogicUnit] = ???
def combine(arg1: Zieb, arg2: Zieb): Future[LogicUnit] = ???

def combine(arg1: LogicUnit, arg2: LogicUnit): Future[LogicUnit] =
  arg1 match {
    case a1: Ezib =>
      arg2 match {
        case a2: Ezib => combine(a1, a2)
        case a2: Zieb => combine(a1, a2)
      }
    case a1: Zieb =>
      arg2 match {
        case a2: Ezib => combine(a1, a2)
        case a2: Zieb => combine(a1, a2)
      }
  }

---

如果在调用站点知道具体类型，那么编译器可以直接调用适当的方法，而不必匹配类型。

这里有许多问题：

这些测试不太可能对性能产生任何影响，因为创建和运行未来的是一项更复杂的操作，并且将主导整个时间

类型参数是不必要的，因为值始终被视为

逻辑单元

，因此签名可以是：

def combine(arg1: LogicUnit, arg2: LogicUnit): Future[LogicUnit]

最好使用

match

而不是

isInstanceOf

，因为编译器会知道参数的类型

第一个版本不依赖于arg1的类型，因此无需对其进行测试：

def combine(arg1: LogicUnit, arg2: LogicUnit): Future[LogicUnit] =
  arg2 match {
    case _: Ezib => Future(new Ezib {})
    case _: Zieb => Future(new Zieb {})
  }

如果确实需要测试这两个参数，请嵌套测试，以便不重复第一个测试：

def combine(arg1: LogicUnit, arg2: LogicUnit): Future[LogicUnit] =
  arg1 match {
    case a1: Ezib =>
      arg2 match {
        case a2: Ezib => Future(???)
        case a2: Zieb => Future(???)
      }
    case a1: Zieb =>
      arg2 match {
        case a2: Ezib => Future(???)
        case a2: Zieb => Future(???)
      }
  }

此公式清晰易读，允许每个分支使用编译器已知的已匹配特定类型的

a1

和

a2

值

也可能是使用多态版本的

combine

会提高性能：

def combine(arg1: Ezib, arg2: Ezib): Future[LogicUnit] = ???
def combine(arg1: Ezib, arg2: Zieb): Future[LogicUnit] = ???
def combine(arg1: Zieb, arg2: Ezib): Future[LogicUnit] = ???
def combine(arg1: Zieb, arg2: Zieb): Future[LogicUnit] = ???

def combine(arg1: LogicUnit, arg2: LogicUnit): Future[LogicUnit] =
  arg1 match {
    case a1: Ezib =>
      arg2 match {
        case a2: Ezib => combine(a1, a2)
        case a2: Zieb => combine(a1, a2)
      }
    case a1: Zieb =>
      arg2 match {
        case a2: Ezib => combine(a1, a2)
        case a2: Zieb => combine(a1, a2)
      }
  }

---

如果调用站点知道具体的类型，那么编译器可以直接调用适当的方法，而不必匹配类型。

我正在尝试对其进行大量优化，我建议避免过早优化，运行代码，如果速度慢，则研究优化。从这段代码中，我不期望有任何意义通过您想要执行的更改可以提高性能。此外，您可能希望从代码中删除

返回值

（请参阅）使用模式匹配而不是

isInstanceOf

，通过将对

Future

的

apply

方法的调用替换为

Future，您几乎肯定会在代码中获得更大的性能加速。成功的
@Gaël J我相信模式匹配无论如何都会转化为反射。我正在尝试优化它我建议您避免过早的优化，运行代码，如果速度慢，则研究优化。从这段代码中，我不希望您希望做的更改会带来任何显著的性能提升。此外，您可能希望从代码中删除
返回值
（请参阅）使用模式匹配而不是
isInstanceOf
，通过将对
Future
的
apply
方法的调用替换为
Future，您几乎肯定会在代码中获得更大的性能加速。成功的
@Gaël J我相信模式匹配无论如何都会转化为反射。谢谢。未来是这是因为我要修改该函数以对大规模集合执行操作。关于类型参数，我不希望该函数只接受一个逻辑单元，而只接受一个继承的对象。@BradOo the
谢谢。之所以会有未来，是因为我要修改该函数以对大规模集合执行操作。关于类型参数，我不希望函数只接受一个逻辑单元，而只接受一个继承的对象。@BradOo the