Add additional benchmarks for TypeID (#447)

## Summary
Adds some additional benchmarks to the existing ones we had in typeid.

## How was it tested?
Ran the benchmarks.

## Community Contribution License
All community contributions in this pull request are licensed to the
project maintainers
under the terms of the [Apache 2
license](https://www.apache.org/licenses/LICENSE-2.0).
By creating this pull request I represent that I have the right to
license the
contributions to the project maintainers under the Apache 2 license.


<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->

## Summary by CodeRabbit

- **Chores**
- Enhanced repository maintenance with refined ignore patterns and
updated dependency management for improved consistency.
- **Tests**
- Expanded performance benchmarks to assess encoding efficiency, memory
usage under various workloads, and parallel ID generation.

<!-- end of auto-generated comment: release notes by coderabbit.ai -->

Author: loreto

.gitignore

@@ -0,0 +1,23 @@
+# Benchmark results
+benchmark_results/
+
+# Go specific
+*.prof
+*.test
+*.out
+/vendor/
+
+# OS specific
+.DS_Store
+Thumbs.db
+
+# Editor files
+.idea/
+.vscode/
+*.swp
+*.swo
+*~
+
+# Build artifacts
+bin/
+dist/ 

bench_test.go

@@ -3,10 +3,13 @@ package typeid_test
 
 import (
 	"fmt"
+	"math/rand"
+	"runtime"
 	"testing"
 
 	"github.com/gofrs/uuid/v5"
 	"go.jetify.com/typeid"
+	"go.jetify.com/typeid/base32"
 )
 
 func BenchmarkNew(b *testing.B) {
@@ -28,6 +31,25 @@ func BenchmarkNew(b *testing.B) {
 			uuid.NewV7()
 		}
 	})
+	// Add benchmark for different prefix lengths
+	b.Run("prefix=short", func(b *testing.B) {
+		b.ReportAllocs()
+		for i := 0; i < b.N; i++ {
+			typeid.WithPrefix("s")
+		}
+	})
+	b.Run("prefix=medium", func(b *testing.B) {
+		b.ReportAllocs()
+		for i := 0; i < b.N; i++ {
+			typeid.WithPrefix("medium")
+		}
+	})
+	b.Run("prefix=long", func(b *testing.B) {
+		b.ReportAllocs()
+		for i := 0; i < b.N; i++ {
+			typeid.WithPrefix("thisislongprefix")
+		}
+	})
 }
 
 func BenchmarkString(b *testing.B) {
@@ -349,6 +371,226 @@ func BenchmarkEncodeDecode(b *testing.B) {
 	}
 }
 
