Scala 高阶函数映射中不需要的隐式参数解析

我在尝试

映射
某些方法时遇到问题，这些方法是通过
选项
类型上的隐式参数定义的

假设我定义了一个自定义
类
和一个
特征
，使用上述方法对所述
类

class MyClass

trait Processor {

  def stringy(implicit arg: MyClass) = arg.toString

  def lengthy(implicit arg: MyClass) = arg.toString.length

  def inty(implicit arg: MyClass) = arg.toString.map(_.toInt).sum

}

然后我创建了一个带有一些测试的实现

object TestProcessing extends Processor {

  //Here everything works fine, the argument is passed explicitly    
  def test() {
    val my = new MyClass

    val res = List(stringy(my), lengthy(my), inty(my))

    println(res.mkString("\n"))
  }

  //Still everything ok, the argument is passed implicitly    
  def testImplicit() {
    implicit val my = new MyClass

    val res = List(stringy, lengthy, inty)

    println(res.mkString("\n"))
  }

  object Mapper {
    //class wrapped in an Option
    val optional = Some(new MyClass)

    //trying to factor out common code
    def optionally[T](processFunction: MyClass => T): Option[T] = optional map processFunction

    //now the specific processing methods that should work on the optional value
    def s: Option[String] = optionally(stringy)
    def l: Option[Int] = optionally(lengthy)
    def i: Option[Int] = optionally(inty)

    /*
     * Here the compiler complains that
     *
     *<console>:40: error: could not find implicit value for parameter arg: MyClass
     *                def s: Option[String] = optionally(stringy)
     *                                                   ^
     *<console>:41: error: could not find implicit value for parameter arg: MyClass
     *                def l: Option[Int] = optionally(lengthy)
     *                                                ^
     *<console>:42: error: could not find implicit value for parameter arg: MyClass
     *                def i: Option[Int] = optionally(inty)
     *                                                ^
     */    
  }


}

对象测试处理扩展了处理器{
//这里一切正常，参数被显式传递
def测试（）{
val my=new MyClass
val res=列表（stringy（我的）、longer（我的）、inty（我的））
println（res.mkString（“\n”））
}
//仍然一切正常，参数是隐式传递的
def testImplicit（）{
隐式val my=new MyClass
val res=列表（连续、冗长、完整）
println（res.mkString（“\n”））
}
对象映射器{
//类包装在选项中
val可选=部分（新MyClass）
//试图找出共同的代码
def可选[T]（processFunction:MyClass=>T）：Option[T]=可选映射processFunction
//现在，具体的处理方法应适用于可选值
def s:Option[String]=可选（stringy）
def l:Option[Int]=可选（冗长）
定义i：选项[Int]=可选（inty）
/*
*这里编译器抱怨说
*
*：40:错误：找不到参数arg:MyClass的隐式值
*def s:Option[String]=可选（stringy）
*                                                   ^
*：41:错误：找不到参数arg:MyClass的隐式值
*def l:Option[Int]=可选（冗长）
*                                                ^
*：42:错误：找不到参数arg:MyClass的隐式值
*定义i：选项[Int]=可选（inty）
*                                                ^
*/    
}
}

虽然
optional
被认为是显式地将可选值显式传递给它的参数函数，但当我在实际函数上使用它时，编译器要求隐式定义

我有两种可能的解决方案，但都不令人满意：

将隐式参数传递给
（可选）
，如中所示

可选（隐式my=>stringy）

避免将特定函数的参数定义为
隐式
，如中所示

defstringy（arg:MyClass）

每个解决方案都违背了实现可读性和可用性的目标

还有第三种方法吗？
如果我理解正确，问题是编译器似乎没有意识到您希望在这里部分地将该方法应用/提升到函数（相反，它“认为”您希望忽略隐式参数），因此显式地这样做似乎是可行的：

def s: Option[String] = optionally(stringy(_))
def l: Option[Int] = optionally(lengthy(_))
def i: Option[Int] = optionally(inty(_))

如果我理解正确，问题在于编译器似乎没有意识到您希望在这里部分地将方法应用/提升到函数（相反，它“认为”您希望忽略隐式参数），因此显式地这样做似乎是可行的：

def s: Option[String] = optionally(stringy(_))
def l: Option[Int] = optionally(lengthy(_))
def i: Option[Int] = optionally(inty(_))

很好，这是否意味着无法部分应用带有隐式args的方法
def[A]（隐式A:A）=A
但否：
val ff=f
？至少不需要简单地省略参数列表，这看起来很简单，这是否意味着无法部分应用带有隐式参数的方法
def[A]（隐式A:A）=A
但否：
val ff=f 
？至少不需要简单地省略参数列表，看起来