generic queue

.golangci.yaml

@@ -40,7 +40,6 @@ linters:
     - gosimple # Code simplification
     - govet # Official Go tool
     - ineffassign # Detects when assignments to existing variables are not used
-    - interfacer # Top-level interface suggestions
     - nakedret # Finds naked/bare returns and requires change them
     - nilerr # Requires explicit returns
     - nilnil # Requires explicit returns

benchmark_test.go

@@ -8,7 +8,7 @@ func benchmarkPush(b *testing.B, items []*mockItem) {
 	b.Helper()
 
 	for i := 0; i < b.N; i++ {
-		q := NewQueue()
+		q := NewQueue[*mockItem]()
 		for _, item := range items {
 			q.Push(item)
 		}
@@ -32,12 +32,12 @@ func BenchmarkHeap_Push100(b *testing.B) {
 func benchmarkPop(
 	b *testing.B,
 	items []*mockItem,
-	popCallback func(q *Queue),
+	popCallback func(q *Queue[*mockItem]),
 ) {
 	b.Helper()
 
 	for i := 0; i < b.N; i++ {
-		q := NewQueue()
+		q := NewQueue[*mockItem]()
 
 		b.StopTimer()
 
@@ -57,7 +57,7 @@ func BenchmarkHeap_PopFront10(b *testing.B) {
 	items := generateRandomItems(10)
 
 	b.ResetTimer()
-	benchmarkPop(b, items, func(q *Queue) {
+	benchmarkPop(b, items, func(q *Queue[*mockItem]) {
 		q.PopFront()
 	})
 }
@@ -66,7 +66,7 @@ func BenchmarkHeap_PopFront100(b *testing.B) {
 	items := generateRandomItems(100)
 
 	b.ResetTimer()
-	benchmarkPop(b, items, func(q *Queue) {
+	benchmarkPop(b, items, func(q *Queue[*mockItem]) {
 		q.PopFront()
 	})
 }
@@ -75,7 +75,7 @@ func BenchmarkHeap_PopBack10(b *testing.B) {
 	items := generateRandomItems(10)
 
 	b.ResetTimer()
-	benchmarkPop(b, items, func(q *Queue) {
+	benchmarkPop(b, items, func(q *Queue[*mockItem]) {
 		q.PopBack()
 	})
 }
@@ -84,7 +84,7 @@ func BenchmarkHeap_PopBack100(b *testing.B) {
 	items := generateRandomItems(100)
 
 	b.ResetTimer()
-	benchmarkPop(b, items, func(q *Queue) {
+	benchmarkPop(b, items, func(q *Queue[*mockItem]) {
 		q.PopBack()
 	})
 }

examples_test.go

@@ -6,47 +6,47 @@ type number struct {
 	value int
 }
 
-func (i number) Less(other Item) bool {
-	return i.value < other.(number).value
+func (i number) Less(other number) bool {
+	return i.value < other.value
 }
 
 func ExampleQueue_Push() {
-	q := NewQueue()
+	q := NewQueue[number]()
 
 	q.Push(number{1}) // 1
 	q.Push(number{2}) // 2
 	q.Push(number{3}) // 3
 
-	fmt.Println(q[0].(number).value)
+	fmt.Println(q[0].value)
 	// Output: 1
 }
 
 func ExampleQueue_PopFront() {
-	q := NewQueue()
+	q := NewQueue[number]()
 
 	q.Push(number{1}) // 1
 	q.Push(number{2}) // 2
 	q.Push(number{3}) // 3
 
 	popped := q.PopFront()
-	fmt.Println(popped.(number).value)
+	fmt.Println(popped.value)
 	// Output: 1
 }
 
 func ExampleQueue_PopBack() {
-	q := NewQueue()
+	q := NewQueue[number]()
 
 	q.Push(number{1}) // 1
 	q.Push(number{2}) // 2
 	q.Push(number{3}) // 3
 
 	popped := q.PopBack()
-	fmt.Println(popped.(number).value)
+	fmt.Println(popped.value)
 	// Output: 3
 }
 
 func ExampleQueue_Fix() {
-	q := NewQueue()
+	q := NewQueue[number]()
 
 	q.Push(number{1}) // 1
 	q.Push(number{2}) // 2
@@ -55,6 +55,6 @@ func ExampleQueue_Fix() {
 	q[0] = number{4} // 1 -> 4
 	q.Fix()
 
-	fmt.Println(q[0].(number).value)
+	fmt.Println(q[0].value)
 	// Output: 2
 }

mock_test.go

@@ -2,7 +2,7 @@ package queue
 
 import "fmt"
 
-type lessDelegate func(Item) bool
+type lessDelegate func(item *mockItem) bool
 
 // mockItem is a mockable Item
 type mockItem struct {
@@ -11,17 +11,12 @@ type mockItem struct {
 	value int
 }
 
-func (m *mockItem) Less(i Item) bool {
+func (m *mockItem) Less(i *mockItem) bool {
 	if m.lessFn != nil {
 		return m.lessFn(i)
 	}
 
-	other, ok := i.(*mockItem)
-	if !ok {
-		return false
-	}
-
-	return m.value < other.value
+	return m.value <= i.value
 }
 
 func (m *mockItem) String() string {

queue.go

@@ -1,26 +1,26 @@
 package queue
 
 // Queue is the priority queue based on insertion sort
-type Queue []Item
+type Queue[T Item[T]] []T
 
 // NewQueue creates an instance of the priority queue
-func NewQueue() Queue {
-	return make(Queue, 0)
+func NewQueue[T Item[T]]() Queue[T] {
+	return make(Queue[T], 0)
 }
 
 // Len returns the length of the queue
-func (q *Queue) Len() int {
+func (q *Queue[T]) Len() int {
 	return len(*q)
 }
 
 // Index returns the element at the specified index, if any.
 // NOTE: panics if out of bounds
-func (q *Queue) Index(index int) Item {
+func (q *Queue[T]) Index(index int) T {
 	return (*q)[index]
 }
 
 // Push adds a new element to the priority queue
-func (q *Queue) Push(item Item) {
+func (q *Queue[T]) Push(item T) {
 	*q = append(*q, item)
 	for i := len(*q) - 1; i > 0; i-- {
 		if (*q)[i].Less((*q)[i-1]) {
@@ -33,7 +33,7 @@ func (q *Queue) Push(item Item) {
 }
 
 // Fix makes sure the priority queue is properly sorted
-func (q *Queue) Fix() {
+func (q *Queue[T]) Fix() {
 	for i := 1; i < len(*q); i++ {
 		for j := i - 1; j >= 0; j-- {
 			if (*q)[j].Less((*q)[j+1]) {
@@ -46,25 +46,25 @@ func (q *Queue) Fix() {
 }
 
 // PopFront removes the first element in the queue, if any
-func (q *Queue) PopFront() Item {
+func (q *Queue[T]) PopFront() *T {
 	if len(*q) == 0 {
 		return nil
 	}
 
 	el := (*q)[0]
 	*q = (*q)[1:]
 
-	return el
+	return &el
 }
 
 // PopBack removes the last element in the queue, if any
-func (q *Queue) PopBack() Item {
+func (q *Queue[T]) PopBack() *T {
 	if len(*q) == 0 {
 		return nil
 	}
 
 	el := (*q)[len(*q)-1]
 	*q = (*q)[:len(*q)-1]
 
-	return el
+	return &el
 }

queue_test.go

@@ -10,19 +10,9 @@ import (
 )
 
 // isSorted checks if the queue is sorted
-func isSorted(q Queue, ascending bool) bool {
-	cmp := func(a, b *mockItem) bool {
-		return a.value <= b.value
-	}
-
-	if !ascending {
-		cmp = func(a, b *mockItem) bool {
-			return a.value >= b.value
-		}
-	}
-
+func isSorted[T Item[T]](q Queue[T]) bool {
 	for i := 0; i < len(q)-1; i++ {
-		if !cmp(q[i].(*mockItem), q[i+1].(*mockItem)) {
+		if !q[i].Less(q[i+1]) {
 			return false
 		}
 	}
@@ -76,26 +66,24 @@ func TestQueue_Insert(t *testing.T) {
 			)
 
 			// Create a new queue
-			q := NewQueue()
+			q := NewQueue[*mockItem]()
 
 			// Push items
 			for _, item := range items {
 				item := item
 
 				if !testCase.ascending {
 					// Prep the items if needed (min / max)
-					item.lessFn = func(i Item) bool {
-						other, _ := i.(*mockItem)
-
-						return item.value >= other.value
+					item.lessFn = func(i *mockItem) bool {
+						return item.value >= i.value
 					}
 				}
 
 				q.Push(item)
 			}
 
 			assert.Len(t, q, numItems)
-			assert.True(t, isSorted(q, testCase.ascending))
+			assert.True(t, isSorted(q))
 		})
 	}
 }
@@ -109,7 +97,7 @@ func TestQueue_PopFront(t *testing.T) {
 	)
 
 	// Create a new queue
-	q := NewQueue()
+	q := NewQueue[*mockItem]()
 
 	// Push items
 	for _, item := range items {
@@ -127,7 +115,7 @@ func TestQueue_PopFront(t *testing.T) {
 	for _, item := range items {
 		popped := q.PopFront()
 
-		assert.Equal(t, item, popped)
+		assert.Equal(t, item, *popped)
 	}
 
 	assert.Len(t, q, 0)
@@ -143,7 +131,7 @@ func TestQueue_PopBack(t *testing.T) {
 	)
 
 	// Create a new queue
-	q := NewQueue()
+	q := NewQueue[*mockItem]()
 
 	// Push items
 	for _, item := range items {
@@ -161,7 +149,7 @@ func TestQueue_PopBack(t *testing.T) {
 	for i := len(items) - 1; i >= 0; i-- {
 		popped := q.PopBack()
 
-		assert.Equal(t, items[i], popped)
+		assert.Equal(t, items[i], *popped)
 	}
 
 	assert.Len(t, q, 0)
@@ -177,7 +165,7 @@ func TestQueue_Fix(t *testing.T) {
 	)
 
 	// Create a new queue
-	q := NewQueue()
+	q := NewQueue[*mockItem]()
 
 	// Push items
 	for _, item := range items {
@@ -197,6 +185,6 @@ func TestQueue_Fix(t *testing.T) {
 	q.Fix()
 
 	assert.Equal(t, q.Len(), numItems)
-	assert.True(t, isSorted(q, true))
+	assert.True(t, isSorted(q))
 	assert.Equal(t, newItem, q.Index(0))
 }

types.go

@@ -1,9 +1,9 @@
 package queue
 
 // Item represents a single queue item
-type Item interface {
+type Item[T any] interface {
 	// Less returns a flag indicating if the element
 	// has a lower value than another element.
 	// For max-priority queue implementations, Less should return true if A > B
-	Less(b Item) bool
+	Less(b T) bool
 }