是否有 type-class 检查是否存在至少一个隐式类型？

Question

我有一个特征 Foo[T, U] 和一个给定 L <: HList 和目标类型 U 的类型级算法，告诉我是否存在 T L 这样在范围内就有一个隐含的 Foo[T, U] 。这是使用以下类型 class 实现的：

trait Search[L <: HList, U]

object Search {
  def apply[L <: HList, U](implicit s: Search[L, U]): U = null

  ...
}

我们有以下内容：

object Test {
  type L = Int :: String :: HNil

  implicit val foo: Foo[String, Boolean] = null

  Search[L, Boolean] //compiles

  Search[L, Double] //does not compile
}

我想要的是，如果在范围内根本没有任何 T 的 Foo[T, U]，则根本不会进行搜索，因为那时我们已经知道该算法不会完全的。换句话说，我想要一个类型-class trait Exists[F[_]] 当且仅当范围内至少有一个隐式 F 时存在实例，所以函数 Search.apply 代替有签名：

def apply[L <: HList, U](implicit ev: Exists[Foo[_, U]], s: Search[L, U]): U = null

在这种情况下，如果范围内存在任何隐式 Foo，编译器将仅尝试解析 s。

这样的类型-class可以定义吗？已经存在了吗？

Answer 1

尝试

import scala.language.experimental.macros
import scala.reflect.macros.{blackbox, contexts}

trait Exists[A]

object Exists {
  implicit def materialize[A]: Exists[A] = macro impl[A]

  def impl[A: c.WeakTypeTag](c: blackbox.Context): c.Tree = {
    import c.universe._
    val context = c.asInstanceOf[contexts.Context]
    val global: context.universe.type = context.universe
    val analyzer: global.analyzer.type = global.analyzer
    val callsiteContext = context.callsiteTyper.context

    val tpA = weakTypeOf[A]

    val searchResult = analyzer.inferImplicit(
      tree = EmptyTree.asInstanceOf[global.Tree],
      pt = tpA.asInstanceOf[global.Type],
      reportAmbiguous = false,
      isView = false,
      context = callsiteContext,
      saveAmbiguousDivergent = true,
      pos = c.enclosingPosition.asInstanceOf[global.Position]
    )

    val isAmbiguous = callsiteContext.reporter.firstError match {
      case Some(analyzer.AmbiguousImplicitTypeError(_,_)) => true
      case _ => false
    }

    if (searchResult.isSuccess || searchResult.isAmbiguousFailure || isAmbiguous) 
      q"new Exists[$tpA] {}"
    else c.abort(c.enclosingPosition, s"no implicit $tpA")    
  }
}

测试

// no implicit Int
// implicitly[Exists[Int]] // doesn't compile

implicit val i: Int = 1 
implicitly[Exists[Int]] // compiles

implicit val i: Int = 1 
implicit val i1: Int = 2 
implicitly[Exists[Int]] // compiles

我猜原来的 Search 是

trait Foo[U, V]

trait Search[L <: HList, V]

trait LowPrioritySearch {
  implicit def tail[H, T <: HList, V](implicit search: Search[T, V]): Search[H :: T, V] = null
}

object Search extends LowPrioritySearch {
  def apply[L <: HList, U](implicit s: Search[L, U]): U = null.asInstanceOf[U]

  implicit def head[U, T <: HList, V](implicit foo: Foo[U, V]): Search[U :: T, V] = null
}

现在 Exists

def apply[L <: HList, U](implicit ev: Exists[Foo[_, U]], s: Search[L, U]): U = null.asInstanceOf[U]

同样有效

Search[L, Boolean] //compiles
// Search[L, Double] //does not compile

在 2.13.0 中测试

libraryDependencies ++= Seq(
  scalaOrganization.value % "scala-reflect" % scalaVersion.value,
  scalaOrganization.value % "scala-compiler" % scalaVersion.value
)

Answer 2

在 Scala 3 中，scala.util.Not（即将成为 NotGiven？），如果没有找到给定类型的隐式则存在，可用于此：

implicit val b: Byte = 1
  
summon[Not[Not[Byte]]] //compiles

implicit val i: Int = 0
implicit val i2: Int = 2

summon[Not[Not[Int]]] //compiles

summon[Not[Not[String]]] //doesn't compile - Not[String] not found

在 Scastie 中查看。

你的 Exists 类型类现在看起来像这样（givens 的语法可能很快就会改变，但你明白了）：

@annotation.implicitNotFound("No implicit of type ${T} was found")
trait Exists[T]
object Exists {
  given [T](using Not[Not[T]]) as Exists[T]
}

在 Scastie 中查看。

是否有 type-class 检查是否存在至少一个隐式类型？

Is there a type-class that checks for existence of at least one implicit of a type?

scala

type-level-computation

shapeless

scala-macros

scala-compiler