Scala 是否可以计算类型级别上的润滑油？

我需要得到作为参数给定的两种类型的最小上界。诸如此类：

class Holder[T] {
  type Shrink[S] = ???
}

其中，

？

生成某种类型表达式，该表达式为

T

和

S

类型生成最小上界。一些看起来像是魔法的东西LUB\u Magic[T，S]

我尝试了很多东西，但找不到任何表达的方式

例如，如果预定义了类型

A

和

B

，则

final case class Solve() {
  val query = (x : Any) => x match {
    case a : A => a
    case b : B => b
  }
  type Q = query.type
}

将根据最小上界生成类型

但是如果我尝试像

类Solve[A，B]（）

那样对它进行参数化，那么类型将是

Any

，而不是最小上界。这同样适用于

---

是否有可能在类型级别上获得最小上限？

如果您的主要目标是在

查询中获得正确的结果类型，那么您可以简单地为
添加隐式证据，因为隐式证据不稳定。我无法在类型级别计算它，即不创建对象<代码>查询
键入不是目标，而是我尝试过的解决方案，但失败了。如果允许创建对象，那么我提到的要点提供了很好的解决方案来区分
List[Int]
和
List[Float]
您可以使用
TypeTag
s@ayvango那么我误解了你的问题，对不起。我将删除我的答案，希望你的问题再次得到更多的关注。
class Lub[A, B, C](val ev1: A <:< C, val ev2: B <:< C)

object Lub {
  implicit def lub[C, A <: C, B <: C]: Lub[A, B, C] = 
    new Lub[A, B, C](implicitly, implicitly)
}

import scala.reflect.ClassTag

case class Solve[A: ClassTag, B: ClassTag]() {
  def query[C](implicit lub: Lub[A, B, C]): Any => C = {
    (x: Any) => x match {
      case a : A => lub.ev1(a)
      case b : B => lub.ev2(b)
    }
  }
}

val s1 = Solve[Int, Float]
val q1: Any => AnyVal = s1.query // typechecks

abstract class Solve2[A: ClassTag, B: ClassTag] {
  type C
  def query: Any => C
}

object Solve2 {
  final class Solve2Builder[A: ClassTag, B: ClassTag] {
    def build[X](implicit lub: Lub[A, B, X])
    : Solve2[A, B] { type C = X } = new Solve2[A, B] {
      type C = X
      val query: Any => C = _ match {
        case a: A => lub.ev1(a)
        case b: B => lub.ev2(b)
      } 
    }
  }
  def apply[A: ClassTag, B: ClassTag]: Solve2Builder[A, B] = new Solve2Builder[A, B]
}

val s2 = Solve2[Int, Float].build
val q2: Any => AnyVal = s2.query