Using brigand::sort with a roughly 100 element list on the VisualGDB IDE I get `cc1plus.exe: out of memory allocating 135167 bytes`

error. I understand that this is probably due to the fact that the provided GCC compiler can only access 2 GB or RAM for some reason. Despite the fact that this VisualGDB limitation is stupid there may also be some optimization potential in brigand. Using my cheap old insertion sort I used before discovering brigand (see below) I get to about 300 elements before I run out of memory.

Has there been any testing done to determine the current sort algorithm superior?

```
namespace Detail {
template<typename T_Out, template<typename, typename > class T_Pred,
typename T_Insert, bool B_Tag, typename ... Ts>
struct SortInsert;
//next is less than insert, next is not end
template<typename ... Os, template<typename, typename > class T_Pred,
typename T_Insert, typename T1, typename T2, typename ... Ts>
struct SortInsert<brigand::list<Os...>, T_Pred, T_Insert, true, T1, T2, Ts...> : SortInsert<
brigand::list<Os..., T1>, T_Pred, T_Insert, T_Pred<T2, T_Insert>::value, T2,
Ts...> {};
//next is less than insert, next is end, terminate
template<typename ... Os, template<typename, typename > class T_Pred,
typename T_Insert, typename ... Ts>
struct SortInsert<brigand::list<Os...>, T_Pred, T_Insert, true, Ts...> {
using type = brigand::list<Os..., Ts..., T_Insert>;
};
//next is not less than insert, terminate
template<typename ... Os, template<typename, typename > class T_Pred,
typename T_Insert, typename ... Ts>
struct SortInsert<brigand::list<Os...>, T_Pred, T_Insert, false, Ts...> {
using type = brigand::list<Os..., T_Insert, Ts...>;
};
template<typename TOut, template<typename, typename > class P, typename ... Ts>
struct Sort{
static_assert(AlwaysFalse<TOut>::value,"implausible parameters");
};
//out and in are not empty
template<typename O, typename ... Os,
template<typename, typename > class TPred, typename TInsert,
typename ... Ts>
struct Sort<brigand::list<O, Os...>, TPred, TInsert, Ts...> : Sort<
typename Detail::SortInsert<brigand::list<>, TPred, TInsert,
TPred<O, TInsert>::value, O, Os...>::type, TPred, Ts...>
{};
//out is empty, in is not empty
template<typename ... Os, template<typename, typename > class TPred,
typename TInsert, typename ... Ts>
struct Sort<brigand::list<Os...>, TPred, TInsert, Ts...> : Sort<
typename Detail::SortInsert<brigand::list<>, TPred, TInsert, false, Os...>::type,
TPred, Ts...>
{};
//in is empty
template<typename ... Os, template<typename, typename > class P, typename ... Ts>
struct Sort<brigand::list<Os...>, P, Ts...> {
using type = brigand::list<Os...>;
};
}
//Sort
template<typename TList, typename TPred = LessP>
struct Sort{
static_assert(AlwaysFalse<TList>::value,"implausible type");
};
//empty input case
template<template<typename, typename > class TPred>
struct Sort<brigand::list<>, Template<TPred>> {
using type = brigand::list<>;
};
//one element case
template<typename T, template<typename, typename > class TPred>
struct Sort<brigand::list<T>, Template<TPred>> {
using type = brigand::list<T>;
};
//two or more elements case
template<typename ... Ts, template<typename, typename > class TPred>
struct Sort<brigand::list<Ts...>, Template<TPred>> :
Detail::Sort<brigand::list<>, TPred, Ts...> {};
//alias
template<typename TList, typename TPred = LessP>
using SortT = typename Sort<TList,TPred>::type;
```