transrangers namespace

Namespaces

namespace detail

Classes

template<typename Ranger, typename... Rangers>
class __lambda_244_25
template<typename type_parameter_1_0, typename Ranger, typename... Rangers>
class __lambda_246_16
template<typename Ranger, typename... Rangers>
class __lambda_249_18
template<std::size_t I, typename Ranger, typename... Rangers>
class __lambda_255_33
zip
struct all_adaption
template<typename Range>
struct all_copy
template<typename Cursor, typename F, typename = void>
struct deref_fun
template<typename Cursor, typename F>
struct deref_fun<Cursor, F, typename std::enable_if<std::is_trivially_default_constructible<F>::value && std::is_empty<F>::value>::type>
struct identity_adaption
template<typename Cursor, typename F>
struct ranger_class
template<typename Range>
struct skip_both_copy
template<typename Range>
struct skip_first_copy
template<typename Range>
struct skip_last_copy
template<typename... Rangers>
struct zip_cursor

Functions

template<typename Ranger>
auto input_view(Ranger rgr) -> auto
template<typename Ranger>
auto forward_view(Ranger rgr) -> auto
template<typename Cursor, typename F>
auto ranger(F f) -> auto
template<typename Range>
auto all(Range&& rng) -> auto
template<typename Range>
auto all(Range&& rng) -> std::enable_if<std::is_rvalue_reference<Range && >::value, all_copy<Range>>::type
template<typename Pred>
auto pred_box(Pred pred) -> auto
template<typename Pred, typename Ranger>
auto filter(Pred pred_, Ranger rgr) -> auto
template<typename F, typename Ranger>
auto transform(F f, Ranger rgr) -> auto
template<typename Ranger>
auto take(int n, Ranger rgr) -> auto
template<typename Ranger>
auto concat(Ranger rgr) -> auto
template<typename Ranger, typename... Rangers>
auto concat(Ranger rgr, Rangers... rgrs) -> auto
template<typename Ranger>
auto unique(Ranger rgr) -> auto
template<typename Ranger1, typename Ranger2>
auto zip2(Ranger1 rgr1, Ranger2 rgr2) -> auto
template<typename Ranger, typename T>
auto accumulate(Ranger rgr, T init) -> T
template<typename Range>
auto skip_first(Range&& rng) -> auto
skip_first, skip_first_copy (assume the next item is available)
template<typename Range>
auto skip_first(Range&& rng) -> std::enable_if<std::is_rvalue_reference<Range && >::value, skip_first_copy<Range>>::type
template<typename Range>
auto skip_last(Range&& rng) -> auto
skip_last, skip_last_copy (assume the previous item is available)
template<typename Range>
auto skip_last(Range&& rng) -> std::enable_if<std::is_rvalue_reference<Range && >::value, skip_last_copy<Range>>::type
template<typename Range>
auto skip_both(Range&& rng) -> auto
skip_both, skip_both_copy (assume the next and prev items are available)
template<typename Range>
auto skip_both(Range&& rng) -> std::enable_if<std::is_rvalue_reference<Range && >::value, skip_both_copy<Range>>::type
template<typename Ranger>
auto enumerate(Ranger rgr) -> auto
enumerate
template<typename Ranger, typename T>
auto partial_sum(Ranger rgr, T init) -> T
partial sum (cummutative sum)
template<typename Ranger, typename... Rangers>
auto zip(Ranger rgr, Rangers... rgrs) -> auto

Function documentation

#include <transranger_view.hpp>
template<typename Ranger>
auto transrangers::input_view(Ranger rgr)

#include <transranger_view.hpp>
template<typename Ranger>
auto transrangers::forward_view(Ranger rgr)

#include <transrangers.hpp>
template<typename Cursor, typename F>
auto transrangers::ranger(F f)

#include <transrangers.hpp>
template<typename Range>
auto transrangers::all(Range&& rng)

#include <transrangers.hpp>
template<typename Range>
std::enable_if<std::is_rvalue_reference<Range && >::value, all_copy<Range>>::type transrangers::all(Range&& rng)

#include <transrangers.hpp>
template<typename Pred>
auto transrangers::pred_box(Pred pred)

#include <transrangers.hpp>
template<typename Pred, typename Ranger>
auto transrangers::filter(Pred pred_, Ranger rgr)

#include <transrangers.hpp>
template<typename F, typename Ranger>
auto transrangers::transform(F f, Ranger rgr)

#include <transrangers.hpp>
template<typename Ranger>
auto transrangers::take(int n, Ranger rgr)

#include <transrangers.hpp>
template<typename Ranger>
auto transrangers::concat(Ranger rgr)

#include <transrangers.hpp>
template<typename Ranger, typename... Rangers>
auto transrangers::concat(Ranger rgr, Rangers... rgrs)

#include <transrangers.hpp>
template<typename Ranger>
auto transrangers::unique(Ranger rgr)

#include <transrangers.hpp>
template<typename Ranger1, typename Ranger2>
auto transrangers::zip2(Ranger1 rgr1, Ranger2 rgr2)

#include <transrangers.hpp>
template<typename Ranger, typename T>
T transrangers::accumulate(Ranger rgr, T init)

#include <transrangers_ext.hpp>
template<typename Range>
auto transrangers::skip_first(Range&& rng)

skip_first, skip_first_copy (assume the next item is available)

Template parameters
Range
Parameters
rng in
Returns auto

#include <transrangers_ext.hpp>
template<typename Range>
std::enable_if<std::is_rvalue_reference<Range && >::value, skip_first_copy<Range>>::type transrangers::skip_first(Range&& rng)

Template parameters
Range
Parameters
rng in
Returns std::enable_if<std::is_rvalue_reference<Range &&>::value, skip_first_copy<Range>>::type

#include <transrangers_ext.hpp>
template<typename Range>
auto transrangers::skip_last(Range&& rng)

skip_last, skip_last_copy (assume the previous item is available)

Template parameters
Range
Parameters
rng in
Returns auto

#include <transrangers_ext.hpp>
template<typename Range>
std::enable_if<std::is_rvalue_reference<Range && >::value, skip_last_copy<Range>>::type transrangers::skip_last(Range&& rng)

Template parameters
Range
Parameters
rng in
Returns std::enable_if<std::is_rvalue_reference<Range &&>::value, skip_last_copy<Range>>::type

#include <transrangers_ext.hpp>
template<typename Range>
auto transrangers::skip_both(Range&& rng)

skip_both, skip_both_copy (assume the next and prev items are available)

Template parameters
Range
Parameters
rng in
Returns auto

#include <transrangers_ext.hpp>
template<typename Range>
std::enable_if<std::is_rvalue_reference<Range && >::value, skip_both_copy<Range>>::type transrangers::skip_both(Range&& rng)

Template parameters
Range
Parameters
rng in
Returns std::enable_if<std::is_rvalue_reference<Range &&>::value, skip_both_copy<Range>>::type

#include <transrangers_ext.hpp>
template<typename Ranger>
auto transrangers::enumerate(Ranger rgr)

enumerate

Template parameters
Ranger
Parameters
rgr in
Returns auto

#include <transrangers_ext.hpp>
template<typename Ranger, typename T>
T transrangers::partial_sum(Ranger rgr, T init)

partial sum (cummutative sum)

Template parameters
Ranger
T
Parameters
rgr in
init in
Returns T

#include <transrangers_ext.hpp>
template<typename Ranger, typename... Rangers>
auto transrangers::zip(Ranger rgr, Rangers... rgrs)

Template parameters
Ranger
Rangers
Parameters
rgr in
rgrs in
Returns auto