它不起作用的原因是你有冲突的暗示。因为有不止一种方法可以将Option[String]转换为Option[Int]，所以编译器无法知道应该使用哪种方法，也不会使用任何方法。
你可以在使用-Yno-predef编译器选项时看到它：

import scala.language.implicitConversions
import scala.util.Try
object OptionalConverter {
  import scala.Predef.augmentString
  implicit val string2Long: String => Long = java.lang.Long.parseLong(_)
  //implicit val string2Int: String => Int = java.lang.Integer.parseInt(_)
  implicit def convert[A, B](input: Option[A])(implicit
      mapper: A => B
  ): Option[B] = input.flatMap(i => Try(mapper(i)).toOption)
}
import OptionalConverter._
val input: Option[String] = Option("123")
val longOpt: Option[Long] = input
scala.Predef.println(longOpt)
//val intOpt: Option[Int] = Option("123")
//scala.Predef.println(intOpt)

(see：Scastie）。
这段代码编译并打印您所期望的内容。然而，在这方面，

• 如果你取消注解implicit val string2Int: String => Int，它将停止工作-也许，因为你可以将Long转换为Int（反之亦然），这个原生的implicit A => B变得模糊不清。
• 如果将string2Int注解掉，但删除了-Yno-predef，则从scala.Predef进行隐式转换将与string2Long发生冲突，并使其变得不明确
• 同时你不能只启用Predef而注解掉string2int和string2Long，它也不起作用。

这突出了隐式转换有多少陷阱，以及它们以不可预测的方式发生冲突的容易程度（这并不像它们导致编译代码不应该编译，因为它们的混合导致不必要的行为）。
出于这个原因，最好使用带有类型类的某种扩展方法，因为它将基于隐式的行为约束到单个用例中，这有助于调试和驯服行为。

使用非常一般的隐式几乎总是一个坏主意，因为它可能导致非常不可预测的结果。
与其使用裸A => B作为隐式转换器，不如将此转换行为封装在它自己的构造中。这将防止由非预期转换器候选者引入的不可预测性和错误。
因此，您可以定义类似OptionConverter trait的东西，然后在代码中使用它implicitly。

trait OptionConverter[A, B] {
    def convert(o: Option[A]): Option[B]
  }
  object OptionConverter {
    implicit val intToString: OptionConverter[Int, String] = new OptionConverter[Int, String] {
      override def convert(o: Option[Int]): Option[String] = o.map(_.toString())
    }
    implicit val stringToString: OptionConverter[String, Int] = new OptionConverter[String, Int] {
      override def convert(o: Option[String]): Option[Int] = o.map(s => Integer.parseInt(s))
    }
    
  }
  implicit class OptionConverterOps[A](o: Option[A]) {
    def convert[B](implicit oc: OptionConverter[A, B]): Option[B] = oc.convert(o)
  }
  val intOption = Option("10").convert[Int]
  val stringOption = Option(10).convert[String]