chore: Update all files to v2.3.0 with Go as 5th implementation

- Update version numbers across all READMEs (C++, Go, Rust, Zig, TypeScript)
- Update Rust Cargo.toml and Cargo.lock to 2.3.0
- Update TypeScript package.json and source file @Version comments
- Regenerate TypeScript package-lock.json files
- Fix "four implementations" → "five implementations" in C++ header
- Add Go section to INSTALL.md with installation and usage examples
- Add Go column to cross-language method compatibility table
- Update version compatibility matrix with v2.3.0 row and Go column
- Add Go to building from source and error handling sections
- Update ROADMAP.md to mark v2.3.0 Go milestone as complete

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: PCfVW

Cpp/PriorityQueue.h

@@ -10,16 +10,29 @@
 ///
 /// This file is divided as follows:
 ///	- File History					(Line 19)
-/// - Inclusion of files			(Line 123)
-///	- Namespace declaration			(Line 136)
-///	- Class declaration				(Line 145)
+/// - Inclusion of files			(Line 143)
+///	- Namespace declaration			(Line 156)
+///	- Class declaration				(Line 165)
 ///
-///	- End of file					(line 415)
+///	- End of file					(line 435)
 ///
 /// =================================================================================================================== File history
 ///
-/// [Author, Created, Last Modification] = [Eric JACOPIN, 2023/07/29, 2025/12/25]
-/// Version: 2.2.0
+/// [Author, Created, Last Modification] = [Eric JACOPIN, 2023/07/29, 2025/12/27]
+/// Version: 2.3.0
+///
+/// [v2.3.0] Go Implementation Release -------------------------------------------------------------------------------- 2025/12/27
+///     - Added complete Go implementation with full API parity (fifth language)
+///     - Go generics support: PriorityQueue[T any, K comparable] with Comparator and KeyExtractor
+///     - Go Dijkstra example demonstrating d-heap usage in examples/dijkstra/Go/
+///     - Comparator utilities: MinBy(), MaxBy() factory functions and pre-built comparators
+///     - Bulk operations: InsertMany(), PopMany() with Floyd's O(n) heapify algorithm
+///     - Cross-language aliases: Snake_case method aliases (Is_empty(), Increase_priority(), etc.)
+///     - Go workspace configuration with go.work for multi-module development
+///     - 47 test cases covering all functionality in Go implementation
+///     - All five implementations now maintain synchronized version numbers and API parity
+///     - Updated Rust package name to `d-ary-heap` for clarity and consistency
+///     - Standardized Rust library name to `d_ary_heap` throughout the codebase
 ///
 /// [v2.2.0] Examples Infrastructure + TypeScript Dijkstra Release ---------------------------------------------------- 2025/12/26
 ///     - Added examples/dijkstra/ infrastructure with Network Flows textbook example (Figure 4.7, page 110)
@@ -53,7 +66,7 @@
 ///     - Added peek() alias and initCapacity() methods in Zig for API completeness
 ///     - All four implementations maintain synchronized version numbers and API parity
 ///
-/// [v1.1.0] Enhanced Release - Three-Language Implementation ---------------------------------------------------------- 2025/09/26
+/// [v1.1.0] Enhanced Release - Three-Language Implementation --------------------------------------------------------- 2025/09/26
 ///     - Complete Zig implementation added with full API parity
 ///     - All three languages (C++, Rust, Zig) now provide identical functionality
 ///     - Enhanced documentation with cross-language comparison and usage guides
@@ -66,7 +79,7 @@
 ///     - Cross-language API parity with Rust implementation
 ///     - Professional documentation with usage examples and design explanations
 ///
-/// [DEV 5] Cross-Language API Consistency --------------------------------------------------------------------------- 2025/09/25
+/// [DEV 5] Cross-Language API Consistency ---------------------------------------------------------------------------- 2025/09/25
 ///     - Cross-language API methods added for consistency across C++, Rust, Zig, and TypeScript:
 ///			- size() -> len() (unified across all languages)
 ///			- empty() -> is_empty() (C++/Rust snake_case, Zig/TypeScript camelCase as isEmpty())

