feat(stdlib): Add == operator to Queue module

compiler/test/stdlib/queue.test.gr

@@ -135,6 +135,74 @@ Queue.push(4, qa1)
 assert Queue.fromArray([> 1, 2, 3, 4]) == qa1
 assert Queue.fromArray([>]) == Queue.makeSized(16)
 
+// Queue.equal
+from Queue use { (==) }
+let queue1 = Queue.make()
+let queue2 = Queue.make()
+Queue.push(1, queue2)
+Queue.push(2, queue2)
+Queue.push(3, queue2)
+Queue.push(4, queue2)
+Queue.pop(queue2)
+Queue.pop(queue2)
+Queue.push(5, queue2)
+Queue.pop(queue2)
+Queue.pop(queue2)
+Queue.pop(queue2)
+Queue.push(6, queue2)
+Queue.push(7, queue2)
+Queue.push(8, queue2)
+Queue.push(9, queue2)
+Queue.push(10, queue2)
+Queue.push(11, queue2)
+Queue.push(12, queue2)
+Queue.push(13, queue2)
+Queue.push(14, queue2)
+Queue.push(15, queue2)
+Queue.push(16, queue2)
+Queue.push(17, queue2)
+Queue.push(18, queue2)
+Queue.push(19, queue2)
+let queue3 = Queue.make()
+Queue.push(1, queue3)
+Queue.push(2, queue3)
+Queue.push(3, queue3)
+let queue4 = Queue.copy(queue3)
+Queue.pop(queue4)
+let queue5 = Queue.make()
+Queue.push(6, queue5)
+Queue.push(7, queue5)
+Queue.push(8, queue5)
+Queue.push(9, queue5)
+Queue.push(10, queue5)
+Queue.push(11, queue5)
+Queue.push(12, queue5)
+Queue.push(13, queue5)
+Queue.push(14, queue5)
+Queue.push(15, queue5)
+Queue.push(16, queue5)
+Queue.push(17, queue5)
+Queue.push(18, queue5)
+Queue.push(19, queue5)
+assert queue2 == queue5
+let queue6 = Queue.make()
+Queue.push(1, queue6)
+Queue.push(2, queue6)
+Queue.push(3, queue6)
+assert queue3 == queue6
+let queue7 = Queue.make()
+Queue.push(2, queue7)
+Queue.push(3, queue7)
+assert queue4 == queue7
+let queue8 = Queue.make()
+Queue.push(1, queue8)
+Queue.pop(queue8)
+assert queue8 == queue1
+
+assert !(queue2 == queue3)
+assert !(queue5 == queue6)
+from Pervasives use { (==) }
+
 module Immutable {
   from Queue use { module Immutable as Queue }
 

stdlib/queue.gr

@@ -225,6 +225,32 @@ provide let fromArray = arr => {
   { size, array: contents, headIndex: 0, tailIndex: size }
 }
 
+/**
+ * Checks if two queues are equivalent by value.
+ *
+ * @param queue1: The first queue to compare
+ * @param queue2: The second queue to compare
+ * @returns `true` if the queues are equivalent or `false` otherwise
+ *
+ * @since v0.6.0
+ */
+provide let (==) = (queue1, queue2) => {
+  if (queue1.size != queue2.size) return false
+  let len1 = Array.length(queue1.array)
+  let len2 = Array.length(queue2.array)
+  for (let mut i = 0; i < queue1.size; i += 1) {
+    // Get the index of element from queue1
+    let mut index1 = queue1.headIndex + i
+    if (index1 >= len1) index1 -= len1
+    // Get the index of element from queue2
+    let mut index2 = queue2.headIndex + i
+    if (index2 >= len2) index2 -= len2
+
+    if (queue1.array[index1] != queue2.array[index2]) return false
+  }
+  return true
+}
+
 /**
  * An immutable queue implementation.
  */

stdlib/queue.md

@@ -294,6 +294,32 @@ Returns:
 |----|-----------|
 |`Queue<a>`|A queue containing all values from the array|
 
+### Queue.**(==)**
+
+<details disabled>
+<summary tabindex="-1">Added in <code>next</code></summary>
+No other changes yet.
+</details>
+
+```grain
+(==) : (queue1: Queue<a>, queue2: Queue<a>) => Bool
+```
+
+Checks if two queues are equivalent by value.
+
+Parameters:
+
+|param|type|description|
+|-----|----|-----------|
+|`queue1`|`Queue<a>`|The first queue to compare|
+|`queue2`|`Queue<a>`|The second queue to compare|
+
+Returns:
+
+|type|description|
+|----|-----------|
+|`Bool`|`true` if the queues are equivalent or `false` otherwise|
+
 ## Queue.Immutable
 
 An immutable queue implementation.