在Scala中应用函数之前写入函数参数

是否可能具有像(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"}但是在这里你必须写出这个函数：你不能使用一个引用。在Scala中应用函数之前写入函数参数

来源

2016-02-26 user

我发现很难理解你想实现什么。令牌//开始评论。你想“重载”这个并且执行一个函数应用吗？ – Suma

我不认为这是可能的标准斯卡拉。但是，你可以写一些辅助方法，这将使像这样可供选择：

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

来源

2016-02-26 12:37:27 Kolmar

-3

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

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

来源

2016-02-26 12:22:09

对不起，我的问题似乎并不清楚。看到我更新的问题。 – user

隐类可以用来实现一些东西，这似乎是类似于你在找什么。

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

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

implicit class DurationInt(n: Int) { 
    def seconds: FiniteDuration = Duration(n, TimeUnit.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 */ }

来源

2016-02-26 12:35:05 Wellingr

在Scala中应用函数之前写入函数参数

回答

相关问题