Cookbook

package main

import "fmt"

// Basic example - Filter slice with custom predicate
func Filter[T any](slice []T, predicate func(T) bool) []T {
	result := make([]T, 0, len(slice))
	for _, item := range slice {
		if predicate(item) {
			result = append(result, item)
		}
	}
	return result
}

func main() {
	numbers := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

	// Filter even numbers
	evens := Filter(numbers, func(n int) bool {
		return n%2 == 0
	})
	fmt.Println("Even numbers:", evens)
	// Output: Even numbers: [2 4 6 8 10]

	// Filter numbers greater than 5
	greaterThanFive := Filter(numbers, func(n int) bool {
		return n > 5
	})
	fmt.Println("Greater than 5:", greaterThanFive)
	// Output: Greater than 5: [6 7 8 9 10]
}

// Advanced example - Filter with multiple conditions and chaining
type Product struct {
	Name     string
	Price    float64
	InStock  bool
	Category string
}

func FilterProducts(products []Product, filters ...func(Product) bool) []Product {
	result := products
	for _, filter := range filters {
		result = Filter(result, filter)
	}
	return result
}

func main() {
	products := []Product{
		{"Laptop", 999.99, true, "Electronics"},
		{"Mouse", 25.00, false, "Electronics"},
		{"Desk", 299.99, true, "Furniture"},
		{"Chair", 149.99, true, "Furniture"},
		{"Keyboard", 75.00, true, "Electronics"},
	}

	// Multiple filter conditions
	inStockFilter := func(p Product) bool { return p.InStock }
	priceFilter := func(p Product) bool { return p.Price < 300 }
	categoryFilter := func(p Product) bool { return p.Category == "Electronics" }

	filtered := FilterProducts(products, inStockFilter, priceFilter, categoryFilter)
	for _, p := range filtered {
		fmt.Printf("%s - $%.2f\n", p.Name, p.Price)
	}
	// Output: Keyboard - $75.00
}

package main

import (
	"fmt"
	"strings"
)

// Basic example - Transform slice elements
func Map[T, R any](slice []T, transform func(T) R) []R {
	result := make([]R, len(slice))
	for i, item := range slice {
		result[i] = transform(item)
	}
	return result
}

func main() {
	numbers := []int{1, 2, 3, 4, 5}

	// Transform to squares
	squares := Map(numbers, func(n int) int {
		return n * n
	})
	fmt.Println("Squares:", squares)
	// Output: Squares: [1 4 9 16 25]

	names := []string{"alice", "bob", "charlie"}

	// Transform to uppercase
	upperNames := Map(names, func(s string) string {
		return strings.ToUpper(s)
	})
	fmt.Println("Uppercase:", upperNames)
	// Output: Uppercase: [ALICE BOB CHARLIE]
}

// Advanced example - Complex transformations with error handling
type User struct {
	ID    int
	Name  string
	Email string
}

type UserDTO struct {
	ID       int    `json:"id"`
	Username string `json:"username"`
}

func MapWithError[T, R any](slice []T, transform func(T) (R, error)) ([]R, error) {
	result := make([]R, len(slice))
	for i, item := range slice {
		r, err := transform(item)
		if err != nil {
			return nil, fmt.Errorf("transform failed at index %d: %w", i, err)
		}
		result[i] = r
	}
	return result, nil
}

func main() {
	users := []User{
		{1, "alice", "alice@example.com"},
		{2, "bob", "bob@example.com"},
		{3, "charlie", "charlie@example.com"},
	}

	// Transform User to UserDTO
	dtos := Map(users, func(u User) UserDTO {
		return UserDTO{
			ID:       u.ID,
			Username: u.Name,
		}
	})

	fmt.Printf("DTOs: %+v\n", dtos)
	// Output: DTOs: [{ID:1 Username:alice} {ID:2 Username:bob} {ID:3 Username:charlie}]

	// Map with extraction
	emails := Map(users, func(u User) string {
		return u.Email
	})
	fmt.Println("Emails:", emails)
	// Output: Emails: [alice@example.com bob@example.com charlie@example.com]
}

