Составление адаптеров в Boost::range

Самая сложная проблема — выяснить тип возвращаемого значения в коде. decltype и лямбды плохо сочетаются (см. здесь), поэтому нам нужно подумать об альтернативе способ:

auto map = boost::adaptors::transformed;

namespace magic_transform
{
   std::function<int(int)> f1 = [](int x){ return 2*x; };
   std::function<int(int)> f2 = [](int x){ return x+1; };
   template <typename Range>
   auto run_pipeline(Range input) -> decltype(input | map(f1) | map(f1))
   {
        return input | map(f1) | map(f2);
   }
}

...
auto sink = magic_transform::run_pipeline(generate(1))
                          | map([](int x){ return 3*x; });

Простое решение — вставить лямбды в std::function, чтобы мы могли использовать decltype для вывода типа возвращаемого значения. Я использовал пространство имен magic_transform в примере, но вы можете адаптировать этот код в класс, если хотите. Вот ссылка, адаптирующая ваш код к приведенному выше.

Кроме того, использование std::function здесь может быть излишним. Вместо этого вы можете просто объявить две обычные функции (пример).

Я также экспериментировал с boost::any_range, похоже, есть некоторая несовместимость с лямбда-выражениями C+11 и т. д. Самое близкое, что я смог получить, было следующим (пример):

auto map = boost::adaptors::transformed;
using range = boost::any_range<
               const int,
               boost::forward_traversal_tag,
               const int&,
               std::ptrdiff_t
               >;

namespace magic_transform
{
    template <typename Range>
    range run_pipeline(Range r)
    {
        return r | map(std::function<int(int)>([](int x){ return 2*x; }))
             | map(std::function<int(int)>([](int x){ return x+1; }));
    }
}

int main(){
  auto sink = magic_transform::run_pipeline(boost::irange(0, 10))
                          | map([](int x){ return 3*x; });
  for(auto i : sink)
    std::cout << i << "\n";
}

думаю будет работать:

auto magic_transform()->decltype(boost::adaptors::transformed(std::function<int(int)>())
{
    std::function<int(int)> retval = [](int x){ return [](int x){ return x+1; }(2*x);
    return boost::adaptors::transformed(retval);
}

но это, вероятно, не то, что вы ищете. :) (Шутки в приведенном выше коде: связанные лямбды для 2 * x + 1, использование decltype в основном в реализации для поиска возвращаемого типа),

Глядя на исходный код для http://www.boost.org/doc/libs/1_46_1/boost/range/adaptor/transformed.hpp, тип, который magic_transform хочет вернуть, — это boost::range_detail::transform_holder<T>, где T — тип функции.

Когда вы делаете это в стеке с лямбда-выражениями, T оказывается очень узким типом. Если вы хотите обойти абстрактные преобразования, не раскрывая всех деталей, использование std::function<outtype(intype)> может быть разумным (будут небольшие накладные расходы во время выполнения).

Надеюсь, это сработает.