Function Scala-我可以定义一个函数来接收任何函数作为参数吗？

在Scala中，是否可以定义一个函数来接收任何其他函数作为参数

它应该类似于以下内容：

object Module extends SecureModule{
    val bc = new MyBC()

    def method(parameter: Type) = {
        exec(bc.method(parameter))
    }
    def method2(parameter1: Type1, parameter2: Type2) = {
        exec(bc.method2(parameter1,parameter2))
    }
}

trait SecureModule {
    def exec(f: ANY_PARAMETER => ANY_RESULT) = {
        //some extra processing
        f
    }
}

可能吗？如果是，我怎样才能做到这一点

提前谢谢。

您不能将任何函数作为参数。你会怎么做

充其量，您可以使用具有特定数量参数的任何函数

例如，这里，

f

接受一个参数并返回一个值

def exec[A,B](f: A => B)

这里，

f

接受两个参数：

def exec[A,B,C](f: (A, B) => C)

如果不关心函数的返回类型，则始终可以使用

Any

而不是类型参数，因为函数的返回类型是协变的：

def exec[A](f: A => Any)

不能将任何函数作为参数。你会怎么做

充其量，您可以使用具有特定数量参数的任何函数

例如，这里，

f

接受一个参数并返回一个值

def exec[A,B](f: A => B)

这里，

f

接受两个参数：

def exec[A,B,C](f: (A, B) => C)

如果不关心函数的返回类型，则始终可以使用

Any

而不是类型参数，因为函数的返回类型是协变的：

def exec[A](f: A => Any)

不能将任何函数作为参数。你会怎么做

充其量，您可以使用具有特定数量参数的任何函数

例如，这里，

f

接受一个参数并返回一个值

def exec[A,B](f: A => B)

这里，

f

接受两个参数：

def exec[A,B,C](f: (A, B) => C)

如果不关心函数的返回类型，则始终可以使用

Any

而不是类型参数，因为函数的返回类型是协变的：

def exec[A](f: A => Any)

不能将任何函数作为参数。你会怎么做

充其量，您可以使用具有特定数量参数的任何函数

例如，这里，

f

接受一个参数并返回一个值

def exec[A,B](f: A => B)

这里，

f

接受两个参数：

def exec[A,B,C](f: (A, B) => C)

如果不关心函数的返回类型，则始终可以使用

Any

而不是类型参数，因为函数的返回类型是协变的：

def exec[A](f: A => Any)

---

我觉得你的描述有点误导人。 按照我的理解，您（可能）想要做的是延迟执行

bc.method

调用，直到执行了其他代码。 如果是，请尝试以下方法：

object Module extends SecureModule{
    val bc = new MyBC()

    def method(parameter: Type) = {
        exec(() => bc.method(parameter))
    }
    def method2(parameter1: Type1, parameter2: Type2) = {
        exec(() => bc.method2(parameter1,parameter2))
    }
}

trait SecureModule {
    def exec[Result](f: () => Result): Result = {
        //some extra processing
        f()
    }
}

---

我觉得你的描述有点误导人。 按照我的理解，您（可能）想要做的是延迟执行

bc.method

调用，直到执行了其他代码。 如果是，请尝试以下方法：

object Module extends SecureModule{
    val bc = new MyBC()

    def method(parameter: Type) = {
        exec(() => bc.method(parameter))
    }
    def method2(parameter1: Type1, parameter2: Type2) = {
        exec(() => bc.method2(parameter1,parameter2))
    }
}

trait SecureModule {
    def exec[Result](f: () => Result): Result = {
        //some extra processing
        f()
    }
}

---

我觉得你的描述有点误导人。 按照我的理解，您（可能）想要做的是延迟执行

bc.method

调用，直到执行了其他代码。 如果是，请尝试以下方法：

object Module extends SecureModule{
    val bc = new MyBC()

    def method(parameter: Type) = {
        exec(() => bc.method(parameter))
    }
    def method2(parameter1: Type1, parameter2: Type2) = {
        exec(() => bc.method2(parameter1,parameter2))
    }
}

trait SecureModule {
    def exec[Result](f: () => Result): Result = {
        //some extra processing
        f()
    }
}

---

我觉得你的描述有点误导人。 按照我的理解，您（可能）想要做的是延迟执行

bc.method

调用，直到执行了其他代码。 如果是，请尝试以下方法：

object Module extends SecureModule{
    val bc = new MyBC()

