转换由名称参数

Question

我想创建一个函数与下面的签名元组：

def myFunction[T](functionWithName: (String, => T)): T 

，这样我可以调用它，例如，像这样：val x = myFunction("abc" -> 4 * 3)。但是，Tuple不接受名称参数，所以上面的签名是无效的。

通过this answer的启发，我想下面的隐式转换：

implicit class ByName[T](getValue: => T) extends Proxy { 
    def apply(): T = getValue 
    def self = apply() 
} 

def myFunction[T](functionWithName: (String, ByName[T])): T = { 
    // do something 
    functionWithName._2() 
} 

隐含不会在这种情况下工作，但是（不像在链接的答案）。

• 为什么隐式转换为ByName不起作用？
• 如何才能达到myFunction("abc" -> 4 * 3)的名称所要传递4 * 3的预期效果？

Answer 1

我有两个建议，以实现这一点：

• 制作整个元组通过名字：functionWithName: => (String, T)

• 使自己的等级：

  class MyTuple[A, B](a: A, b: => B) { 
      def _1: A = a 
      def _2: B = b 
      def toTuple = a -> b // optional 
  } 
  

，并有一个自定义的隐式方法的地方，像->用于Tuple2（见ArrowAssoc在Predef）：

implicit final class ArrAssoc[A](private val self: A) extends AnyVal { 
    @inline def -->[B](y: => B): MyTuple[A, B] = { 
     new MyTuple(self, y) 
    } 
    } 

然后，你可以这样说：

val t = 1 --> { println("blah"); 5 } 
    //t._2 
    //t.toTuple 

The b para仪表不应该被评估，直到调用t._2 甚至使toTuple imlicit转换，所以当Tuple2被espected你可以传递一个MyTuple ...

Answer 2

您可以将call-by-name参数更改为thunk。

def myFunction[T](functionWithName: (String,() => T)): T = functionWithName._2() 

myFunction(("abc",() => 4 * 3)) // 12 

，或者把它与implicit工作，你只需要明确提供类型myFunction：

myFunction[Int]("abc" -> 4 * 3) // 12