Scala 多次延迟初始化

在scala中，我找不到一种自然的方式来做这样的事情：

class Car {
  var speed: Int
  var color: String
}

var myCar = new Car()

myCar.set {
  speed = 5
  color = "green"
}

我知道这在Groovy等其他语言中也是可能的。我也知道我可以用这样的构造函数来实现：

val myCar = new Car { 
  speed = 5
  color = "green"
}

我感兴趣的是一种同样的方法，不是在对象构造上，而是在对象已经创建之后

到目前为止，我一直在这样做：

class Car (var speed: Int, var color: String) {

  def set(f: (Car) => Unit) = {
    f(this)
  }

}

val myCar = new Car(5, "red")
myCar.set { c =>
  c.speed = 12
  c.color = "green"
}

但是我不喜欢为每个属性编写'c'变量的需要

---

你知道我该怎么做吗，或者有没有更简单的方法吗？

除非绝对必要，否则你应该避免使用可变类。您通常会在Scala中执行此操作：

case class Car(speed: Int, color: String)

val c1 = Car(5, "red")
val c2 = c1.copy(speed = 12, color = "green")

然后c2是该车的新版本，而c1保持不变

如果你想坚持你的可变类型，为什么不

class Car(var speed: Int, var color: String)

val myCar = new Car(5, "red")
import myCar._
speed = 12
color = "green"

使用专用的集合方法：

---

除非绝对必要，否则应该避免可变类。您通常会在Scala中执行此操作：

case class Car(speed: Int, color: String)

val c1 = Car(5, "red")
val c2 = c1.copy(speed = 12, color = "green")

然后c2是该车的新版本，而c1保持不变

如果你想坚持你的可变类型，为什么不

class Car(var speed: Int, var color: String)

val myCar = new Car(5, "red")
import myCar._
speed = 12
color = "green"

使用专用的集合方法：

---

尽管我们都同意var重新分配是丑陋的，但这是一个可能的解决方案

object DoTo { 
  def apply[T](that: T)(functions: (T) => Unit*): T = {
    functions foreach { _.apply(that) }
    that
  }    
}


class Car (var speed: Int, var color: String) {
  def move() = println("moving")
  def stop() = println("stop")
}


val myNewCar = DoTo(new Car(12, "red")) (
  _.move(),
  _.stop(),
  _.speed = 15,
  _.color = "green"
)

---

这并不完全是我最初想要的，但如果不使用宏，我找不到任何更简单的方法：-

尽管我们都同意var重新分配很难看，但这是一个可能的解决方案

object DoTo { 
  def apply[T](that: T)(functions: (T) => Unit*): T = {
    functions foreach { _.apply(that) }
    that
  }    
}


class Car (var speed: Int, var color: String) {
  def move() = println("moving")
  def stop() = println("stop")
}


val myNewCar = DoTo(new Car(12, "red")) (
  _.move(),
  _.stop(),
  _.speed = 15,
  _.color = "green"
)

---

这并不是我最初想要的，但如果不使用宏，我找不到更简单的方法：-

您可以通过导入变量来实现：

class Car {
  var speed: Int = _
  var color: String = _
}

// ...
val myCar = new Car();
// a blocks that works with myCar:
{
    import myCar._
    // access the content without any prefix
    speed = 5
    color = "green"
}

---

您可以通过导入变量来完成此操作：

class Car {
  var speed: Int = _
  var color: String = _
}

// ...
val myCar = new Car();
// a blocks that works with myCar:
{
    import myCar._
    // access the content without any prefix
    speed = 5
    color = "green"
}

---

在我的上下文中，我有一个可重用的对象池。我不创建新对象，因为它实现起来很慢，这就是为什么我有一个可变类。我发现第二个版本不太容易阅读，即使它基本上是我想做的。当我看到我的第三个版本时，很抱歉我没有真正解释我的整个想法。。。对于第三个版本，在更新类属性时始终需要更新函数。另外，您也不能调用任何方法。我真正想做的是myCar.set{speed=12 color=green move stop}这就是为什么我需要一些更通用的东西你仍然可以使用你定义的set方法，并在函数参数体的顶部写import c.u。为什么在set块中调用move或stop更有意义？您似乎需要类似VB的构造。这是一个难看的黑客行为，但构造is def with thism:this.type=>Unit*：Unit=m.foreach\u this也是如此。然后你就可以开我的车了，速度=12，颜色=绿色，移动，停止，速度=5，移动。但现在，在提出这个建议之后，我必须去洗澡。在我的环境中，我有一个可重用的对象池。我不创建新对象，因为它实现起来很慢，这就是为什么我有一个可变类。我发现第二个版本不太容易阅读，即使它基本上是我想做的。当我看到我的第三个版本时，很抱歉我没有真正解释我的整个想法。。。对于第三个版本，在更新类属性时始终需要更新函数。另外，您也不能调用任何方法。我真正想做的是myCar.set{speed=12 color=green move stop}这就是为什么我需要一些更通用的东西你仍然可以使用你定义的set方法，并在函数参数体的顶部写import c.u。为什么在set块中调用move或stop更有意义？您似乎需要类似VB的构造。这是一个难看的黑客行为，但构造is def with thism:this.type=>Unit*：Unit=m.foreach\u this也是如此。然后你就可以开我的车了，速度=12，颜色=绿色，移动，停止，速度=5，移动。但现在在提出这个建议之后，我必须去洗澡。