26

场景：
我想实现一个无限列表：

abstract class MyList[+T]
case object MyNil extends MyList[Nothing]
case class MyNode[T](h:T,t: => MyList[T]) extends MyList[T]

//error: `val' parameters may not be call-by-name

问题：
错误是call-by-name不允许的。

我听说这是因为val.orvar不允许使用构造函数参数call-by-name。例如：

class A(val x: =>Int) 
//error: `val' parameters may not be call-by-name

但相比之下，普通的构造函数参数仍然是val，尽管如此private。例如：

class A(x: =>Int) 
// pass

所以问题：

  • 问题真的是关于val或var吗？
    • 如果是这样，因为点call-by-name是推迟计算。为什么不能推迟计算（或初始化）val？var
  • 如何绕过case class实现无限列表的限制？
4

4 回答 4

16

没有矛盾：class A(x: => Int)等价于class A(private[this] val x: => Int)and not class A(private val x: => Int)。private[this]将值标记为实例私有，而没有进一步说明的私有修饰符允许从该类的任何实例访问该值。

不幸的是，case class A(private[this] val x: => Int)也不允许定义 a 。我认为这是因为案例类需要访问其他实例的构造函数值，因为它们实现了该equals方法。

不过，您可以实现案例类手动提供的功能：

abstract class MyList[+T]

class MyNode[T](val h: T, t: => MyList[T]) extends MyList[T]{

  def getT = t // we need to be able to access t 

  /* EDIT: Actually, this will also lead to an infinite recursion
  override def equals(other: Any): Boolean = other match{
    case MyNode(i, y) if (getT == y) && (h == i) => true
    case _ => false
  }*/

  override def hashCode = h.hashCode

  override def toString = "MyNode[" + h + "]"

}

object MyNode {
  def apply[T](h: T, t: => MyList[T]) = new MyNode(h, t)
  def unapply[T](n: MyNode[T]) = Some(n.h -> n.getT)
}

要检查此代码，您可以尝试：

def main(args: Array[String]): Unit = {
  lazy val first: MyNode[String] = MyNode("hello", second)
  lazy val second: MyNode[String] = MyNode("world", first)
  println(first)
  println(second)
  first match {
    case MyNode("hello", s) => println("the second node is " + s)
    case _ => println("false")
  }
}

不幸的是，我不确定为什么禁止按名称调用 val 和 var 成员。然而，它至少有一个危险：想想 case-classes 是如何实现的toString；toString调用每个构造函数值的- 方法。这可能（并且在这个例子中）导致值无限地调用自己。您可以通过添加t.toString到MyNode's toString-method 来检查这一点。

编辑：在阅读了 Chris Martin 的评论后： 的实现equals也会带来一个可能比实现更严重的问题toString（主要用于调试）和hashCode（如果你不能采取只会导致更高的碰撞率）参数考虑）。您必须仔细考虑如何实施equals才有意义。

于 2014-11-05T04:59:04.347 回答
6

我也没有找到为什么在案例类中禁止使用名称参数。我想解释应该相当详尽和复杂。但是 Runar Bjarnason 在他的《Scala 函数式编程》一书中提供了一个很好的方法来解决这个障碍。他将“thunk”的概念与记忆一起使用。下面是一个 Stream 实现的例子：

sealed trait Stream[+A]
case object Empty extends Stream[Nothing]
case class Cons[+A](h: () => A, t: () => Stream[A]) extends Stream[A]
object Stream {
 def cons[A](hd: => A, tl: => Stream[A]): Stream[A] = {
  lazy val head = hd
  lazy val tail = tl
  Cons(() => head, () => tail)
 }
 def empty[A]: Stream[A] = Empty
 def apply[A](as: A*): Stream[A] =
  if (as.isEmpty) empty else cons(as.head, apply(as.tail: _*))
 }
}

如您所见，他们使用所谓的“thunk”，一个零参数的函数，而不是案例类数据构造函数的常规名称参数() => T。然后为了让用户透明，他们在伴生对象中声明了一个智能构造函数，它允许您提供按名称参数并使其记忆。

于 2016-08-29T18:21:21.140 回答
1

这实际上是与Stream解决方案类似的方法，但简化为实际需要的方法：

case class A(x: () => Int) {
  lazy val xx = x()
}

因此，您可以将案例类用作：

def heavyOperation: Int = ???
val myA = A(heavyOperation)
val myOtherA = A(() => 10)
val useA = myA.xx + myOtherA.xx

像这样，实际的繁重操作只会在您使用时执行xx，即仅在最后一行执行。

于 2019-03-19T15:09:54.777 回答
0

我喜欢使用隐式函数来使 thunk 像按名称调用一样工作。

例如在这个例子中：

case class Timed[R](protected val block: () => R) {
    override def toString() = s"Elapsed time: $elapsedTime"

    val t0 = System.nanoTime()
    val result = block() // execute thunk
    val t1 = System.nanoTime()
    val elapsedTime = t1 - t0
  }

  implicit def blockToThunk[R](bl: => R) = () => bl //helps to call Timed without the thunk syntax

这让我们调用 Timed({Thread.sleep(1000); println("hello")}) 例如使用按名称调用语法

于 2021-06-02T18:34:48.823 回答