在要应用于Scala的函数之前写入函数参数

是否可以应用myFunction（参数1，参数2）之类的语法。这里myFunction将应用于给定的参数。具体示例：

valmyfunction=（a:String）=>a+a+“there”；“hello”应用的myFunction

应输出“hellohellother”。

---

我知道可以进行

（parameter1，parameter2）匹配{case myfunctionwritenout}

，因此上面的内容将变成

“hello”匹配{case a:String=>a+a+“there”}

，但这里您必须写出函数：您不能使用引用。

在Scala中，函数的参数列表总是写在函数之前：

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

---

在Scala中，函数的参数列表总是写在函数之前：

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

---

隐式类可以用来实现与您所寻找的类似的东西

只有一个构造函数参数的隐式类可以用作向给定类型添加方法的模式。一个例子是

DurationInt

，它将方法“添加”到整数中，以便将它们转换为持续时间。它是使用

import scala.concurrent.duration.导入范围的

延长期的简化版本可定义如下：

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 */ }

隐式类可以用来实现与您所寻找的类似的东西

只有一个构造函数参数的隐式类可以用作向给定类型添加方法的模式。一个例子是
DurationInt
，它将方法“添加”到整数中，以便将它们转换为持续时间。它是使用
import scala.concurrent.duration.导入范围的

延长期的简化版本可定义如下：

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 */ }

我认为使用标准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

我认为使用标准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

对不起，我的问题好像不清楚。请看我更新的问题。对不起，我的问题似乎不清楚。看我更新的问题。我发现很难理解你想要实现什么。标记//开始注释。你想“重载”这个函数并执行一个函数应用程序吗？我发现很难理解你想要实现什么。标记//开始注释。您是否希望“重载”此函数并改为执行函数应用程序？