Doubly linked list in mojo

[ljh]

Hi, how to define the node type for doubly linked list? Could the following work?

Thanks

from memory import ArcPointer
struct Node(Copyable, Movable):
  var x: Int
  var prev: ArcPointer[Self]
  var next: ArcPointer[Self]

[Ehsan (Ehsan M. Kermani)]

There’re many ways. A simple example is

struct Node(Copyable & Movable & Writable):
    var data: Int
    var prev: UnsafePointer[Node]
    var next: UnsafePointer[Node]

    fn __init__(
        out self,
        data: Int,
        prev: UnsafePointer[Node] = UnsafePointer[Node](),
        next: UnsafePointer[Node] = UnsafePointer[Node](),
    ):
        self.data = data
        self.prev = prev
        self.next = next

    fn write_to(self, mut writer: Some[Writer]):
        writer.write("Node(", self.data)
        if self.prev:
            writer.write(", prev=", self.prev[].data)
        else:
            writer.write(", prev=None")
        if self.next:
            writer.write(", next=", self.next[].data)
        else:
            writer.write(", next=None")
        writer.write(")")


def main():
    node = Node(data=1)
    node2 = Node(data=2, prev=UnsafePointer[Node](to=node))
    node.next = UnsafePointer[Node](to=node2)
    node3 = Node(
        data=3, prev=UnsafePointer[Node](to=node2), next=UnsafePointer[Node]()
    )
    node2.next = UnsafePointer[Node](to=node3)
    print(node)
    print(node2)
    print(node3)

outputs

Node(1, prev=None, next=2)
Node(2, prev=1, next=3)
Node(3, prev=2, next=None)

[ljh]

Hi, what is the difference between comma and ampersand in trait combination? They both mean all of the traits, right?

# struct Node(Copyable , Movable , Writable)
# struct Node(Copyable & Movable & Writable)

[christoph_schlumpf]

Yes, they are the same. The & syntax is newer and can be used in more places like in parameter and argument definitions in function declarations.