Programowanie uogólnione

Programowanie uogólnione (rodzajowe, generyczne) – jeden z paradygmatów programowania, polegający na definiowaniu algorytmów i struktur danych na poziomie abstrakcyjnym (niezależnym od konkretnej reprezentacji danych), tak aby ten sam schemat rozwiązania mógł być stosowany do wielu różnych typów. W ujęciu praktycznym akcentuje się abstrahowanie od szczegółowych typów do wąskiego zestawu wymagań funkcjonalnych, dzięki czemu ten sam algorytm może działać na szerokiej klasie typów spełniających te wymagania.

Programowanie uogólnione umożliwia pisanie kodu (zwłaszcza w językach statycznie typowanych) w postaci uogólnionej, bez wiązania go z jednym, konkretnym typem danych na etapie definicji; typy są podstawiane w momencie użycia (instancjacji) mechanizmu uogólnień.

W ekosystemie C++ programowanie uogólnione jest często omawiane obok metaprogramowania szablonowego, ponieważ oba podejścia wykorzystują szablony jako mechanizm językowy, przy czym metaprogramowanie szablonowe obejmuje m.in. techniki obliczeń na etapie kompilacji i tworzenia nowych typów.

W wielu językach programowania istnieją mechanizmy wspierające uogólnienia, m.in.:

• w C++ – szablony (templates).
• w D – szablony (templates) opisane w specyfikacji języka.
• w Java – typy generyczne (generic classes/type parameters).
• w C# – typy generyczne oparte na parametrach typów (type parameters).
• w Haskell – polimorfizm parametryczny (parametric polymorphism) w systemie typów języka.
• w TypeScript – typy generyczne (generics) w systemie typów języka.

Przykłady

C++ (szablony)

template<typename To, typename From>
To convert(From f);

void g(double d)
{
    int  i = convert<int>(d);   // instancjacja: To=int, From=double
    char c = convert<char>(d);  // instancjacja: To=char, From=double
    int(*ptr)(float) = convert; // dedukcja argumentów szablonu
}

D (szablony)

T Square(T)(T t)
{
    return t * t;
}

void main()
{
    import std.stdio;
    writefln("%s", Square(3));        // T jest dedukowane jako int
    writefln("%s", Square!(int)(3));  // instancjacja jawna
}

Java (typy generyczne)

/** Generic version of the Box class. */
public class Box<T> {
    private T t;
    public void set(T t) { this.t = t; }
    public T get() { return t; }
}

Box<Integer> integerBox; // użycie typu parametryzowanego

C# (typy generyczne)

void SwapIfGreater<T>(ref T lhs, ref T rhs) where T : System.IComparable<T>
{
    T temp;
    if (lhs.CompareTo(rhs) > 0)
    {
        temp = lhs;
        lhs = rhs;
        rhs = temp;
    }
}

Haskell (polimorfizm parametryczny)

-- Typ a -> a oznacza typ uniwersalnie kwantyfikowany: ∀ a. a -> a
id' :: a -> a
id' x = x

TypeScript (generics)

function identity<Type>(arg: Type): Type {
  return arg;
}

Zobacz też

• szablon (C++)
• szablon (D)
• polimorfizm
• metaprogramowanie