Chapter 23 - Generics

Introduction to Generics in Programming

Generics are a powerful feature in modern programming languages that allow developers to write flexible and reusable code while maintaining strong type safety. They enable the creation of components, such as functions, classes, or data structures, that can operate on various types without specifying them explicitly. By avoiding redundant code and enforcing compile-time checks, generics make programs more robust, maintainable, and easier to scale.

In this article, we'll dive deep into the concept of generics, how they are implemented in popular programming languages, and various use cases for them. We’ll also explore type parameters, constraints, and real-world examples in Python, PHP, Go, C++, and Zig.

The Core Concept: Understanding Generics

Generics revolve around the concept of type abstraction. They allow developers to define algorithms or data structures that are independent of specific types. Instead of hardcoding the types, you use placeholders (type parameters) that get replaced with actual types at compile time or runtime, depending on the language.

For example, a function to find the maximum value in a list can use generics to handle lists of integers, floats, or even custom objects. Similarly, generic classes enable the creation of reusable container structures like stacks, queues, or linked lists.

Type Parameters

Type parameters are the placeholders for types in generics. They are commonly represented by single uppercase letters such as T, U, or K. These placeholders can be replaced with concrete types when the generic component is used.

Constraints

Constraints define the rules for the types that can be used with generics. For instance, a generic function might only work with types that implement certain interfaces or inherit from specific base classes. Constraints help maintain type safety while allowing flexibility.

Why Use Generics?

Code Reusability: Generics let you write a function or class once and use it with various types.
Type Safety: They catch type-related errors at compile time, reducing runtime failures.
Performance: Avoiding runtime type checks or conversions can lead to faster code execution.
Simplified Maintenance: Generic code is easier to update since you don’t need to duplicate logic for different types.

Generics in Python

Python doesn’t have built-in generics at the language level, but with the introduction of type hints in Python 3.5 and the typing module, generics are now supported for type annotations.

Example: Generic Functions in Python

from typing import TypeVar, List

T = TypeVar('T')  # Declare a generic type

def get_first_element(elements: List[T]) -> T:
    return elements[0]

# Usage
print(get_first_element([1, 2, 3]))       # Works with integers
print(get_first_element(["a", "b", "c"]))  # Works with strings

Example: Generic Classes in Python

from typing import Generic, TypeVar

T = TypeVar('T')

class Stack(Generic[T]):
    def __init__(self):
        self._items: List[T] = []

    def push(self, item: T):
        self._items.append(item)

    def pop(self) -> T:
        return self._items.pop()

# Usage
stack = Stack[int]()
stack.push(10)
stack.push(20)
print(stack.pop())

Generics in PHP

Generics in PHP were introduced in PHP 8.1 with enhanced support for type safety. They are commonly used with classes and functions through PHPDoc annotations.

Example: Generic Functions in PHP

/**
 * @template T
 * @param T[] $array
 * @return T
 */
function getFirstElement(array $array) {
    return $array[0];
}

// Usage
echo getFirstElement([1, 2, 3]);  // Outputs: 1
echo getFirstElement(["a", "b", "c"]);  // Outputs: a

Example: Generic Classes in PHP

/**
 * @template T
 */
class Stack {
    /** @var T[] */
    private array $items = [];

    /**
     * @param T $item
     */
    public function push($item): void {
        $this->items[] = $item;
    }

    /**
     * @return T
     */
    public function pop() {
        return array_pop($this->items);
    }
}

// Usage
$stack = new Stack();
$stack->push(10);
$stack->push(20);
echo $stack->pop();

Generics in Go

Go implements generics starting with Go 1.18. It uses type parameters to define generics for functions and structs.

Example: Generic Functions In Go

package main

import "fmt"

type T interface{}

func GetFirstElement[T any](elements []T) T {
    return elements[0]
}

func main() {
    fmt.Println(GetFirstElement([]int{1, 2, 3}))      // Outputs: 1
    fmt.Println(GetFirstElement([]string{"a", "b"})) // Outputs: a
}

Example: Generic Structs in Go

package main

import "fmt"

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

func (s *Stack[T]) Push(item T) {
    s.items = append(s.items, item)
}

func (s *Stack[T]) Pop() T {
    lastIndex := len(s.items) - 1
    item := s.items[lastIndex]
    s.items = s.items[:lastIndex]
    return item
}

func main() {
    stack := Stack[int]{}
    stack.Push(10)
    stack.Push(20)
    fmt.Println(stack.Pop())
}

Generics in C++

C++ provides support for generics through templates, allowing compile-time polymorphism.

Example: Generic Functions in C++

#include <iostream>
#include <vector>

template <typename T>
T getFirstElement(const std::vector<T>& elements) {
    return elements[0];
}

int main() {
    std::cout << getFirstElement(std::vector<int>{1, 2, 3}) << std::endl;  // Outputs: 1
    std::cout << getFirstElement(std::vector<std::string>{"a", "b"}) << std::endl;  // Outputs: a
    return 0;
}

Example: Generic Classes in C++

#include <iostream>
#include <vector>

template <typename T>
class Stack {
private:
    std::vector<T> items;

public:
    void push(T item) {
        items.push_back(item);
    }

    T pop() {
        T item = items.back();
        items.pop_back();
        return item;
    }
};

int main() {
    Stack<int> stack;
    stack.push(10);
    stack.push(20);
    std::cout << stack.pop() << std::endl;  // Outputs: 20
    return 0;
}

Generics in Zig

Zig uses comptime parameters to achieve generic behavior, allowing compile-time evaluation and specialization.

Example: Generic Functions in Zig

const std = @import("std");

fn getFirstElement(comptime T: type, elements: []const T) T {
    return elements[0];
}

pub fn main() !void {
    const ints = []const i32{1, 2, 3};
    std.debug.print("{d}\n", .{getFirstElement(i32, ints)});

    const strings = []const []const u8{"a", "b"};
    std.debug.print("{s}\n", .{getFirstElement([]const u8, strings)});
}

Example: Generic Structs in Zig

const std = @import("std");

const Stack = struct(comptime T: type) {
    items: []T,

    pub fn init(items: []T) Stack {
        return Stack{ .items = items };
    }

    pub fn pop(self: *Stack) T {
        const item = self.items[self.items.len - 1];
        self.items = self.items[0..self.items.len - 1];
        return item;
    }
};

pub fn main() !void {
    var stack = Stack(i32).init(&[_]i32{10, 20, 30});
    std.debug.print("{d}\n", .{stack.pop()});
}

Conclusion

Generics are a crucial tool for writing efficient, reusable, and type-safe code. While the implementation varies across programming languages, the core concept remains consistent. By leveraging generics, developers can create versatile algorithms and data structures that adapt seamlessly to different types. As we’ve seen, whether you’re coding in Python, PHP, Go, C++, or Zig, generics enhance the flexibility and maintainability of your codebase.

Last modified: 26 January 2025