quicksort [] = []
quicksort (x:xs) = quicksort small_elements ++ [x] ++ quicksort large_elements
   where small_elements = [y | y <- xs, y <= x]
         large_elements = [y | y <- xs, y >  x]

template <class RAI> // специфичную для C++ магию старался минимизировать
void quicksort(RAI first, RAI last)
{
    if(std::distance(first, last) <= 1)
    {
        return;
    }

    RAI pivot = first;

    typename std::iterator_traits<RAI>::value_type const pivot_value(*pivot);
    std::iter_swap(pivot, last - 1);
    RAI new_pivot = first;
    for(RAI it = first; it + 1 != last; ++it)
    {
        if(!(pivot_value < *it))
        {
            std::iter_swap(new_pivot, it);
            ++new_pivot;
        }
    }
    std::iter_swap(new_pivot, last - 1);

    quicksort(first, new_pivot);
    quicksort(new_pivot + 1, last);
}

-- Сумма     квадратов  первых n  нечетных чисел
-----------  ---------  --------  --------
foldl (+) 0 (map (^2)  (take n    [1, 3..]))

// А это как соответствует человеческому пониманию?
int s = 0;
for(int i = 0, x = 1; i < n; ++i, x += 2) // как бы не ошибиться на единицу
{
    s += x * x;
}
return s;

RO>quicksort [] = []
RO>quicksort (x:xs) = quicksort small_elements ++ [x] ++ quicksort large_elements
RO>   where small_elements = [y | y <- xs, y <= x]
RO>         large_elements = [y | y <- xs, y >  x]
RO>

RO>template <class RAI> // специфичную для C++ магию старался минимизировать
RO>void quicksort(RAI first, RAI last)
RO>{
..................
RO>

list list::sort() const
{
  if (empty()) return list();

  list small_elements, greater_elemets;
  for (size_t i=1; i<size(); ++i)
    if (items[i] >= items[0])
      greater_elemets += items[i];
    else
      smaller_elemets += items[i];

  return smaller_elemets.sort() + list(l[0]) + greater_elemets.sort();
}