Scala支持从调用方而不是从定义中检测隐式参数吗？

也许这是一个愚蠢的问题，但我认为这种用法比当前检测隐式参数的方法更合理、更有用。
下面是一个示例，从调用方检测隐式参数的方法是什么，请首先给出代码：

package tagedfuture

class Future[+T](f: => T)(implicit tag: String) {

  def map[B](f2: T => B): Future[B] = {
    Future(f2(f))
  }

  def flatMap[B](f2: T => Future[B]): Future[B] = {
    f2(f)
  }

  def getTag = tag
}

object Future {
  def apply[T](f: => T)(implicit tag: String): Future[T] = new Future(f)

}

object Test extends App {
  val fur = Future{
    10
  }("future-chain-1")

  val fur2 = fur.map(x => x * 2)

  val fur3 = fur2.flatMap(x => {
    anotherFuture(x)(fur2.getTag)
    // expect this:
    // anotherFuture(x)
  })

  def anotherFuture(int: Int)(implicit tag: String): Future[String] = {
    Future(int.toString)
  }

  // expect this:
  //def anotherFuture(int: Int): Future[String] = {
  //  Future(int.toString)
  //}

  assert(fur.getTag == fur2.getTag && fur2.getTag == fur3.getTag)
}

tagedfuture.Future.apply

需要一个用于标记Future实例来源的隐式参数。
在

另一个Future

方法中，它可以编译，它有一个

隐式标记：String

参数，用于在生成新的Future时传输标记

我们必须为

另一个未来的
附加隐式参数，因为编译器检测从
导入包
中的类定义位置的方法上下文。但不是由呼叫方验证

如何从调用方检测隐式支持？

我们可以使用
//除此之外：
删除所有隐式样板代码。即使我们删除了它，我们也可以从调用方获得隐式实例，其中第一个是
Future
fur1的
“Future-chain-1”

它似乎比当前的实现更困难。Scala会支持这种使用隐式的方式吗

更新
在编译器工作流程中，调用方检测的确切方式是什么？
当前，当我们定义一个方法时，它使用一个具有隐式参数的方法，如
def anotherFuture
，编译器将检查包含
import pacake
的方法上下文，
相对类/对象定义中的隐式变量，如果没有任何隐式变量，则报告错误以匹配方法需要。

detect by caller意味着编译器不检查方法定义位置，而是检查调用方法的调用方位置。在此阶段，调用方的位置是另一个未来（x）（fur2.getTag）
。上下文包含
Test
对象、
fur2
实例和
flatmap
方法。

我希望它将通过检测
fur2
实例进行编译，其中有一个
标记
变量

它与以前不同，但在这个阶段，它可以顺便找到隐式，并提供一个优雅的代码来传输隐式上下文。
总而言之，您希望编译器检查作用域中的每个变量（在调用隐式参数的方法的位置）以查找任何（public）其类的成员，该成员本身标记为隐式并与预期类型匹配，以便将其作为隐式参数的参数提供给被调用的方法

我认为这将是非常模糊的（如果范围内有两个
Future[X]
实例，您会选择哪一个隐式？），会大大降低编译器的速度，并且对人脑来说根本无法管理

所以，我的答案是否定的（如果我正确理解了你的问题）
我不太明白你的问题是什么，但您可能想看一看。调用方检测隐式错误，您理解了什么？隐式错误丢失或在上下文中提供隐式错误时，隐式错误与隐式未找到错误有何不同？@MateuszKubuszok，我更新了它！谢谢你，AndreyTyukin，这是一个新的考虑，隐含的和不同的当前实施策略。谢谢，有很多歧义，即使我们通过定义一个优先次序，将使它更难以阅读。