Programowanie uogólnione 📖 Wikipedia

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^[1][2][3]. 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^[3][4.1][5].

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ń^[6].

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^[4.2][7].

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

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

C++ (szablony)^[13]

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)^[14]

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)^[15]

/** 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)^[16]

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)^[17]

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

TypeScript (generics)^[18]

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

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