Question

Scala不允许创建laze vars，只允许lazy vals。这很有意义。

但我已经碰到了用例，我希望能有类似的功能。我需要一个懒惰的变量持有者。可以为其分配应该由耗时算法计算的值。但它可能会在以后重新分配给另一个值，我不想再调用第一个值计算。

假设存在一些魔术变量定义的示例

lazy var value : Int = _
val calc1 : () => Int = ... // some calculation
val calc2 : () => Int = ... // other calculation
value = calc1
value = calc2
val result : Int = value + 1

这段代码应该只调用calc2（），而不是calc1

我知道如何使用隐式转换和特殊容器类编写此容器。我很好奇是否有任何嵌入式scala功能不需要我编写不必要的代码

Answer 1

这有效：

var value: () => Int = _
val calc1: () => Int = () => { println("calc1"); 47 }
val calc2: () => Int = () => { println("calc2"); 11 }
value = calc1
value = calc2
var result = value + 1 /* prints "calc2" */

implicit def invokeUnitToInt(f: () => Int): Int = f()

让隐含的人稍微担心，因为它广泛适用，这可能会导致意外的应用程序或编译器错误的含糊不清。

另一种解决方案是使用带有setter的包装器对象和为您实现惰性行为的getter方法：

lazy val calc3 = { println("calc3"); 3 }
lazy val calc4 = { println("calc4"); 4 }

class LazyVar[A] {
  private var f: () => A = _
  def value: A = f() /* getter */
  def value_=(f: => A) = this.f = () => f /* setter */
}

var lv = new LazyVar[Int]
lv.value = calc3
lv.value = calc4
var result = lv.value + 1 /* prints "calc4 */

Answer 2

你可以简单地让编译器自己动手做，并且这样做：

class Foo {
  private[this] var _field: String = _
  def field = {
    if(_field == null) {
      _field = "foo" // calc here
    }
    _field
  }

  def field_=(str: String) {
    _field = str
  }
}

scala> val x = new Foo
x: Foo = Foo@11ba3c1f

scala> x.field
res2: String = foo

scala> x.field = "bar"
x.field: String = bar

scala> x.field
res3: String = bar

编辑：这在电流形式中不是线程安全的！

edit2：

与mhs的第二个解决方案的区别在于，计算只会发生一次，而在mhs的解决方案中，它会被反复调用。

Answer 3

var value: () => Int = _
lazy val calc1 = {println("some calculation"); 1}
lazy val calc2 = {println("other calculation"); 2}
value = () => calc1
value = () => calc2

scala> val result : Int = value() + 1
other calculation
result: Int = 3

Answer 4

如果你想继续使用lazy val（它可以在路径依赖类型中使用并且它是线程安全的），你可以在其定义中添加一个间接层（以前的解决方案使用{{1} s作为间接）：

var

当然，如果你想重复使用它，你可以将它封装在一个类中。

Answer 5

我总结了所有提供的构建自定义容器的建议：

object LazyVar {

  class NotInitialized extends Exception

  case class Update[+T]( update : () => T )
  implicit def impliciţUpdate[T](update: () => T) : Update[T] = Update(update)

  final class LazyVar[T] (initial : Option[Update[T]] = None ){
    private[this] var cache : Option[T] = None
    private[this] var data : Option[Update[T]] = initial

    def put(update : Update[T]) : LazyVar[T] = this.synchronized {
      data = Some(update)
      this
    }
    def set(value : T) : LazyVar[T] = this.synchronized {
      data = None
      cache = Some(value)
      this
    }
    def get : T = this.synchronized { data match {
      case None => cache.getOrElse(throw new NotInitialized)
      case Some(Update(update)) => {
        val res = update()
        cache = Some(res)
        res
      }
    } }

    def := (update : Update[T]) : LazyVar[T] = put(update)
    def := (value : T) : LazyVar[T] = set(value)
    def apply() : T = get
  }
  object LazyVar {
    def apply[T]( initial : Option[Update[T]] = None ) = new LazyVar[T](initial)
    def apply[T]( value : T) = {
      val res = new LazyVar[T]()
      res.set(value)
      res
    }
  }
  implicit def geţLazy[T](lazyvar : LazyVar[T]) : T = lazyvar.get

  object Test {
    val getInt1 : () => Int = () => {
      print("GetInt1")
      1
    }
    val getInt2 : () => Int = () => {
      print("GetInt2")
      2
    }
    val li : LazyVar[Int] = LazyVar()
    li := getInt1
    li := getInt2
    val si : Int = li
  }
}

在scala中做一个懒惰变量

5 个答案: