如何在Scala中调用n次方法？

Question

我有一个例子，我想调用一个方法 n 次，其中 n 是一个 Int。在 Scala 中是否有一种以“函数式”方式执行此操作的好方法？

case class Event(name: String, quantity: Int, value: Option[BigDecimal])

// a list of events
val lst = List(
    Event("supply", 3, Some(new java.math.BigDecimal("39.00"))),
    Event("sale", 1, None),
    Event("supply", 1, Some(new java.math.BigDecimal("41.00")))
    )

// a mutable queue
val queue = new scala.collection.mutable.Queue[BigDecimal]

lst.map { event =>
    event.name match {
        case "supply" => // call queue.enqueue(event.value) event.quantity times
        case "sale" =>   // call queue.dequeue() event.quantity times
    }
}

我认为闭包是一个很好的解决方案，但我无法让它发挥作用。我也尝试过使用 for 循环，但这不是一个漂亮的功能解决方案。

Answer 1

不是你的问题的完全答案，但如果你有一个自同态（即转换 A => A），那么使用 scalaz 你可以使用自然幺半群 Endo[A]

N times func apply target

这样：

scala> import scalaz._; import Scalaz._
import scalaz._
import Scalaz._

scala> Endo((_:Int) * 2).multiply(5)
res3: scalaz.Endo[Int] = Endo(<function1>)

scala> res1(3)
res4: Int = 96

Answer 2

import List._

fill(10) { println("hello") }

简单、内置，你会得到一个单位列表作为纪念品！

但是，如果您使用函数式编程，则永远不需要多次调用函数。

Answer 3

更实用的解决方案是使用带有不可变队列和Queue 的fill 和drop 方法的折叠：

 val queue = lst.foldLeft(Queue.empty[Option[BigDecimal]]) { (q, e) =>
   e.name match {
     case "supply" => q ++ Queue.fill(e.quantity)(e.value)
     case "sale"   => q.drop(e.quantity)
   }
 }

或者更好的是，在Event 的子类中捕获您的"supply"/"sale" 区别，并避免尴尬的Option[BigDecimal] 业务：

sealed trait Event { def quantity: Int }
case class Supply(quantity: Int, value: BigDecimal) extends Event
case class Sale(quantity: Int) extends Event

val lst = List(
  Supply(3, BigDecimal("39.00")),
  Sale(1),
  Supply(1, BigDecimal("41.00"))
)

val queue = lst.foldLeft(Queue.empty[BigDecimal]) { (q, e) => e match {
  case Sale(quantity)          => q.drop(quantity)
  case Supply(quantity, value) => q ++ Queue.fill(quantity)(value)
}}

这并不能直接回答您的问题（如何将函数调用指定次数），但它肯定更惯用。

Answer 4

使用递归：

def repeat(n: Int)(f: => Unit) { 
  if (n > 0) {
    f
    repeat(n-1)(f)
  }
}

repeat(event.quantity) { queue.enqueue(event.value) }

Answer 5

我认为最简单的解决方案是使用范围：

(1 to n) foreach (x => /* do something */)

但你也可以创建这个小辅助函数：

implicit def intTimes(i: Int) = new {
    def times(fn: => Unit) = (1 to i) foreach (x => fn)
}

10 times println("hello")

此代码将打印“hello”10 次。隐式转换 intTimes 使方法 times 在所有整数上都可用。因此，在您的情况下，它应该如下所示：

event.quantity times queue.enqueue(event.value) 
event.quantity times queue.dequeue()