package main

import "fmt"

// Basic example - Group slice by key
func GroupBy[T any, K comparable](slice []T, keyFunc func(T) K) map[K][]T {
	result := make(map[K][]T)
	for _, item := range slice {
		key := keyFunc(item)
		result[key] = append(result[key], item)
	}
	return result
}

func main() {
	numbers := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

	// Group by even/odd
	grouped := GroupBy(numbers, func(n int) string {
		if n%2 == 0 {
			return "even"
		}
		return "odd"
	})

	fmt.Println("Even:", grouped["even"])
	fmt.Println("Odd:", grouped["odd"])
	// Output: Even: [2 4 6 8 10]
	// Output: Odd: [1 3 5 7 9]
}

// Advanced example - Group complex objects with counting
type Order struct {
	ID       int
	Customer string
	Amount   float64
	Status   string
}

type GroupStats struct {
	Count      int
	TotalAmount float64
	Items      []Order
}

func GroupByWithStats(orders []Order, keyFunc func(Order) string) map[string]GroupStats {
	result := make(map[string]GroupStats)
	for _, order := range orders {
		key := keyFunc(order)
		stats := result[key]
		stats.Count++
		stats.TotalAmount += order.Amount
		stats.Items = append(stats.Items, order)
		result[key] = stats
	}
	return result
}

func main() {
	orders := []Order{
		{1, "Alice", 100.00, "completed"},
		{2, "Bob", 50.00, "pending"},
		{3, "Alice", 75.00, "completed"},
		{4, "Charlie", 200.00, "completed"},
		{5, "Bob", 150.00, "completed"},
	}

	// Group by customer
	byCustomer := GroupBy(orders, func(o Order) string {
		return o.Customer
	})

	for customer, customerOrders := range byCustomer {
		fmt.Printf("%s: %d orders\n", customer, len(customerOrders))
	}
	// Output: Alice: 2 orders
	//         Bob: 2 orders
	//         Charlie: 1 orders

	// Group by status with statistics
	byStatus := GroupByWithStats(orders, func(o Order) string {
		return o.Status
	})

	for status, stats := range byStatus {
		fmt.Printf("%s: %d orders, total: $%.2f\n", status, stats.Count, stats.TotalAmount)
	}
	// Output: completed: 4 orders, total: $525.00
	//         pending: 1 orders, total: $50.00
}

package main

import (
	"fmt"
	"sort"
)

// Basic example - Sort slice with custom comparison
type Person struct {
	Name string
	Age  int
}

func main() {
	people := []Person{
		{"Alice", 30},
		{"Bob", 25},
		{"Charlie", 35},
		{"Diana", 28},
	}

	// Sort by age (ascending)
	sort.Slice(people, func(i, j int) bool {
		return people[i].Age < people[j].Age
	})

	fmt.Println("Sorted by age:")
	for _, p := range people {
		fmt.Printf("%s: %d\n", p.Name, p.Age)
	}
	// Output: Bob: 25
	//         Diana: 28
	//         Alice: 30
	//         Charlie: 35

	// Sort by name (ascending)
	sort.Slice(people, func(i, j int) bool {
		return people[i].Name < people[j].Name
	})

	fmt.Println("\nSorted by name:")
	for _, p := range people {
		fmt.Printf("%s: %d\n", p.Name, p.Age)
	}
	// Output: Alice: 30
	//         Bob: 25
	//         Charlie: 35
	//         Diana: 28
}

// Advanced example - Multi-field sorting with stable sort
type Product struct {
	Name     string
	Price    float64
	Rating   float64
	Category string
}