Cpp/README.md

@@ -1,7 +1,7 @@
 ![C++17](https://img.shields.io/badge/C%2B%2B-17-blue.svg)
 ![License: Apache-2.0](https://img.shields.io/badge/License-Apache_2.0-green.svg)
 
-# d-Heap Priority Queue (C++17) v2.2.0
+# d-Heap Priority Queue (C++17) v2.3.0
 
 This is a generic d-ary heap priority queue supporting both min-queue and max-queue behavior through a comparator.
 

Go/README.md

@@ -293,4 +293,4 @@ cd Go && go test -bench=. ./src/...
 
 ## License
 
-Apache License 2.0 - See [LICENSE](../LICENSE) for details.
+Apache License 2.0 - See [LICENSE](https://github.com/PCfVW/d-Heap-priority-queue/blob/master/LICENSE) for details.

INSTALL.md

@@ -1,5 +1,64 @@
 # Installation Guide
 
+## Go Installation
+
+### Prerequisites
+- **Go 1.21+** (for generics support)
+
+### Install
+
+```bash
+go get github.com/PCfVW/d-Heap-priority-queue/Go/src@v2.3.0
+```
+
+### Usage
+
+```go
+package main
+
+import (
+    "fmt"
+    dheap "github.com/PCfVW/d-Heap-priority-queue/Go/src"
+)
+
+type Task struct {
+    ID       string
+    Priority int
+}
+
+func main() {
+    pq := dheap.New(dheap.Options[Task, string]{
+        D:            4,
+        Comparator:   dheap.MinBy(func(t Task) int { return t.Priority }),
+        KeyExtractor: func(t Task) string { return t.ID },
+    })
+
+    pq.Insert(Task{ID: "task1", Priority: 10})
+    pq.Insert(Task{ID: "task2", Priority: 5})
+
+    top, _ := pq.Front()
+    fmt.Printf("Top: %s\n", top.ID)  // task2
+}
+```
+
+### Cross-Language Compatibility
+
+Go provides both PascalCase (primary) and snake_case (compatibility) methods:
+
+```go
+// Primary Go style
+pq.IsEmpty()
+pq.IncreasePriority(item)
+pq.String()
+
+// Cross-language compatibility aliases
+pq.Is_empty()
+pq.Increase_priority(item)
+pq.To_string()
+```
+
+---
+
 ## TypeScript Installation
 
 ### Prerequisites
@@ -68,7 +127,7 @@ pq.to_string()
     .version = "0.1.0",
     .dependencies = .{
         .d_heap = .{
-            .url = "https://github.com/your-username/priority-queues/archive/refs/tags/v2.2.0.tar.gz",
+            .url = "https://github.com/PCfVW/priority-queues/archive/refs/tags/v2.3.0.tar.gz",
             .hash = "1220abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890",
         },
     },
@@ -136,7 +195,7 @@ pub fn main() !void {
 }
 ```
 
-### Cross-Language Compatibility (v2.2.0+)
+### Cross-Language Compatibility (v2.3.0+)
 
 Zig provides both camelCase (primary) and snake_case (compatibility) methods:
 
@@ -146,10 +205,9 @@ heap.isEmpty()
 heap.increasePriority(item)
 heap.toString()
 
-// Cross-language compatibility aliases  
+// Cross-language compatibility aliases
 heap.to_string()  // Available in v2.2.0+
 ```
-```
 
 ### Custom Item Types
 
@@ -235,10 +293,10 @@ int main() {
 ```toml
 [dependencies]
 # If published to crates.io (not recommended based on analysis)
-# rust_priority_queue = "2.2.0"
+# rust_priority_queue = "2.3.0"
 
 # Or use git dependency
-rust_priority_queue = { git = "https://github.com/your-username/priority-queues", tag = "v2.2.0" }
+rust_priority_queue = { git = "https://github.com/PCfVW/priority-queues", tag = "v2.3.0" }
 ```
 
 ### Usage
@@ -260,26 +318,36 @@ fn main() {
 
 Different languages follow their respective naming conventions:
 
-| Function | C++ | Rust | Zig | TypeScript |
-|----------|-----|------|-----|------------|
-| **Check Empty** | `is_empty()` | `is_empty()` | `isEmpty()` | `isEmpty()` |
-| **Increase Priority** | `increase_priority()` | `increase_priority()` | `increasePriority()` | `increasePriority()` |
-| **String Output** | `to_string()` | `to_string()` | `toString()` / `to_string()` | `toString()` / `to_string()` |
+| Function | C++ | Go | Rust | Zig | TypeScript |
+|----------|-----|-----|------|-----|------------|
+| **Check Empty** | `is_empty()` | `IsEmpty()` | `is_empty()` | `isEmpty()` | `isEmpty()` |
+| **Increase Priority** | `increase_priority()` | `IncreasePriority()` | `increase_priority()` | `increasePriority()` | `increasePriority()` |
+| **String Output** | `to_string()` | `String()` | `to_string()` | `toString()` / `to_string()` | `toString()` / `to_string()` |
 
-### Compatibility Features (v2.2.0+)
+### Compatibility Features (v2.3.0+)
+- **Go**: Provides snake_case aliases (`Is_empty()`, `To_string()`) for cross-language consistency
 - **Zig**: Added `to_string()` alias for cross-language consistency
 - **TypeScript**: Provides complete snake_case aliases for all camelCase methods
-- **Error Handling**: Each language uses idiomatic error handling (assertions, panics, error unions, exceptions)
+- **Error Handling**: Each language uses idiomatic error handling (assertions, panics, error unions, exceptions, ok booleans)
 
 ## Building from Source
 
 ### Clone the repository
 
 ```bash
-git clone https://github.com/your-username/priority-queues.git
+git clone https://github.com/PCfVW/priority-queues.git
 cd priority-queues
 ```
 
+### Go
+
+```bash
+cd Go
+go build ./...   # Build all packages
+go test ./...    # Run tests
+go run examples/dijkstra/Go/main.go  # Run Dijkstra example
+```
+
 ### Zig
 
 ```bash
@@ -342,17 +410,18 @@ error: hash mismatch: expected 1220abc..., found 1220def...
 Copy the "found" hash to your `build.zig.zon`.
 
 ### Zig Version Compatibility
-- **v2.2.0+**: Requires Zig 0.15.2+
-- **v2.0.0-v2.1.1**: Requires Zig 0.15.2+  
+- **v2.3.0+**: Requires Zig 0.15.2+
+- **v2.0.0-v2.2.0**: Requires Zig 0.15.2+
 - **v1.x**: For older Zig versions, use v1.1.0
 
 ### Version Compatibility Matrix
 
-| Package Version | Zig | C++ | Rust | TypeScript | Node.js |
-|----------------|-----|-----|------|------------|---------|
-| **v2.2.0** | 0.15.2+ | C++17+ | 2021+ | 5.0+ | 18+ |
-| **v2.1.1** | 0.15.2+ | C++17+ | 2021+ | 5.0+ | 18+ |
-| **v2.0.0** | 0.15.2+ | C++17+ | 2021+ | N/A | N/A |
+| Package Version | Go | Zig | C++ | Rust | TypeScript | Node.js |
+|----------------|-----|-----|-----|------|------------|---------|
+| **v2.3.0** | 1.21+ | 0.15.2+ | C++17+ | 2021+ | 5.0+ | 18+ |
+| **v2.2.0** | N/A | 0.15.2+ | C++17+ | 2021+ | 5.0+ | 18+ |
+| **v2.1.1** | N/A | 0.15.2+ | C++17+ | 2021+ | 5.0+ | 18+ |
+| **v2.0.0** | N/A | 0.15.2+ | C++17+ | 2021+ | N/A | N/A |
 
 ### Build Issues
 - Ensure you have the correct compiler versions (see compatibility matrix above)
@@ -365,6 +434,7 @@ Copy the "found" hash to your `build.zig.zon`.
 Each language handles errors idiomatically:
 
 - **C++**: Assertions (`assert()`) - check conditions before calling methods
+- **Go**: Ok booleans - use `Peek()` for safe access, errors returned as second value
 - **Rust**: Panics with messages - use `peek()` for safe access
 - **Zig**: Error unions (`!void`) - handle with `try` or explicit checking
 - **TypeScript**: Exceptions - use try-catch or `peek()` for safe access

ROADMAP.md

@@ -14,11 +14,31 @@ Each milestone follows a deliberate sequence:
 
 ## Current Status
 
-**v2.2.0** — Core implementations complete for C++, Rust, Zig, and TypeScript.
+**v2.3.0** — Core implementations complete for C++, Go, Rust, Zig, and TypeScript.
 
 ---
 
-## v2.2.0 — Examples Infrastructure + TypeScript Dijkstra
+## v2.3.0 — Go Implementation ✅
+
+> *Why Go? Why now?*
+
+Research revealed the only existing Go d-ary heap library lacks `decrease_priority` and O(1) item lookup—the very features that make d-ary heaps useful for graph algorithms.
+
+Adding Go after the TypeScript example (rather than before) means:
+- **The example pattern exists** — Dijkstra structure is already defined
+- **Architecture is validated** — `go.work` setup tested with a real use case
+- **Different audience reached** — Go developers ≠ TypeScript developers
+
+### Deliverables
+
+- [x] `Go/` — Full implementation with API parity
+- [x] `go.work` — Workspace configuration for local development
+- [x] `examples/dijkstra/Go/` — Dijkstra implementation
+- [ ] Published on [pkg.go.dev](https://pkg.go.dev)
+
+---
+
+## v2.2.0 — Examples Infrastructure + TypeScript Dijkstra ✅
 
 > *Why start here?*
 
@@ -39,26 +59,6 @@ Starting with TypeScript enables:
 
 ---
 
-## v2.3.0 — Go Implementation
-
-> *Why Go? Why now?*
-
-Research revealed the only existing Go d-ary heap library lacks `decrease_priority` and O(1) item lookup—the very features that make d-ary heaps useful for graph algorithms.
-
-Adding Go after the TypeScript example (rather than before) means:
-- **The example pattern exists** — Dijkstra structure is already defined
-- **Architecture is validated** — `go.work` setup tested with a real use case
-- **Different audience reached** — Go developers ≠ TypeScript developers
-
-### Deliverables
-
-- [ ] `Go/` — Full implementation with API parity
-- [ ] `go.work` — Workspace configuration for local development
-- [ ] `examples/dijkstra/Go/` — Dijkstra implementation
-- [ ] Published on [pkg.go.dev](https://pkg.go.dev)
-
----
-
 ## v2.4.0 — Complete Dijkstra Examples
 
 > *Why wait for the other languages?*

Rust/Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "d-ary-heap"
-version = "2.2.0"
+version = "2.3.0"
 edition = "2021"
 authors = ["Eric Jacopin"]
 license = "Apache-2.0"

Rust/Cargo.toml

@@ -3,7 +3,7 @@
 ![crates.io](https://img.shields.io/crates/v/d-ary-heap.svg)
 ![docs.rs](https://docs.rs/d-ary-heap/badge.svg)
 
-# d-ary Heap Priority Queue (Rust) v2.2.0
+# d-ary Heap Priority Queue (Rust) v2.3.0
 
 **Wikipedia-standard d-ary heap implementation** with O(1) item lookup and configurable arity.
 
@@ -25,7 +25,7 @@ Add to your `Cargo.toml`:
 
 ```toml
 [dependencies]
-d-ary-heap = "2.2.0"
+d-ary-heap = "2.3.0"
 ```
 
 ## Quick Start

Rust/README.md

@@ -1,7 +1,7 @@
 ![TypeScript](https://img.shields.io/badge/TypeScript-5.3-blue.svg)
 ![License: Apache-2.0](https://img.shields.io/badge/License-Apache_2.0-green.svg)
 
-# d-Heap Priority Queue (TypeScript) v2.2.0
+# d-Heap Priority Queue (TypeScript) v2.3.0
 
 A high-performance, generic d-ary heap priority queue with O(1) item lookup, supporting both min-heap and max-heap behavior.