Can you tell me why this code doesn't work?

[mjsshell]

It’s been ages since I wrote Adept code, so yeah, definite brain rot here. The code was generated by AI for C, but I ported it to Adept. I’m sorry, but I’m too incompetent—even as a hobbyist coder—to write it myself.

// Circular Doubly Linked List

import 'sys/cstdio.adept'
import 'sys/cstdlib.adept'

// Node definition

struct Node ( data int, next *Node, prev *Node)

func createNode(data int) *Node {
    newNode *Node = malloc(sizeof Node)
    newNode.data = data
    newNode.next = newNode // points to itself initially
    newNode.prev = newNode
    return newNode
}

func insertEnd(head **Node, data int) void {
    newNode *Node = createNode(data)

    if (*head == null) {
        *head = newNode
        return
    }

    last *Node = (*head).prev

    newNode.next = *head
    (*head).prev = newNode
    newNode.prev = last
    last.next = newNode
}

func displayForward(head *Node) void {
    if (head == null) return

    temp *Node = head
    until (temp == head) {
        printf('%d ', temp.data)
        temp = temp.next
    }
    printf('\n')
}

func displayBackward(head *Node) void {
    if (head == null) return

    last *Node = head.prev
    temp *Node = last
    until (temp == last) {
        printf('%d ', temp.data)
        temp = temp.prev
    }
    printf('\n')
}

func main() void {
    head *Node = null

    insertEnd(&head, 10)
    insertEnd(&head, 20)
    insertEnd(&head, 30)

    printf('Forward Traversal: ')
    displayForward(head)

    printf('Backward Traversal: ')
    displayBackward(head)
}

[IsaacShelton]

I think the AI is not very accurate, if you read about what a doubly-linked list is and watch some videos about it, then it eventually it will make sense. For inserting, we have to find the node that we want the new one to go before/after. Then we attach the next or prev pointer of the existing node to the new node and vice-versa (which way depends on whether in-front or behind existing node).

It depends on what you're trying to do, but you can compare to this which works:

import 'sys/cstdio.adept'
import 'sys/cstdlib.adept'

struct Node (data int, prev, next *Node)

func createNode(data int) *Node {
    n *Node = new Node
    n.data = data
    n.next = null
    n.prev = null
    return n
}

func insertFront(head **Node, data int) {
    n *Node = createNode(data)
    n.next = *head
    (*head).prev = n
    *head = n
}

func insertBack(head **Node, data int) {
    n *Node = createNode(data)

    if *head == null {
        *head = n
        return
    }

    last *Node = *head
    while last.next {
        last = last.next
    }

    n.prev = last
    last.next = n
}

func displayForwards(head *Node) {
    until head == null {
        printf('%d ', head.data)
        head = head.next
    }
    printf('\n')
}

func displayBackwards(head *Node) {
    if head == null, return

    last *Node = head
    while last.next {
        last = last.next
    }

    until last.prev == null {
        printf('%d ', last.data)
        last = last.prev
    }
    printf('%d ', last.data)
    printf('\n')
}

func main() {
    head *Node = null

    insertBack(&head, 10)
    insertBack(&head, 20)
    insertBack(&head, 30)

    printf('Forward Traversal: ')
    displayForwards(head)

    printf('Backward Traversal: ')
    displayBackwards(head)
}

or the generic version:

import 'sys/cstdio.adept'
import 'sys/cstdlib.adept'

struct <$T> Node (data $T, prev, next *<$T> Node)

func createNode(data $T) *<$T> Node {
    n *<$T> Node = new <$T> Node
    n.data = data
    n.next = null
    n.prev = null
    return n
}

func insertFront(head **<$T> Node, data $T) {
    n *<$T> Node = createNode(data as $T) // (hack to make sure data is $T, not just compatible with $T)
    n.next = *head
    (*head).prev = n
    *head = n
}