func main() {
	products := []Product{
		{"Laptop", 999.99, 4.5, "Electronics"},
		{"Mouse", 25.00, 4.2, "Electronics"},
		{"Desk", 299.99, 4.8, "Furniture"},
		{"Keyboard", 75.00, 4.5, "Electronics"},
		{"Chair", 149.99, 4.7, "Furniture"},
	}

	// Multi-level sort: category (asc), then price (desc)
	sort.SliceStable(products, func(i, j int) bool {
		if products[i].Category != products[j].Category {
			return products[i].Category < products[j].Category
		}
		return products[i].Price > products[j].Price // Descending price
	})

	fmt.Println("Sorted by category, then price (desc):")
	for _, p := range products {
		fmt.Printf("%-12s $%-7.2f %s\n", p.Name, p.Price, p.Category)
	}
	// Output: Laptop       $999.99  Electronics
	//         Keyboard     $75.00   Electronics
	//         Mouse        $25.00   Electronics
	//         Desk         $299.99  Furniture
	//         Chair        $149.99  Furniture

	// Sort by rating (descending), preserve order for ties
	sort.SliceStable(products, func(i, j int) bool {
		return products[i].Rating > products[j].Rating
	})

	fmt.Println("\nSorted by rating (desc):")
	for _, p := range products {
		fmt.Printf("%-12s %.1f ★\n", p.Name, p.Rating)
	}
	// Output: Desk         4.8 ★
	//         Chair        4.7 ★
	//         Laptop       4.5 ★
	//         Keyboard     4.5 ★
	//         Mouse        4.2 ★
}

package main

import "fmt"

// Basic example - Remove duplicates using map
func RemoveDuplicates[T comparable](slice []T) []T {
	seen := make(map[T]bool)
	result := make([]T, 0, len(slice))

	for _, item := range slice {
		if !seen[item] {
			seen[item] = true
			result = append(result, item)
		}
	}

	return result
}

func main() {
	numbers := []int{1, 2, 2, 3, 3, 3, 4, 5, 5}
	unique := RemoveDuplicates(numbers)
	fmt.Println("Unique numbers:", unique)
	// Output: Unique numbers: [1 2 3 4 5]

	words := []string{"apple", "banana", "apple", "cherry", "banana"}
	uniqueWords := RemoveDuplicates(words)
	fmt.Println("Unique words:", uniqueWords)
	// Output: Unique words: [apple banana cherry]
}

// Advanced example - Remove duplicates from complex objects
type User struct {
	ID    int
	Name  string
	Email string
}

func RemoveDuplicatesByKey[T any, K comparable](slice []T, keyFunc func(T) K) []T {
	seen := make(map[K]bool)
	result := make([]T, 0, len(slice))

	for _, item := range slice {
		key := keyFunc(item)
		if !seen[key] {
			seen[key] = true
			result = append(result, item)
		}
	}

	return result
}

func main() {
	users := []User{
		{1, "Alice", "alice@example.com"},
		{2, "Bob", "bob@example.com"},
		{3, "Alice", "alice2@example.com"}, // Duplicate name
		{4, "Charlie", "charlie@example.com"},
		{5, "Bob", "bob2@example.com"}, // Duplicate name
	}

	// Remove duplicates by name
	uniqueByName := RemoveDuplicatesByKey(users, func(u User) string {
		return u.Name
	})

	fmt.Println("Unique by name:")
	for _, u := range uniqueByName {
		fmt.Printf("%s (%s)\n", u.Name, u.Email)
	}
	// Output: Alice (alice@example.com)
	//         Bob (bob@example.com)
	//         Charlie (charlie@example.com)

	// Remove duplicates by email
	uniqueByEmail := RemoveDuplicatesByKey(users, func(u User) string {
		return u.Email
	})

	fmt.Println("\nUnique by email:")
	fmt.Printf("Count: %d users\n", len(uniqueByEmail))
	// Output: Count: 5 users
}

package main

import "fmt"

// Basic example - Find min and max with generics
type Ordered interface {
	~int | ~int8 | ~int16 | ~int32 | ~int64 |
		~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 |
		~float32 | ~float64 | ~string
}

func Min[T Ordered](slice []T) (T, bool) {
	if len(slice) == 0 {
		var zero T
		return zero, false
	}

	min := slice[0]
	for _, item := range slice[1:] {
		if item < min {
			min = item
		}
	}
	return min, true
}

