Question

是否可以使用(parameter1, parameter2) applied myFunction之类的语法。这里myFunction将应用于给定的参数。具体示例：val myFunction = (a:String) => a+a+"there"; "hello" applied myFunction应输出“hellohellothere”。我知道可以(parameter1, parameter2) match {case myFunctionWrittenOut}，所以上面会变成"hello" match {case a:String => a+a+"there"}但是你必须写出这个函数：你不能使用引用。

Answer 1

我不认为使用标准scala是可能的。但是你可以编写一些辅助方法来实现这样的东西：

implicit class Applied1[T](val t: T) extends AnyVal {
  def applied[R](f: T => R): R = f(t)
}

implicit class Applied2[T1, T2](val t: (T1, T2)) extends AnyVal {
  def applied[R](f: (T1, T2) => R): R = f(t._1, t._2)
}

implicit class Applied3[T1, T2, T3](val t: (T1, T2, T3)) extends AnyVal {
  def applied[R](f: (T1, T2, T3) => R): R = f(t._1, t._2, t._3)
}

// ... and 19 more implicit classes: Applied4 to Applied22

然后你可以像这样使用它：

def minus(a: Int): Int = -a
def plus(a: Int, b: Int): Int = a + b
def plus(a: Int, b: Int, c: Int): Int = a + b + c

scala> 5 applied minus
res0: Int = -5

scala> (1, 2) applied plus
res1: Int = 3

scala> (1, 2, 3) applied plus
res2: Int = 6

但是使用泛型函数或带隐式参数的函数可能会有点复杂：

def mul[T : Numeric](a: T, b: T): T = {
  import Numeric.Implicits._
  a * b
}

scala> (1.5, 2.5) applied (mul(_, _))
res3: Double = 3.75

Answer 2

可以使用隐式类来实现与您正在寻找的类似的东西。

只有一个构造函数参数的隐式类可以用作将方法添加到给定类型的模式。一个例子是DurationInt，其中＆＃34;添加＆＃34;整数的方法，使其能够转换为持续时间。它使用import scala.concurrent.duration._

导入范围

DurationInt的简化版本可以定义如下：

implicit class DurationInt(n: Int) {
  def seconds: FiniteDuration = Duration(n, TimeUnit.SECONDS)
}

这样就可以在所有整数上使用seconds方法

2.seconds // Returns a duration object

对于具有多个参数的函数，可以对隐式类使用元组参数：

implicit class TupleConcat(tuple: (String, String)) {
  def concat: String = tuple._1 + tuple._2
}

// enables the following syntax
("aa", "bb").concat

这些隐式类通常扩展AnyVal，这允许一些编译器优化，避免在很多情况下实际上必须实例化隐式类。

implicit final class DurationInt(val n: Int) extends AnyVal { /* implementation */ }

Answer 3

在Scala中，函数的参数列表始终在函数前写入：

val fn = (a: Int, b: Int) => a + b
//       ^  parameters  ^    ^ function

在要在Scala中应用的函数之前编写函数参数

3 个答案: