let (+) left right = left#operator_plus right

list qsort() {
    if(!first || !first->next) return *this;
    pair<list, list> tmp = rest().split(less<int>(), first->value);
    return tmp.first.qsort() + first + tmp.second.qsort(); 
};

#include <iostream>
#include <functional>

using namespace std;

struct cell { 
    int value; 
    cell* next; 
    cell(int v, cell* n=NULL) :value(v), next(n) {}
};

struct list : std::pair<cell*, cell*>  {

    list() : pair<cell*,cell*>(NULL, NULL) {}

    list(cell* first, cell* last) 
        : pair<cell*, cell*>(first, last) {}

    list qsort() {
        if(!first || !first->next) return *this;
        pair<list, list> tmp = rest().split(less<int>(), first->value);
        return tmp.first.qsort() + first + tmp.second.qsort(); 
    };

    list rest() {
        if(first==second) return list();
        return list(first->next, second);
    }

    list operator+(const list& over) { 
        if(first==NULL) return over;
        if(over.first==NULL) return *this;
        second->next = over.first; return list(first, over.second);
    }

    list operator+(cell* c) {
        c->next = NULL;
        return operator+(list(c, c));
    }

    list operator+(int i) {
        return operator+(new cell(i));
    }

    list& operator +=(const list& over) {
        *this = *this + over;
    }

    list& operator +=(cell* c) {
        return *this = *this + c;
    }

    template<typename func>
    pair<list, list> split(func f, int value) {
        pair<list, list> res;
        while(first) {
            cell* next = first->next;
            if(f(first->value, value)) 
                res.first += first;
            else 
                res.second += first;
            first = next;
        }
        return res;
    };
};

template<typename Char>
std::basic_ostream<Char>& operator <<(std::basic_ostream<Char>& s, cell* c) { 
    if(c) s << c->value << ' ' << c->next; 
    return s;
}

template<typename Char>
std::basic_ostream<Char>& operator <<(std::basic_ostream<Char>& s, const list& l) { 
    s << l.first;
    return s;
}

int _tmain(int argc, _TCHAR* argv[])
{
    list l = list() + 10 + 1 + 5 + 2 + 7 + 11 + 4; 
    cout << l << endl;
    cout << l.qsort();
    return 0;
}

V>list qsort() {
V>    if(!first || !first->next) return *this;
V>    pair<list, list> tmp = rest().split(less<int>(), first->value);
V>    return tmp.first.qsort() + first + tmp.second.qsort(); 
V>};
V>

V>Красота... Не хуже OCalm-a.

    static List<T> QSort<T>(List<T> list) where T: IComparable<T>
    {
        if (list.Count <= 0)
            return list;
        List<T> gr = QSort(list.FindAll(delegate(T el) { return list[0].CompareTo(el) > 0; }));
        List<T> eq = list.FindAll(delegate(T el) { return list[0].CompareTo(el) == 0; });
        List<T> lt = QSort(list.FindAll(delegate(T el) { return list[0].CompareTo(el) < 0; }));
        gr.AddRange(eq); gr.AddRange(lt); return gr;
    }