func Max[T Ordered](slice []T) (T, bool) {
	if len(slice) == 0 {
		var zero T
		return zero, false
	}

	max := slice[0]
	for _, item := range slice[1:] {
		if item > max {
			max = item
		}
	}
	return max, true
}

func main() {
	numbers := []int{3, 1, 4, 1, 5, 9, 2, 6}

	min, _ := Min(numbers)
	max, _ := Max(numbers)

	fmt.Printf("Min: %d, Max: %d\n", min, max)
	// Output: Min: 1, Max: 9

	prices := []float64{99.99, 25.50, 149.99, 75.00}
	minPrice, _ := Min(prices)
	maxPrice, _ := Max(prices)

	fmt.Printf("Price range: $%.2f - $%.2f\n", minPrice, maxPrice)
	// Output: Price range: $25.50 - $149.99
}

// Advanced example - Find min/max by custom comparison
type Product struct {
	Name  string
	Price float64
	Stock int
}

func MinBy[T any](slice []T, less func(T, T) bool) (T, bool) {
	if len(slice) == 0 {
		var zero T
		return zero, false
	}

	min := slice[0]
	for _, item := range slice[1:] {
		if less(item, min) {
			min = item
		}
	}
	return min, true
}

func MaxBy[T any](slice []T, less func(T, T) bool) (T, bool) {
	if len(slice) == 0 {
		var zero T
		return zero, false
	}

	max := slice[0]
	for _, item := range slice[1:] {
		if less(max, item) {
			max = item
		}
	}
	return max, true
}

func main() {
	products := []Product{
		{"Laptop", 999.99, 10},
		{"Mouse", 25.00, 50},
		{"Keyboard", 75.00, 30},
		{"Monitor", 299.99, 15},
	}

	// Find cheapest product
	cheapest, _ := MinBy(products, func(a, b Product) bool {
		return a.Price < b.Price
	})
	fmt.Printf("Cheapest: %s ($%.2f)\n", cheapest.Name, cheapest.Price)
	// Output: Cheapest: Mouse ($25.00)

	// Find most expensive product
	expensive, _ := MaxBy(products, func(a, b Product) bool {
		return a.Price < b.Price
	})
	fmt.Printf("Most expensive: %s ($%.2f)\n", expensive.Name, expensive.Price)
	// Output: Most expensive: Laptop ($999.99)

	// Find product with highest stock
	highestStock, _ := MaxBy(products, func(a, b Product) bool {
		return a.Stock < b.Stock
	})
	fmt.Printf("Highest stock: %s (%d units)\n", highestStock.Name, highestStock.Stock)
	// Output: Highest stock: Mouse (50 units)
}

package main

import (
	"fmt"
	"strings"
)

// Basic example - Split and join operations
func main() {
	// Split string by delimiter
	csv := "apple,banana,cherry,date"
	fruits := strings.Split(csv, ",")
	fmt.Println("Fruits:", fruits)
	// Output: Fruits: [apple banana cherry date]

	// Join slice into string
	joined := strings.Join(fruits, " | ")
	fmt.Println("Joined:", joined)
	// Output: Joined: apple | banana | cherry | date

	// Split by whitespace
	sentence := "  hello   world  go  "
	words := strings.Fields(sentence) // Removes extra whitespace
	fmt.Println("Words:", words)
	// Output: Words: [hello world go]

	// Split with limit
	path := "user/docs/project/file.txt"
	parts := strings.SplitN(path, "/", 2) // Split into 2 parts max
	fmt.Println("Parts:", parts)
	// Output: Parts: [user docs/project/file.txt]
}

// Advanced example - Complex splitting and parsing
import (
	"fmt"
	"strings"
)

