What are the existing general-purpose programming tools?

In Golang, the following generic programming tools exist:

1. Parameterized types: Allow creating structures, interfaces, and functions that can work with different data types without specifying them at compile time. Data types are indicated in square brackets after the type or function name.

   // Example of a structure with a parameterized type
   type Stack[T any] struct {
   	elements []T
   }
   
   // Example of a function with parameterized types
   func Map[T, U any](collection []T, f func(T) U) []U {
   	result := make([]U, len(collection))
   	for i, item := range collection {
   		result[i] = f(item)
   	}
   	return result
   }
   

2. Type constraints: Define a set of types that can be used as parameters for generics. They allow restricting the universality of types and ensuring operation safety.

   • Interfaces: Any interface by itself is a type constraint.
   • Union interfaces: Allow combining multiple types or interfaces using the | operator.

   // Example of a type constraint using a union interface
   type Number interface {
   	int | int8 | int16 | int32 | int64 |
   	uint | uint8 | uint16 | uint32 | uint64 | uintptr |
   	float32 | float64 |
   	complex64 | complex128
   }
   
   // Function using the type constraint
   func Add[T Number](a, b T) T {
   	return a + b
   }
   

These tools were added in Go 1.18. Before that, to implement similar generics, interfaces (interface{}) and reflection were used, which led to reduced type safety and performance.