Question

I want to implement some kind of a simple linked list.

I defined an abstract No, with a field next, its type is Node.
Then I have a bunch of other specific Node, inheriting the abstract node.

I write like this:

abstract class Node {
  def next: Node   
}

case class SpecificNode(nxt: Node) extends Node {
  val next = nxt
}

object NullNode extends Node{
  val next = new Exception("no more node")
}

However, I find that I need to change the field next later, in the SpecificNode,
so I make

case class SpecificNode(nxt: Node) extends Node {
  var next = nxt
}

However, I can not assign to the next field of an instance of some specific node ,e.g sn.next = ..., because the compiler complains next_ is not a member of Node.

Then I changed to use var in the abstract class Node for the next field.

But when I new a NullNode, exception will be thrown (since I defined so..)

So how should I use the var, def, val here?
How should I define the NullNode, which is to signify no more node?

Answer 1

You need to explicitly define getter/setter in your interface. In our case (without changing structure and idea):

trait Node {
    def next: Node
    def next_=(node: Node)
}

// `var next: Node` generates implementations for `def next: Node` and `def next_=(node: Node)`
case class SpecificNode(var next: Node) extends Node

object NullNode extends Node {
    def next = throw new Exception("no more node")
    def next_=(node: Node) { throw new Exception("can't change next on null node") }
}

val n1 = SpecificNode(NullNode)
val n2 = SpecificNode(SpecificNode(NullNode))
val n3: Node = SpecificNode(n1)

// some function to test our structure:
def length(n: Node, prev: Int = 0): Int = if (n == NullNode) prev else length(n.next, prev + 1)

println(length(n3))
n3.next = n2
println(length(n3))

Side note: this is mutable linked list, I suggest you to check how immutable list implemented in standard scala library