func main() {
	// Parse CSV with quotes (simple parser)
	csvLine := `"John Doe","30","New York, NY"`

	// Split by comma, but handle quoted values
	fields := strings.Split(csvLine, ",")
	for i, field := range fields {
		// Remove quotes
		fields[i] = strings.Trim(field, `"`)
	}
	fmt.Printf("Name: %s, Age: %s, City: %s\n", fields[0], fields[1], fields[2])
	// Output: Name: John Doe, Age: 30, City: New York, NY

	// Split by multiple delimiters
	text := "apple;banana,cherry|date"
	replacer := strings.NewReplacer(";", ",", "|", ",")
	normalized := replacer.Replace(text)
	items := strings.Split(normalized, ",")
	fmt.Println("Items:", items)
	// Output: Items: [apple banana cherry date]

	// Build path safely
	pathParts := []string{"users", "john", "documents", "file.txt"}
	fullPath := strings.Join(pathParts, "/")
	fmt.Println("Path:", fullPath)
	// Output: Path: users/john/documents/file.txt

	// Split lines preserving empty lines
	multiline := "line1\n\nline3\nline4"
	lines := strings.Split(multiline, "\n")
	fmt.Printf("Lines: %v (count: %d)\n", lines, len(lines))
	// Output: Lines: [line1  line3 line4] (count: 4)
}

package main

import "fmt"

// Basic example - String formatting with fmt
func main() {
	name := "Alice"
	age := 30
	balance := 1234.56

	// Basic string interpolation
	message := fmt.Sprintf("Hello, %s! You are %d years old.", name, age)
	fmt.Println(message)
	// Output: Hello, Alice! You are 30 years old.

	// Number formatting
	fmt.Printf("Balance: $%.2f\n", balance)
	// Output: Balance: $1234.56

	// Multiple values
	fmt.Printf("Name: %s, Age: %d, Balance: $%.2f\n", name, age, balance)
	// Output: Name: Alice, Age: 30, Balance: $1234.56

	// Width and alignment
	fmt.Printf("%-10s: %5d\n", "Alice", 30)    // Left-align name, right-align number
	fmt.Printf("%-10s: %5d\n", "Bob", 25)
	// Output: Alice     :    30
	//         Bob       :    25
}

// Advanced example - Complex formatting scenarios
import (
	"fmt"
	"strings"
)

type User struct {
	ID       int
	Username string
	Email    string
	IsActive bool
}

func main() {
	user := User{
		ID:       123,
		Username: "alice",
		Email:    "alice@example.com",
		IsActive: true,
	}

	// Format struct with different verbs
	fmt.Printf("User: %+v\n", user) // Include field names
	// Output: User: {ID:123 Username:alice Email:alice@example.com IsActive:true}

	fmt.Printf("User: %#v\n", user) // Go-syntax representation
	// Output: User: main.User{ID:123, Username:"alice", Email:"alice@example.com", IsActive:true}

	// Build formatted table
	headers := []string{"ID", "Username", "Email", "Status"}
	row1 := []interface{}{123, "alice", "alice@example.com", "active"}
	row2 := []interface{}{456, "bob", "bob@example.com", "inactive"}

	fmt.Printf("%-5s | %-10s | %-20s | %-8s\n", headers[0], headers[1], headers[2], headers[3])
	fmt.Println(strings.Repeat("-", 50))
	fmt.Printf("%-5d | %-10s | %-20s | %-8s\n", row1[0], row1[1], row1[2], row1[3])
	fmt.Printf("%-5d | %-10s | %-20s | %-8s\n", row2[0], row2[1], row2[2], row2[3])
	// Output: ID    | Username   | Email                | Status
	//         --------------------------------------------------
	//         123   | alice      | alice@example.com    | active
	//         456   | bob        | bob@example.com      | inactive

	// Format boolean as custom text
	status := "inactive"
	if user.IsActive {
		status = "active"
	}
	fmt.Printf("Account status: %s\n", status)
	// Output: Account status: active

	// Hexadecimal and binary formatting
	num := 255
	fmt.Printf("Decimal: %d, Hex: %x, Hex (uppercase): %X, Binary: %b\n", num, num, num, num)
	// Output: Decimal: 255, Hex: ff, Hex (uppercase): FF, Binary: 11111111
}

