Deletion using Linked List Queues in OCAML - linked-list

Question

I'm trying to implement a singly-linked list (queue) in OCAML which is very difficult and not as intuitive as I thought it would be. Let me first state the invariants of the queue that I am implementing:
q.head and q.tail are either both None, or
- q.head and q.tail both point to Some nodes, and
- q.tail is reachable by following 'next' pointers
from q.head
- q.tail's next pointer is None.
The queues and their associated nodes are declared as using options as follows:
type 'a qnode = { v: 'a;
mutable next: 'a qnode option }
type 'a queue = { mutable head: 'a qnode option;
mutable tail: 'a qnode option }
I have many test cases but the one that fails first is this one:
let test (): bool =
let q = from_list [5; 6; 7] in
delete 5 q;
valid q && to_list q = [6; 7]
;; run_test "delete element from front of queue" test
Valid () just tests whether the queue satisfies the invariants. And here is my implementation:
let delete (elt: 'a) (q: 'a queue) : unit =
if not (valid q) then failwith "delete: given invalid queue";
let rec loop_delete (elt: 'a) (no: 'a qnode option) : unit =
begin match no with
|None -> ()
|Some n -> (*Item to delete is only item in queue*)
if n.v = elt && n.next = None then
(q.head <- None; q.tail <- None)
else if n.v = elt && n.next = Some n
then (q.head <- n.next; n.next <- None) else loop_delete elt n.next
end
in loop_delete elt q.head
Why is n.next not updating appropriately? Moreover, I'm sure there are many other issues wrong with my implementation. Any help is appreciated.
EDIT:
According to suggestions below, I've made the following adjustments. The comments indicate remaining confusions.
let delete (elt: 'a) (q: 'a queue) : unit =
if not (valid q) then failwith "delete: given invalid queue";
let rec loop_delete (elt: 'a) (prev: 'a qnode option)
(curr: 'a qnode option) : unit =
begin match prev, curr with
|_, None -> ()
|None, Some n -> if n.v = elt && n.next = None then (q.head <- None; q.tail <- None) (*One element in list only...right??*)
else if n.v = elt && n.next != None then (*How to continuously update prev and curr??* else ()
|Some n, Some n1 -> (*??*)
end
in loop_delete elt None q.head

Answer 1

(Sorry my earlier answer was wrong. I missed that you're using q directly in your helper function.)
Your function loop_delete looks for the matching node, but when it finds the matching node it seems to make unwarranted assumptions. If the matching node n is at the end of the queue (n.next = None), it assumes it was the only element of the queue (it sets q.head and q.tail to None). If the matching node isn't at the end of the queue, it seems to assume that the matching node was at the beginning of the queue (it sets q.head to n.next).
As a separate problem, this is not a reasonable test:
n.next = Some n
What it tests is whether the next pointer of n points to n itself. If you just want to know whether n.next points to any node you could say n.next <> None.
As an even more general comment, when deleting from a singly linked list you generally need to keep track of two nodes, the node you're interested in and the previous node in the list. When you find the node you want to delete, you need to change the next value of the previous node.
You shouldn't really need to think about pointers when coding in OCaml, but it's not too wrong to think of None as a null pointer and Some n as a pointer to the node n. For the first call you don't have a previous node, so the call might look like this:
loop_delete elt None q.head
When you want to move to the next node inside loop_delete, the call might look something like this:
loop_delete elt no n.next
In essence you are passing two values of type 'a qnode option. They represent the previous node and the current node. If there's no previous node it's because you're at the beginning of the list. If there's no current node it's because you're at the end of the list.
Sorry for unhelpful comments earlier. Maybe this is a little better.