+// Benchmark Base32 operations directly
+func BenchmarkBase32(b *testing.B) {
+	b.Run("encode", func(b *testing.B) {
+		uid := uuid.Must(uuid.NewV7())
+		var bytes [16]byte
+		copy(bytes[:], uid.Bytes())
+		b.ReportAllocs()
+		b.ResetTimer()
+		for i := 0; i < b.N; i++ {
+			_ = base32.Encode(bytes)
+		}
+	})
+	b.Run("decode", func(b *testing.B) {
+		uid := uuid.Must(uuid.NewV7())
+		var bytes [16]byte
+		copy(bytes[:], uid.Bytes())
+		encoded := base32.Encode(bytes)
+		b.ReportAllocs()
+		b.ResetTimer()
+		for i := 0; i < b.N; i++ {
+			_, _ = base32.Decode(encoded)
+		}
+	})
+}
+
+// Benchmark memory usage with different batch sizes
+func BenchmarkMemoryUsage(b *testing.B) {
+	benchSizes := []int{100, 1000, 10000}
+	for _, size := range benchSizes {
+		size := size // capture range variable
+		b.Run(fmt.Sprintf("size=%d", size), func(b *testing.B) {
+			// Pre-allocate a slice to avoid measuring slice growth
+			ids := make([]typeid.AnyID, size)
+			b.Cleanup(func() {
+				// Clear the slice to help GC
+				for i := range ids {
+					ids[i] = typeid.AnyID{}
+				}
+				ids = nil
+			})
+
+			b.ReportAllocs()
+			b.SetBytes(int64(size * 16)) // Each UUID is 16 bytes
+			b.ResetTimer()
+
+			for i := 0; i < b.N; i++ {
+				for j := range ids {
+					ids[j] = typeid.Must(typeid.WithPrefix("prefix"))
+				}
+				// Force memory pressure to ensure GC behavior is measured
+				runtime.GC()
+			}
+		})
+	}
+}
+
+// Benchmark validation
+func BenchmarkValidation(b *testing.B) {
+	validIDs := make([]string, 100)
+	invalidIDs := make([]string, 100)
+
+	for i := range validIDs {
+		validIDs[i] = typeid.Must(typeid.WithPrefix("prefix")).String()
+		if i < len(invalidIDs) {
+			// Create definitely invalid IDs by:
+			// 1. Using invalid prefix characters
+			// 2. Wrong separator
+			// 3. Invalid base32 characters
+			switch i % 3 {
+			case 0:
+				// Invalid prefix (contains number)
+				invalidIDs[i] = "prefix1_01h2xcejqtf2nbrexx3vqjhp41"
+			case 1:
+				// Wrong separator (using . instead of _)
+				invalidIDs[i] = "prefix.01h2xcejqtf2nbrexx3vqjhp41"
+			case 2:
+				// Invalid base32 character in suffix (using 'u' which isn't in the alphabet)
+				invalidIDs[i] = "prefix_u1h2xcejqtf2nbrexx3vqjhp41"
+			}
+		}
+	}
+
+	b.Run("valid", func(b *testing.B) {
+		b.ReportAllocs()
+		b.ResetTimer()
+
+		for i := 0; i < b.N; i++ {
+			// Test all valid IDs in each iteration
+			for _, id := range validIDs {
+				_, err := typeid.FromString(id)
+				if err != nil {
+					b.Fatalf("Expected valid ID to pass validation: %v", err)
+				}
+			}
+		}
+	})
+
+	b.Run("invalid", func(b *testing.B) {
+		b.ReportAllocs()
+		b.ResetTimer()
+
+		for i := 0; i < b.N; i++ {
+			// Test all invalid IDs in each iteration
+			for _, id := range invalidIDs {
+				_, err := typeid.FromString(id)
+				if err == nil {
+					b.Fatalf("Expected invalid ID to fail validation for ID: %s", id)
+				}
+			}
+		}
+	})
+}
+
+// Benchmark parallel ID generation
+func BenchmarkParallelGeneration(b *testing.B) {
+	benchCases := []struct {
+		name      string
+		procs     int
+		batchSize int
+	}{
+		{"procs=4_batch=100", 4, 100},
+		{"procs=8_batch=100", runtime.GOMAXPROCS(0) * 2, 100},
+		{"procs=4_batch=1000", 4, 1000},
+		{"procs=8_batch=1000", runtime.GOMAXPROCS(0) * 2, 1000},
+	}
+
+	for _, bc := range benchCases {
+		bc := bc // capture range variable
+		b.Run(bc.name, func(b *testing.B) {
+			// Pre-allocate a slice of prefixes for each processor
+			prefixes := make([]string, bc.procs)
+			for i := range prefixes {
+				// Use valid prefixes with only [a-z_]
+				prefixes[i] = fmt.Sprintf("prefix_%c", 'a'+i)
+			}
+
+			b.SetParallelism(bc.procs)
+			b.ReportAllocs()
+			b.ResetTimer()
+
+			b.RunParallel(func(pb *testing.PB) {
+				// Pre-allocate slice with capacity
+				ids := make([]typeid.AnyID, 0, bc.batchSize)
+				// Keep track of which prefix we're using
+				prefixIdx := 0
+
+				for pb.Next() {
+					// Clear the slice but keep capacity
+					ids = ids[:0]
+
+					// Use all prefixes in each iteration
+					for j := 0; j < bc.batchSize; j++ {
+						// Cycle through prefixes
+						prefix := prefixes[prefixIdx%len(prefixes)]
+						prefixIdx++
+						ids = append(ids, typeid.Must(typeid.WithPrefix(prefix)))
+					}
+				}
+			})
+		})
+	}
+}
+
+// Benchmark mixed operations to simulate real-world usage patterns
+func BenchmarkMixedOperations(b *testing.B) {
+	// Pre-generate all operations and test data
+	type op struct {
+		kind string
+		id   typeid.AnyID // For operations that need an existing ID
+	}
+
+	// Create a slice of operations in the ratio we want to test
+	numOps := 100 // Number of operations to pre-generate
+	ops := make([]op, numOps)
+	ids := make([]typeid.AnyID, numOps/2) // Pre-generate some IDs for operations that need them
+
+	for i := range ids {
+		ids[i] = typeid.Must(typeid.WithPrefix("prefix"))
+	}
+
+	// Initialize random number generator
+	src := rand.NewSource(1234)
+	rnd := rand.New(src)
+
+	// Generate operations in desired ratios
+	for i := range ops {
+		r := rnd.Float32()
+		switch {
+		case r < 0.1: // 10% new IDs
+			ops[i] = op{kind: "create"}
+		case r < 0.4: // 30% toString
+			ops[i] = op{kind: "toString", id: ids[rnd.Intn(len(ids))]}
+		case r < 0.7: // 30% parse
+			ops[i] = op{kind: "parse", id: ids[rnd.Intn(len(ids))]}
+		default: // 30% validate
+			ops[i] = op{kind: "validate", id: ids[rnd.Intn(len(ids))]}
+		}
+	}
+
+	b.ReportAllocs()
+	b.ResetTimer()
+
+	// Ensure we go through all operations at least once
+	for i := 0; i < b.N; i++ {
+		// Do all operations once per iteration
+		for _, op := range ops {
+			switch op.kind {
+			case "create":
+				_ = typeid.Must(typeid.WithPrefix("prefix"))
+			case "toString":
+				_ = op.id.String()
+			case "parse":
+				_, _ = typeid.FromString(op.id.String())
+			case "validate":
+				_, _ = typeid.FromString(op.id.String())
+			}
+		}
+	}
+}
+
 // TODO: define these in a shared file if we're gonna use in several tests.
 
 type TestPrefix struct{}