相关疑难解决方法(0)

以下代码来自Pathikrit的动态编程存储库.我的美丽和独特使我感到困惑.

def subsetSum(s: List[Int], t: Int) = {
  type DP = Memo[(List[Int], Int), (Int, Int), Seq[Seq[Int]]]
  implicit def encode(key: (List[Int], Int)) = (key._1.length, key._2)

  lazy val f: DP = Memo {
    case (Nil, 0) => Seq(Nil)
    case (Nil, _) => Nil
    case (a :: as, x) => (f(as, x - a) map {_ :+ a}) ++ f(as, x)
  }

  f(s, t)
}

该类型Memo在另一个文件中实现:

case class Memo[I <% K, K, O](f: I => O) extends (I => …

在研究如何在Scala中进行Memoization时,我发现了一些我没有理解的代码.我试图看看这个特别的"东西",但不知道该怎么称呼它; 即引用它的术语.另外,用符号搜索并不容易,唉!

我在这里看到以下代码在Scala中进行memoization :

case class Memo[A,B](f: A => B) extends (A => B) {
  private val cache = mutable.Map.empty[A, B]
  def apply(x: A) = cache getOrElseUpdate (x, f(x))
}

这就是案例类正在扩展的内容,这让我感到困惑extends (A => B).首先,发生了什么？其次,为什么甚至需要呢？最后,你称之为这种继承; 即是否有一些特定的名称或术语可供我参考？

接下来,我看到这样计算Fibanocci号码使用备注这里:

  val fibonacci: Memo[Int, BigInt] = Memo {
    case 0 => 0
    case 1 => 1
    case n => fibonacci(n-1) + fibonacci(n-2)
  }

可能我没有看到正在应用的所有"简化".但是,我无法弄清楚这val条线的终点= Memo {.因此,如果更详细地输入,也许我会理解正在构建备忘录的"跳跃".

非常感谢对此提供的任何帮助.谢谢.

我尽量避免代码中的变量,以便更容易地进行多线程处理.但是,有一行代码开始:

val positions: Hashtable[String, String] ...

我想知道val是否使自动线程安全,或者是否需要担心更多细节？

我正在使用Scala 2.10.3运行此程序:

object Test {
  def main(args: Array[String]) { 
    def factorial(x: BigInt): BigInt = 
      if (x == 0) 1 else x * factorial(x - 1)

    val N = 1000
    val t = new Array[Long](N)
    var r: BigInt = 0

    for (i <- 0 until N) {
      val t0 = System.nanoTime()

      r = r + factorial(300)
      t(i) = System.nanoTime()-t0
    }

    val ts = t.sortWith((x, y) => x < y)

    for (i <- 0 to 10)
      print(ts(i) + "  ")

    println("***  " …

我有这样的功能

def runOnce(request: Request): Future[Result] = {
}

当我调用这个 runOnce 函数时，如果它尚未运行，我希望它运行某个方法并返回该结果。如果它已经运行，我只希望它返回原始结果（传入的请求将是相同的）。

如果我没有像这样的参数，我可以做到

lazy val hydratedModel = hydrateImpl(request)

future for efficient filtering
def fetchHydratedModel(): Future[HydratedModelRequest] = {
   hydratedModel
}

第一种情况怎么办？

我正在尝试在 Scala 中使用记忆功能实现斐波那契函数

这里给出的一个例子使用了一个 case 语句： 在 Scala 中是否有一种通用的记忆方法？

import scalaz.Memo
lazy val fib: Int => BigInt = Memo.mutableHashMapMemo {
  case 0 => 0
  case 1 => 1
  case n => fib(n-2) + fib(n-1)
}

似乎该变量n被隐式定义为第一个参数，但是如果我替换n为_

此外，lazy关键字在这里有什么优势，因为该函数在使用和不使用此关键字的情况下似乎同样有效。

但是，我想将其概括为具有适当类型的更通用的函数定义

import scalaz.Memo
def fibonachi(n: Int) : Int = Memo.mutableHashMapMemo[Int, Int] {
    var value : Int = 0
    if( n <= 1 ) { value = n; }
    else         { value = fibonachi(n-1) + fibonachi(n-2) } …