|
| template<typename IteratorTag , typename Iterable > |
| static void | rangeless::fn::impl::require_iterator_category_at_least (const Iterable &) |
| |
| template<typename G , typename T > |
| auto | rangeless::fn::impl::recycle (G &gen, T &value, pr_high) -> decltype(gen.recycle(value), void()) |
| |
| template<typename G , typename T > |
| void | rangeless::fn::impl::recycle (G &, T &, pr_low) |
| |
| template<typename NullaryInvokable > |
| impl::seq< impl::catch_end< NullaryInvokable > > | rangeless::fn::seq (NullaryInvokable gen_fn) |
| | Adapt a generator function as InputRange. More...
|
| |
| template<typename Iterable > |
| impl::seq< impl::refs_gen< Iterable > > | rangeless::fn::refs (Iterable &src) |
| | Adapt a reference to Iterable as seq yielding reference-wrappers. More...
|
| |
| template<typename T > |
| int | rangeless::fn::impl::compare (const T &a, const T &b) |
| |
| template<typename T > |
| impl::gt< T > | rangeless::fn::by::decreasing (T x) |
| | Wraps the passed value and exposes inverted operator<. More...
|
| |
| template<typename T > |
| impl::gt< const T & > | rangeless::fn::by::decreasing (std::reference_wrapper< T > x) |
| |
| template<typename F > |
| impl::comp< F > | rangeless::fn::by::make_comp (F key_fn) |
| | Make binary comparison predicate from a key-function. More...
|
| |
| template<typename Iterator > |
| constexpr view< Iterator > | rangeless::fn::from (Iterator it_beg, Iterator it_end) noexcept |
| | Create a range-view from a pair of iterators. More...
|
| |
| template<typename Iterator > |
| constexpr view< Iterator > | rangeless::fn::from (std::pair< Iterator, Iterator > p) noexcept |
| | To enable composability of APIs returning a pair of iterators, e.g. std::equal_range. More...
|
| |
| template<typename Iterable , typename Iterator = typename Iterable::iterator> |
| constexpr view< Iterator > | rangeless::fn::from (Iterable &src) noexcept |
| | Create a range-view for a container, or an iterable that has begin and end as free functions rather than methods. More...
|
| |
| template<typename Iterable , typename Iterator = typename Iterable::const_iterator> |
| constexpr view< Iterator > | rangeless::fn::from (const Iterable &src) noexcept |
| |
| template<typename Iterable , typename Iterator = typename Iterable::const_iterator> |
| constexpr view< Iterator > | rangeless::fn::cfrom (const Iterable &src) noexcept |
| |
| template<typename Gen , typename T = typename Gen::value_type> |
| any_seq_t< T > | rangeless::fn::make_typerased (impl::seq< Gen > seq) |
| | Type-erase a seq. More...
|
| |
| impl::to_vector | rangeless::fn::to_vector () |
| | Move elements of an Iterable to std::vector. More...
|
| |
| impl::to_seq | rangeless::fn::to_seq () |
| | Wrap an Iterable, taken by value, as seq yielding elements by-move. More...
|
| |
| template<typename Container > |
| impl::to< Container > | rangeless::fn::to (Container dest) |
| | e.g. auto set_of_ints = fn::seq(...) % ... % fn::to(std::set<int>{}); More...
|
| |
| impl::counts | rangeless::fn::counts () |
| | return map: value_type -> size_t More...
|
| |
| template<typename F > |
| impl::adapt< F > | rangeless::fn::adapt (F fn) |
| | Create a custom processing-stage function-object. More...
|
| |
| template<typename F > |
| impl::transform< F > | rangeless::fn::transform (F map_fn) |
| | Create a seq yielding results of applying the transform functions to input-elements. More...
|
| |
| template<typename Result , typename Op > |
| impl::foldl< Result, Op > | rangeless::fn::foldl (Result init, Op binary_op) |
| | Range-based version of c++20 (copy-free) std::accumulate More...
|
| |
| template<typename Op > |
| impl::foldl_d< Op > | rangeless::fn::foldl_d (Op binary_op) |
| | Fold-Left-with-Default: this version uses default-initialized value for init. More...
|
| |
| template<typename Op > |
| impl::foldl_1< Op > | rangeless::fn::foldl_1 (Op binary_op) |
| | Init-free version of foldl (first element is used as init); requires at least one element. More...
|
| |
| impl::sliding_window | rangeless::fn::sliding_window (size_t win_size) |
| |
| template<typename F > |
| impl::for_each< F > | rangeless::fn::for_each (F fn) |
| |
| template<typename F2 > |
| impl::for_each_adjacent< F2 > | rangeless::fn::for_each_adjacent (F2 fn2) |
| |
| template<typename P > |
| impl::take_while< P > | rangeless::fn::take_while (P pred) |
| | Yield elements until pred evaluates to false. More...
|
| |
| impl::take_while< impl::call_count_lt > | rangeless::fn::take_first (size_t n=1) |
| | Yield first n elements. More...
|
| |
| impl::take_last | rangeless::fn::take_last (size_t n=1) |
| | Yield last n elements. More...
|
| |
| template<typename P > |
| impl::drop_while< P > | rangeless::fn::drop_while (P pred) |
| | Drop elements until pred evaluates to false. More...
|
| |
| impl::drop_while< impl::call_count_lt > | rangeless::fn::drop_first (size_t n=1) |
| | Drop first n elements. More...
|
| |
| impl::drop_last | rangeless::fn::drop_last (size_t n=1) |
| | Drop last n elements. More...
|
| |
| template<typename P > |
| impl::where< P > | rangeless::fn::where (P pred) |
| | Filter elements. More...
|
| |
| template<typename SortedForwardRange , typename F > |
| impl::where< impl::in_sorted_by< SortedForwardRange, F > > | rangeless::fn::where_in_sorted_by (const SortedForwardRange &r, F key_fn) |
| |
| template<typename SortedForwardRange > |
| impl::where< impl::in_sorted_by< SortedForwardRange, by::identity > > | rangeless::fn::where_in_sorted (const SortedForwardRange &r) |
| | Intersect with a sorted range. More...
|
| |
| template<typename SortedForwardRange , typename F > |
| impl::where< impl::in_sorted_by< SortedForwardRange, F > > | rangeless::fn::where_not_in_sorted_by (const SortedForwardRange &r, F key_fn) |
| |
| template<typename SortedForwardRange > |
| impl::where< impl::in_sorted_by< SortedForwardRange, by::identity > > | rangeless::fn::where_not_in_sorted (const SortedForwardRange &r) |
| | Subtract a sorted range. More...
|
| |
| template<typename F > |
| impl::where_max_by< F > | rangeless::fn::where_max_by (F key_fn) |
| | Filter elements to those having maximum value of fn. More...
|
| |
| impl::where_max_by< by::identity > | rangeless::fn::where_max () |
| |
| template<typename F > |
| impl::where_max_by< F > | rangeless::fn::where_min_by (F key_fn) |
| |
| impl::where_max_by< by::identity > | rangeless::fn::where_min () |
| |
| template<typename Pred > |
| impl::exists_where< Pred > | rangeless::fn::exists_where (Pred p) |
| |
| template<typename F > |
| impl::group_all_by< F > | rangeless::fn::group_all_by (F key_fn) |
| | Similar to group_adjacent_by, but presorts the elements. More...
|
| |
| impl::group_all_by< by::identity > | rangeless::fn::group_all () |
| |
| template<typename F > |
| impl::group_adjacent_by< F > | rangeless::fn::group_adjacent_by (F key_fn) |
| | Group adjacent elements. More...
|
| |
| template<typename F > |
| impl::group_adjacent_as_subseqs_by< F > | rangeless::fn::group_adjacent_by (F key_fn, impl::to_seq) |
| | Group adjacent elements. More...
|
| |
| impl::group_adjacent_by< by::identity > | rangeless::fn::group_adjacent () |
| |
| impl::group_adjacent_as_subseqs_by< by::identity > | rangeless::fn::group_adjacent (impl::to_seq) |
| |
| template<typename BinaryPred > |
| impl::group_adjacent_by< fn::by::identity, BinaryPred > | rangeless::fn::group_adjacent_if (BinaryPred pred2) |
| | Group adjacent elements if binary predicate holds. More...
|
| |
| template<typename BinaryPred > |
| impl::group_adjacent_as_subseqs_by< fn::by::identity, BinaryPred > | rangeless::fn::group_adjacent_if (BinaryPred pred2, impl::to_seq) |
| | Group adjacent elements if binary predicate holds. More...
|
| |
| impl::group_adjacent_by< impl::chunker > | rangeless::fn::in_groups_of (size_t n) |
| | Group adjacent elements into chunks of specified size. More...
|
| |
| impl::reverse | rangeless::fn::reverse () |
| | Reverse the elements in the input container. More...
|
| |
| template<typename F > |
| impl::sort_by< F, impl::stable_sort_tag > | rangeless::fn::sort_by (F key_fn) |
| | stable-sort and return the input. More...
|
| |
| impl::sort_by< by::identity, impl::stable_sort_tag > | rangeless::fn::sort () |
| | sort_by with key_fn = by::identity More...
|
| |
| template<typename F > |
| impl::sort_by< F, impl::unstable_sort_tag > | rangeless::fn::unstable_sort_by (F key_fn) |
| |
| impl::sort_by< by::identity, impl::unstable_sort_tag > | rangeless::fn::unstable_sort () |
| |
| template<typename F > |
| impl::lazy_sort_by< F > | rangeless::fn::lazy_sort_by (F key_fn) |
| | Unstable lazy sort. More...
|
| |
| impl::lazy_sort_by< by::identity > | rangeless::fn::lazy_sort () |
| | lazy_sort_by with key_fn = by::identity More...
|
| |
| template<typename F > |
| impl::take_top_n_by< F > | rangeless::fn::take_top_n_by (size_t n, F key_fn) |
| | Return top-n elements, sorted by key_fn. More...
|
| |
| impl::take_top_n_by< by::identity > | rangeless::fn::take_top_n (size_t n) |
| | Return top-n elements, sorted by identity. More...
|
| |
| template<typename F > |
| impl::unique_adjacent_by< F > | rangeless::fn::unique_adjacent_by (F key_fn) |
| | Keep first element from every adjacently-equal run of elements. More...
|
| |
| impl::unique_adjacent_by< by::identity > | rangeless::fn::unique_adjacent () |
| |
| template<typename F > |
| impl::unique_all_by< F > | rangeless::fn::unique_all_by (F key_fn) |
| | Uniquefy elements globally, as-if unique_adjacent_by pre-sorted by same key. More...
|
| |
| impl::unique_all_by< by::identity > | rangeless::fn::unique_all () |
| |
| impl::concat | rangeless::fn::concat () |
| | Flatten the result of group_all_by or group_adjacent_by. More...
|
| |
| template<typename Iterable > |
| impl::append< Iterable > | rangeless::fn::append (Iterable next) |
| | Yield elements of next after elements of arg. More...
|
| |
| template<typename Iterable , typename BinaryFn > |
| impl::zip_with< Iterable, BinaryFn > | rangeless::fn::zip_with (Iterable second, BinaryFn fn) |
| | Yield pairs of elements, (up to end of the shorter range) More...
|
| |
| template<typename BinaryFn > |
| impl::zip_adjacent< BinaryFn > | rangeless::fn::zip_adjacent (BinaryFn fn) |
| | Yield invocations of fn over pairs of adjacent inputs. More...
|
| |
| template<typename Iterable , typename BinaryFn > |
| impl::cartesian_product_with< Iterable, BinaryFn > | rangeless::fn::cartesian_product_with (Iterable second, BinaryFn fn) |
| |
| template<typename Container , typename P > |
| auto | rangeless::fn::get_unique (Container &container, P &&pred) -> decltype(*container.begin()) |
| | Access unique element matching the predicate. More...
|
| |
| template<typename Container , typename P , typename Construct > |
| auto | rangeless::fn::set_unique (Container &container, P &&pred, Construct &&con) -> decltype(*container.begin()) |
| | Similar to get_unique, but end-insert an element if missing. More...
|
| |
| template<typename Container > |
| auto | rangeless::fn::first_or_default (const Container &c) -> typename Container::value_type |
| | e.g. const CConstRef<CSeq_align> aln = first_or_default( get_alns_annot(...)->Get() ); More...
|
| |
| template<typename Container , typename Pred > |
| auto | rangeless::fn::first_or_default (const Container &c, Pred &&pred) -> typename Container::value_type |
| |
| template<typename Container > |
| auto | rangeless::fn::last_or_default (const Container &c) -> typename Container::value_type |
| |
| template<typename Container , typename Pred > |
| auto | rangeless::fn::last_or_default (const Container &c, Pred &&pred) -> typename Container::value_type |
| |
| template<typename F > |
| impl::memoizer< F > | rangeless::fn::make_memoized (F fn) |
| | Memoizing wrapper for non-recursive non-mutable unary lambdas (not synchronized). More...
|
| |
| template<typename F > |
| impl::scope_guard< F > | rangeless::fn::make_scope_guard (F fn) |
| | Basic scope guard - execute some code in guard`s destructor. More...
|
| |
| template<typename Arg , typename F > |
| auto | rangeless::fn::operators::operator % (Arg &&arg, F &&fn) -> decltype(std::forward< F >(fn)(std::forward< Arg >(arg))) |
| | return std::forward<F>(fn)(std::forward<Arg>(arg)) More...
|
| |
| template<typename Arg , typename F > |
| auto | rangeless::fn::operators::operator %= (Arg &arg, F &&fn) -> decltype(void(std::forward< F >(fn)(std::move(arg)))) |
| | arg = fn::to(Arg{})(std::forward<F>(fn)(std::move(arg))); More...
|
| |
| template<class Container1 , class Container2 > |
| auto | rangeless::fn::operators::operator<<= (Container1 &cont1, Container2 &&cont2) -> decltype(void(cont1.insert(cont1.end(), std::move(*cont2.begin())))) |
| | End-insert elements of cont2 into cont1 by-move. More...
|
| |
| template<class Container1 , class Container2 > |
| auto | rangeless::fn::operators::operator<<= (Container1 &cont1, const Container2 &cont2) -> decltype(void(cont1.insert(cont1.end(), *cont2.begin()))) |
| |
| template<class Container1 , class Gen > |
| void | rangeless::fn::operators::operator<<= (Container1 &cont1, impl::seq< Gen > seq) |
| |
| template<class Container > |
| void | rangeless::fn::operators::operator<<= (Container &cont, typename Container::value_type el) |
| |
| auto | rangeless::tsv::from (std::istream &istr, char delim='\t', params params={}) -> fn::impl::seq< fn::impl::transform< tsv::split_on_delim >::gen< fn::impl::catch_end< tsv::get_next_line > > > |
| | Read tab-separated-values from stream. More...
|
| |
| impl::async_wr | rangeless::fn::to_async (size_t queue_size=16) |
| | Wrap generating seq in an async-task. More...
|
| |
| template<typename F > |
| impl::par_transform< F, impl::std_async > | rangeless::fn::transform_in_parallel (F map_fn) |
| | Parallelized version of fn::transform More...
|
| |
| template<typename F , typename Async > |
| impl::par_transform< F, Async > | rangeless::fn::transform_in_parallel (F map_fn, Async async) |
| | A version of transform_in_parallel that uses a user-provided Async (e.g. backed by a fancy work-stealing thread-pool implementation). More...
|
| |
1.8.15