func insertBack(head **<$T> Node, data $T) {
    n *<$T> Node = createNode(data as $T) // (hack to make sure data is $T, not just compatible with $T)

    if *head == null {
        *head = n
        return
    }

    last *<$T> Node = *head
    while last.next {
        last = last.next
    }

    n.prev = last
    last.next = n
}

func displayForwards(head *<int> Node) {
    until head == null {
        printf('%d ', head.data)
        head = head.next
    }
    printf('\n')
}

func displayBackwards(head *<int> Node) {
    if head == null, return

    last *<int> Node = head
    while last.next {
        last = last.next
    }

    until last.prev == null {
        printf('%d ', last.data)
        last = last.prev
    }
    printf('%d ', last.data)
    printf('\n')
}

func main() {
    head *<int> Node = null

    insertBack(&head, 10)
    insertBack(&head, 20)
    insertBack(&head, 30)

    printf('Forward Traversal: ')
    displayForwards(head)

    printf('Backward Traversal: ')
    displayBackwards(head)
}

[mjsshell]

To be clear, I asked it to implement a Circular Doubly Linked List for me.

[IsaacShelton]

For a circular doubly-linked list example, see below (note, the prints will go on forever since it's cyclic):

import 'sys/cstdio.adept'
import 'sys/cstdlib.adept'

struct <$T> Node (data $T, prev, next *<$T> Node)

func createNode(data $T) *<$T> Node {
    n *<$T> Node = new <$T> Node
    n.data = data
    n.next = n
    n.prev = n
    return n
}

func insertFront(head **<$T> Node, data $T) {
    n *<$T> Node = createNode(data as $T) // (hack to make sure data is $T, not just compatible with $T)
    
    if *head == null {
        *head = n
        return
    }

    last *<$T> Node = (*head).prev

    n.next = *head
    (*head).prev = n
    n.prev = last
    last.next = n
    *head = n
}

// (Inserting at the back is the same as inserting at the front and then moving forward one)
func insertBack(head **<$T> Node, data $T) {
    insertFront(head, data)
    *head = (*head).next
}

func displayForwards(head *<int> Node) {
    until head == null {
        printf('%d ', head.data)
        head = head.next
    }
    printf('\n')
}

func displayBackwards(head *<int> Node) {
    if head == null {
        return
    }

    last *<int> Node = head.prev

    until last == null {
        printf('%d ', last.data)
        last = last.prev
    }
    printf('\n')
}

func main() {
    head *<int> Node = null

    insertBack(&head, 10)
    insertBack(&head, 20)
    insertBack(&head, 30)

    printf('Forward Traversal: ')
    displayForwards(head)

    printf('Backward Traversal: ')
    displayBackwards(head)
}

[mjsshell]

I fixed the code and it's running fine now:

import 'sys/cstdio.adept'
import 'sys/cstdlib.adept'

struct <$T> Node (data $T, prev, next *<$T> Node)

func createNode(data $T) *<$T> Node {
    n *<$T> Node = new <$T> Node
    n.data = data
    n.next = n
    n.prev = n
    return n
}

func insertFront(head **<$T> Node, data $T) {
    n *<$T> Node = createNode(data as $T) // (hack to make sure data is $T, not just compatible with $T)
    
    if *head == null {
        *head = n
        return
    }

    last *<$T> Node = (*head).prev

    n.next = *head
    (*head).prev = n
    n.prev = last
    last.next = n
    *head = n
}

// (Inserting at the back is the same as inserting at the front and then moving forward one)
func insertBack(head **<$T> Node, data $T) {
    insertFront(head, data)
    *head = (*head).next
}

func displayForwards(head *<int> Node) {
    if head == null {
        return
    }
    
    last *<int> Node = head.prev
    
    until break {
        printf('%d ', head.data)
        head = head.next
        if head == last {
            printf('%d ', head.data)
            break
        }
    }
    printf('\n')
}

func displayBackwards(head *<int> Node) {
    if head == null {
        return
    }

    last *<int> Node = head.prev

    until break {
        printf('%d ', last.data)
        last = last.prev
        if last == head {
            printf('%d ', last.data)
            break
        }
    }
    printf('\n')
}

func main() {
    head *<int> Node = null

    insertBack(&head, 10)
    insertBack(&head, 20)
    insertBack(&head, 30)

    printf('Forward Traversal: ')
    displayForwards(head)

    printf('Backward Traversal: ')
    displayBackwards(head)
}

By running fine, I mean it can now print the expected results. I don't know whether there are other issues.

As you can see, my code is ugly. I used a weird and not very elegant until ... break block. I still can't wrap my mind around while ... continue. Even though I'm not English speaker, while ... continue still feels like corrupting the grammar of the English language to me. until ... break just feels a bit slightly better.

[mjsshell]

Maybe the code can be converted to while ... continue like this:

// displayForwards
while continue {
    printf('%d ', head.data)
    head = head.next
    if head == last, continue
}

// displayBackwards
while continue {
    printf('%d ', last.data)
    last = last.prev
    if last == head, continue
}

[mjsshell]

This is my code for AVL Tree (w/ the help of AI):

import 'sys/cstdio.adept'
import 'sys/cstdlib.adept'

struct <$T> AVLNode (
    data $T,
    height int,
    left *<$T> AVLNode,
    right *<$T> AVLNode
)

func max(a int, b int) int {
    if a > b {
        return a
    }
    return b
}

func height(n *<$T> AVLNode) int {
    if n == null {
        return 0
    }
    return n.height
}

func createNode(data $T) *<$T> AVLNode {
    node *<$T> AVLNode = new <$T> AVLNode
    node.data = data
    node.height = 1
    node.left = null
    node.right = null
    return node
}

func rightRotate(y *<$T> AVLNode) *<$T> AVLNode {
    x *<$T> AVLNode = y.left
    T2 *<$T> AVLNode = x.right

    x.right = y
    y.left = T2

    y.height = max(height(y.left), height(y.right)) + 1
    x.height = max(height(x.left), height(x.right)) + 1

    return x
}

func leftRotate(x *<$T> AVLNode) *<$T> AVLNode {
    y *<$T> AVLNode = x.right
    T2 *<$T> AVLNode = y.left

    y.left = x
    x.right = T2

    x.height = max(height(x.left), height(x.right)) + 1
    y.height = max(height(y.left), height(y.right)) + 1

    return y
}

func getBalance(n *<$T> AVLNode) int {
    if n == null {
        return 0
    }
    return height(n.left) - height(n.right)
}

func insert(root *<$T> AVLNode, data $T) *<$T> AVLNode {
    if root == null {
        return createNode(data as $T)
    }

    if data < root.data {
        root.left = insert(root.left, data)
    } else if data > root.data {
        root.right = insert(root.right, data)
    } else {
        return root // duplicates not allowed
    }

    root.height = 1 + max(height(root.left), height(root.right))
    balance int = getBalance(root)

    // Left Left Case
    if balance > 1 && data < root.left.data {
        return rightRotate(root)
    }

    // Right Right Case
    if balance < -1 && data > root.right.data {
        return leftRotate(root)
    }

    // Left Right Case
    if balance > 1 && data > root.left.data {
        root.left = leftRotate(root.left)
        return rightRotate(root)
    }

    // Right Left Case
    if balance < -1 && data < root.right.data {
        root.right = rightRotate(root.right)
        return leftRotate(root)
    }

    return root
}

func inOrder(root *<int> AVLNode) {
    if root != null {
        inOrder(root.left)
        printf('%d ', root.data)
        inOrder(root.right)
    }
}

func main() {
    root *<int> AVLNode = null
    root = insert(root, 30)
    root = insert(root, 20)
    root = insert(root, 40)
    root = insert(root, 10)
    root = insert(root, 25)
    root = insert(root, 35)
    root = insert(root, 50)

    printf('In-order traversal: ')
    inOrder(root)
    printf('\n')
}

[IsaacShelton]

Nice,

Yes while continue does feel like corrupting English grammar a little bit. while continue is the logical opposite of until break though which is where it gets its name. 👍