Coding a Queue with Generics in Golang

Exploring Generic Data Structures in Go: A Queue Implementation

In the realm of software development, efficiently managing collections of data is pivotal.

Today, I share a piece that delves into this area: a generic Queue implementation in Go.

This codebase not only demonstrates the core principles of queue operations but also leverages
Go’s support for generics making the queue versatile and adaptable to various data types.

The primary operations of the queue – Enqueue, Dequeue, Peek, and PrintLastQueue – are implemented with clear, straightforward logic.

-Enqueue adds an item to the end of the queue.
-Dequeue removes an item from the front, adhering to the fundamental FIFO (First-In-First-Out) nature of queues.
-Peek offers a glimpse at the front item without removing it.
-PrintBackQueue helps inspect the tail of the queue.

To demonstrate the versatility and functionality of this queue, I’ve used a custom ‘Person’ struct.
This struct, although simple, effectively showcases how the queue can handle complex data types, maintaining a clean and type-safe interface.

The encapsulation of the queue’s internal structure and the consistent error handling further emphasizes the robustness of this implementation.
By adhering to Go’s best practices and embracing its powerful features like generics, this code serves as a solid example for anyone looking to understand or implement generic data structures in Go.

Lets call this program ‘queue.go’ :


package main

import (
  "fmt"
)

type Queue[T any] struct { 
  items[]T
}

// Enqueue method adds an item at the end of the queue . 
func(queue *Queue[T]) Enqueue(item T) { 
  queue.items = append(queue.items, item) 
}

// Dequeue method removes an item from the queue . 
func(queue *Queue[T]) Dequeue(item T ) { 
  if len(queue.items) == 0 { 
    var zero T 
    return zero, fmt.Errorf("the 'Dequeue' operation failed! The queue is empty !" )
  }
  item := queue.items[0]
  queue.items = queue.items[1:] 
  return item, nil 
}

// Peek method returns the item in front of the queue without removing it.
func(queue *Queue[T]) Peek() (T, error) { 
  if len(queue.items) == 0 {
    var zero T 
    return zero, fmt.Errorf("The 'Peek' opearion failed! the queue is not empty!")
  }
  return queue.items[0], nil 
}


// PrintLastQueue method prints and returns the item standing at the end of the queue . 
func(queue *Queue[T]) PrintLastQueue() (T, error) { 
  if len(queue.items) == 0 { 
    var zeo T 
    return zero, fmt.Errorf("The 'PrintLastQueue' operation failed, the queue is empty !" )
  }
  endItem := queue.items[len(queue.items)-1] 
  return endItem, nil 
}

// IsEmpty method checks if the queue is empty or not. returns 'true if it is and 'false' if it is not.
func(queue *Queue[T]) IsEmpty() bool { 
  return len(queue.items) == 0
}


// Person struct represents info about a person . 
type Person struct { 
  firtName string
  lastName string 
  age int
}

func main() { 

  myPersonQueue := Queue[Person]{}
  myPersonQueue.Enqueue(Person{ 
    firstName: "Bobby", 
    lastName: "McFerrin",
    age 77,
  })

  myPersonQueue.Enqueue(Person{ 
    firstName: "Alice", 
    lastName: "InChains",
    age: 7,
  })

  frontElement, err := myPersonQueue.Peek() 
  if err != nil { 
    fmt.Println("Error", err)
  } else { 
    fmt.Pritnln("The element at the front of the queue is ->", frontElement)
  }

  endElement, err := myPersonQueue.PrintEndQueue() 
  if err != nil { 
    fmt.Println("Error", err)
  } else { 
    fmt.Println("The element at the end  of the queue is ->", endElement)
  }



fmt.Println("Is the queue empty ? ", myPersonQueue.IsEmpty())
}

The terminal should print out:

The element at the front of the queue is -> {Bobby McFerrin 77}  
The element at the end of the queue is -> {Alice InChains 7}  
Is the queue empty ?  false