如何将类声明为具有隐式参数的扩展函数

Question

我想定义一个采用一个显式参数和一个隐式参数的函数，如下所示：

def foo(a: Int)(implicit b: Int) : Int

但作为一个类或对象，像这样

object Foo extends ((Int,Int) => Int) {
  def apply(a: Int)(implicit b: Int) : Int = { ... }
}

这样就可以像下面这样调用该函数：

implicit val b = 2
val g = Foo(1)

我无法获得Foo类应该从其正确扩展的基础的声明。 如何才能做到这一点？

Answer 1

你不能。 Function2 [T1，T2，R]声明了抽象方法apply（t1：T1，t2：T2）：R ，因此，如果要混入Function2 ，则必须实现此arity-2 apply方法，该方法具有不同的签名而不是您要使用的咖喱版本。

Answer 2

因此，此问题分为两部分-首先，如何创建一个使用咖喱参数列表实现函数的对象。 然后，如何使这些参数列表之一成为隐式。

首先肯定是有可能的。 注意，咖喱函数是返回函数的函数。 所以f(x: Int)(y: Int)实际上是Function1 ，而不是Function2 ：

scala> def f(x: Int)(y: Int) = x + y
f: (x: Int)(y: Int)Int

scala> f _
res0: Int => Int => Int = <function1>

您当然可以创建一个实现此目的的类：

scala> object Foo extends (Int => Int => Int) {
     |   def apply(x: Int) = {(y: Int) => x + y}
     | }
defined module Foo

scala> Foo(1)(2)
res1: Int = 3

不幸的是，我不知道有什么方法可以使第二个参数列表隐式化。

Answer 3

除了扩展(Int, Int) => Int您还可以使用隐式转换：

class Foo(f: (Int, Int) => Int) {
  def apply(a: Int)(implicit b: Int) : Int = f(a, b)
}

implicit def Foo_to_Function2(foo: Foo) = (x: Int, y: Int) => foo(x)(y)

测试：

val foo = new Foo(_ * 10 + _)
foo(4) //error since no implicit Int yet
{
  implicit val impint = 5
  foo(4)  //45
}  
def takesF2(f: (Int, Int) => Int) = f(1, 2)
takesF2(foo)  //12 - works as normal Function2

Answer 4

一个问题是：为什么您必须将那个对象Foo传递给“期望（Int，Int）=> Int的地方”？

我想对象Foo应该具有更多特殊功能，这些功能除了可以作为功能外还可以发挥作用吗？

似乎最好在这里将两个问题分开：a）函数（Int）（隐式Int）=> Int和b）对象Foo

object Foo {
  def apply(a: Int, b: Int) : Int = { ... }
}

def foo(a: Int)(implicit b: Int) : Int = Foo(a, b)

implicit val m:Int = 42

foo(5)  // --> res1: Int = 47

如果愿意，您可以将'foo'视为“伴随功能” ...

除此之外：我想尝试应用（Int）（隐式Int）=> Int“其中（Int，Int）=> Int预期为Int”可能不起作用，因为这些类型不相同。 至少当您尝试将其放入

def bar(f:(Int,Int)=>Int) = ....

方法栏无论如何都将使用两个参数调用其参数f，因为它希望它接受两个参数，并且不能假定f中提供的函数确实能够使用隐式函数。