    def method(parameter: Type) = {
        exec(() => bc.method(parameter))
    }
    def method2(parameter1: Type1, parameter2: Type2) = {
        exec(() => bc.method2(parameter1,parameter2))
    }
}

trait SecureModule {
    def exec[Result](f: () => Result): Result = {
        //some extra processing
        f()
    }
}

---

scala的好处在于，您可以创建自己的语法

如果您要做的是包装一个操作，这样您就可以进行预处理和后处理，以及控制执行上下文，那么您可以使用按名称调用参数来完成这一操作。例如，如果我们只想计算一段代码需要多长时间，那么我们可以这样做：

def timer[T](block: => T): (T,Long) = {
  val startDate = new Date()
  val result = block
  val endDate = new Date()
  (result, endDate.getTime()-startDate.getTime())
}

val (result,duration) = timer {
  1+3
}

我们可以这样使用它：

def timer[T](block: => T): (T,Long) = {
  val startDate = new Date()
  val result = block
  val endDate = new Date()
  (result, endDate.getTime()-startDate.getTime())
}

val (result,duration) = timer {
  1+3
}

还是像这样

val (result,duration) = timer {
  "hello" + " world!"
}

---

结果将具有您传入的块的正确类型，同时还提供您期望的持续时间。

scala的优点是您可以创建自己的语法

如果您要做的是包装一个操作，这样您就可以进行预处理和后处理，以及控制执行上下文，那么您可以使用按名称调用参数来完成这一操作。例如，如果我们只想计算一段代码需要多长时间，那么我们可以这样做：

def timer[T](block: => T): (T,Long) = {
  val startDate = new Date()
  val result = block
  val endDate = new Date()
  (result, endDate.getTime()-startDate.getTime())
}

val (result,duration) = timer {
  1+3
}

我们可以这样使用它：

def timer[T](block: => T): (T,Long) = {
  val startDate = new Date()
  val result = block
  val endDate = new Date()
  (result, endDate.getTime()-startDate.getTime())
}

val (result,duration) = timer {
  1+3
}

还是像这样

val (result,duration) = timer {
  "hello" + " world!"
}

---

结果将具有您传入的块的正确类型，同时还提供您期望的持续时间。

scala的优点是您可以创建自己的语法

如果您要做的是包装一个操作，这样您就可以进行预处理和后处理，以及控制执行上下文，那么您可以使用按名称调用参数来完成这一操作。例如，如果我们只想计算一段代码需要多长时间，那么我们可以这样做：

def timer[T](block: => T): (T,Long) = {
  val startDate = new Date()
  val result = block
  val endDate = new Date()
  (result, endDate.getTime()-startDate.getTime())
}

val (result,duration) = timer {
  1+3
}

我们可以这样使用它：

def timer[T](block: => T): (T,Long) = {
  val startDate = new Date()
  val result = block
  val endDate = new Date()
  (result, endDate.getTime()-startDate.getTime())
}

val (result,duration) = timer {
  1+3
}

还是像这样

val (result,duration) = timer {
  "hello" + " world!"
}

---

结果将具有您传入的块的正确类型，同时还提供您期望的持续时间。

scala的优点是您可以创建自己的语法

如果您要做的是包装一个操作，这样您就可以进行预处理和后处理，以及控制执行上下文，那么您可以使用按名称调用参数来完成这一操作。例如，如果我们只想计算一段代码需要多长时间，那么我们可以这样做：

def timer[T](block: => T): (T,Long) = {
  val startDate = new Date()
  val result = block
  val endDate = new Date()
  (result, endDate.getTime()-startDate.getTime())
}

val (result,duration) = timer {
  1+3
}

我们可以这样使用它：

def timer[T](block: => T): (T,Long) = {
  val startDate = new Date()
  val result = block
  val endDate = new Date()
  (result, endDate.getTime()-startDate.getTime())
}

val (result,duration) = timer {
  1+3
}

还是像这样

val (result,duration) = timer {
  "hello" + " world!"
}

---

结果将具有您传入的块的正确类型，同时也将提供您期望的持续时间。

一旦它接近我所寻找的方法，我将接受这一答案。非常感谢。一旦它接近我所寻求的方法，我就会接受这个答案。非常感谢。一旦它接近我所寻求的方法，我就会接受这个答案。非常感谢。一旦它接近我所寻求的方法，我就会接受这个答案。非常感谢。文本

ANY_参数=>