如何在scala中返回一个函数

Question

如何返回 function Scala 中的副作用词法闭包¹？

例如，我正在查看 Go 中的此代码示例

...    
// fib returns a function that returns
// successive Fibonacci numbers.
func fib() func() int {
    a, b := 0, 1
    return func() int {
        a, b = b, a+b
        return b
    }
}
...
println(f(), f(), f(), f(), f())

： 1 2 3 5 8

我不知道如何在 Scala 中编写相同的内容。

^{1.在Apocalisp评论}后更正

Answer 1

稍微短一点，不需要退货。

def fib() = {
    var a = 0
    var b = 1
    () => { 
        val t = a;
        a = b
        b = t + b
        b
    }
}

Answer 2

嘎！可变变量？！

val fib: Stream[Int] =
  1 #:: 1 #:: (fib zip fib.tail map Function.tupled(_+_))

您可以返回一个获取第 n 个 fib 的文字函数，例如：

val fibAt: Int => Int = fib drop _ head

编辑：由于您要求“每次调用 f 时获取不同的值”的功能方式，因此您将这样做。这使用了 Scalaz 的 State monad：

import scalaz._
import Scalaz._

def uncons[A](s: Stream[A]) = (s.tail, s.head)
val f = state(uncons[Int])

值 f 是一个状态转换函数。给定一个流，它将返回其头部，并通过获取其尾部来“变异”侧面的流。请注意，f 完全忽略了fib。下面是一个 REPL 会话，说明了其工作原理：

scala> (for { _ <- f; _ <- f; _ <- f; _ <- f; x <- f } yield x)
res29: scalaz.State[scala.collection.immutable.Stream[Int],Int] = scalaz.States$anon$1@d53513

scala> (for { _ <- f; _ <- f; _ <- f; x <- f } yield x)
res30: scalaz.State[scala.collection.immutable.Stream[Int],Int]  = scalaz.States$anon$1@1ad0ff8

scala> res29 ! fib
res31: Int = 5

scala> res30 ! fib
res32: Int = 3

显然，您得到的值取决于您调用 f 的次数。但这都是纯功能性的，因此是模块化和可组合的。例如，我们可以传递任何非空 Stream，而不仅仅是 fib。

所以你看，你可以产生效果而没有副作用。

Answer 3

虽然我们正在分享与问题无关的斐波那契函数的酷实现，但这里有一个记忆版本：

val fib: Int => BigInt = {                         
   def fibRec(f: Int => BigInt)(n: Int): BigInt = {
      if (n == 0) 1 
      else if (n == 1) 1 
      else (f(n-1) + f(n-2))                           
   }                                                     
   Memoize.Y(fibRec)
}

它使用实现的记忆定点组合器作为此问题的答案：在 Scala 2.8 中，使用什么类型存储内存中的可变数据表？

顺便说一句，组合器的实现建议使用一种稍微更明确的技术来实现 function 副作用词法闭包：

def fib(): () => Int = {
   var a = 0
   var b = 1
   def f(): Int = {
      val t = a;
      a = b
      b = t + b
      b
  }
  f
}

Answer 4

知道了！！经过一番尝试和错误：

def fib() : () => Int = {
    var a = 0
    var b = 1
    return (()=>{ 
        val t = a;
        a = b
        b = t + b
        b
    })
}

测试：

val f = fib()
println(f(),f(),f(),f())

1 2 3 5 8

Answer 5

使用元组时不需要临时变量：

def fib() = {
  var t = (1,-1)
  () => { 
    t = (t._1 + t._2, t._1)
    t._1
  }
}

但在现实生活中，您应该使用 Apocalisp 的解决方案。