package main

import (
	"fmt"
	"strings"
)

// Basic example - Replace operations
func main() {
	text := "Hello World, Hello Go!"

	// Replace all occurrences
	replaced := strings.ReplaceAll(text, "Hello", "Hi")
	fmt.Println(replaced)
	// Output: Hi World, Hi Go!

	// Replace limited occurrences
	limited := strings.Replace(text, "Hello", "Hi", 1) // Replace first occurrence only
	fmt.Println(limited)
	// Output: Hi World, Hello Go!

	// Case-insensitive check
	contains := strings.Contains(strings.ToLower(text), "world")
	fmt.Printf("Contains 'world': %v\n", contains)
	// Output: Contains 'world': true

	// Multiple replacements
	html := "Hello <b>World</b>!"
	replacer := strings.NewReplacer("<b>", "**", "</b>", "**")
	markdown := replacer.Replace(html)
	fmt.Println(markdown)
	// Output: Hello **World**!
}

// Advanced example - Complex replacement scenarios
import (
	"fmt"
	"strings"
)

func main() {
	// Clean user input (remove sensitive data)
	logMessage := "User login failed: username=admin, password=secret123, ip=192.168.1.1"

	// Replace sensitive fields
	sanitizer := strings.NewReplacer(
		"password=secret123", "password=***",
		"192.168.1.1", "xxx.xxx.xxx.xxx",
	)
	sanitized := sanitizer.Replace(logMessage)
	fmt.Println("Sanitized:", sanitized)
	// Output: Sanitized: User login failed: username=admin, password=***, ip=xxx.xxx.xxx.xxx

	// Template replacement (simple)
	template := "Hello, {{name}}! Your balance is ${{balance}}."
	result := template
	result = strings.ReplaceAll(result, "{{name}}", "Alice")
	result = strings.ReplaceAll(result, "{{balance}}", "1234.56")
	fmt.Println(result)
	// Output: Hello, Alice! Your balance is $1234.56.

	// Normalize whitespace
	messyText := "Hello    World\n\n\nGo    Language  "
	normalized := strings.Join(strings.Fields(messyText), " ")
	fmt.Println("Normalized:", normalized)
	// Output: Normalized: Hello World Go Language

	// Chain replacements for cleanup
	dirty := "  Hello   World!!!  "
	clean := strings.TrimSpace(dirty)
	clean = strings.ReplaceAll(clean, "!!!", "!")
	clean = strings.Join(strings.Fields(clean), " ")
	fmt.Println("Clean:", clean)
	// Output: Clean: Hello World!

	// Bulk string transformations
	oldTerms := []string{"color", "flavor", "center"}
	newTerms := []string{"colour", "flavour", "centre"}
	britishText := "I like the color and flavor of this center piece."

	for i := range oldTerms {
		britishText = strings.ReplaceAll(britishText, oldTerms[i], newTerms[i])
	}
	fmt.Println("British:", britishText)
	// Output: British: I like the colour and flavour of this centre piece.
}

package main

import (
	"fmt"
	"regexp"
)

// Basic example - Pattern matching with regex
func main() {
	// Email validation pattern
	emailPattern := `^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$`
	emailRegex := regexp.MustCompile(emailPattern)

	// Test emails
	emails := []string{
		"alice@example.com",
		"invalid.email",
		"bob.smith+tag@company.co.uk",
	}

	for _, email := range emails {
		if emailRegex.MatchString(email) {
			fmt.Printf("✓ %s is valid\n", email)
		} else {
			fmt.Printf("✗ %s is invalid\n", email)
		}
	}
	// Output: ✓ alice@example.com is valid
	//         ✗ invalid.email is invalid
	//         ✓ bob.smith+tag@company.co.uk is valid

	// Extract matches
	text := "Contact us at support@example.com or sales@example.com"
	matches := emailRegex.FindAllString(text, -1)
	fmt.Println("Found emails:", matches)
	// Output: Found emails: [support@example.com sales@example.com]
}