Transformation algorithms More...
Topics | |
lazy | |
Typedefs | |
template<list_like L, typename State , invocable Fn> | |
using | meta::accumulate = fold<L, State, Fn> |
An alias for meta::fold . | |
template<list_like ListOfLists> | |
using | meta::cartesian_product |
Given a list of lists ListOfLists , return a new list of lists that is the Cartesian Product. Like the sequence function from the Haskell Prelude. | |
template<list_like ... Ls> | |
using | meta::concat_ = _t<detail::concat_<Ls...>> |
Concatenates several lists into a single list. | |
template<list_like L, integral N> | |
using | meta::drop = drop_c<L, N::type::value> |
Return a new meta::list by removing the first N elements from L . | |
template<list_like L, std::size_t N> | |
using | meta::drop_c = _t<detail::drop_<L, N>> |
Return a new meta::list by removing the first N elements from L . | |
template<typename L , typename Pred > | |
using | meta::filter = join<transform<L, detail::filter_<Pred>>> |
Returns a new meta::list where only those elements of L that satisfy the Callable Pred such that invoke<Pred,A>::value is true are present. That is, those elements that don't satisfy the Pred are "removed". | |
template<list_like L, typename State , invocable Fn> | |
using | meta::fold = _t<detail::fold_<L, State, Fn>> |
Return a new meta::list constructed by doing a left fold of the list L using binary invocable Fn and initial state State . That is, the State(N) for the list element A(N) is computed by Fn(State(N-1), A(N)) -> State(N) . | |
template<list_like ListOfLists> | |
using | meta::join = apply<quote<concat>, ListOfLists> |
Joins a list of lists into a single list. | |
template<list_like L, invocable Fn> | |
using | meta::partition = fold<L, pair<list<>, list<>>, detail::partition_<Fn>> |
Returns a pair of lists, where the elements of L that satisfy the invocable Fn such that invoke<Fn,A>::value is true are present in the first list and the rest are in the second. | |
template<list_like L> | |
using | meta::pop_front = _t<detail::pop_front_<L>> |
Return a new meta::list by removing the first element from the front of L . | |
template<list_like L, typename... Ts> | |
using | meta::push_back = apply<bind_back<quote<list>, Ts...>, L> |
Return a new meta::list by adding the element T to the back of L . | |
template<list_like L, typename... Ts> | |
using | meta::push_front = apply<bind_front<quote<list>, Ts...>, L> |
Return a new meta::list by adding the element T to the front of L . | |
template<list_like L, typename T , typename U > | |
using | meta::replace = _t<detail::replace_<L, T, U>> |
Return a new meta::list where all instances of type T have been replaced with U . | |
template<list_like L, typename C , typename U > | |
using | meta::replace_if = _t<detail::replace_if_<L, C, U>> |
Return a new meta::list where all elements A of the list L for which invoke<C,A>::value is true have been replaced with U . | |
template<list_like L> | |
using | meta::reverse = _t<detail::reverse_<L>> |
Return a new meta::list by reversing the elements in the list L . | |
template<list_like L, typename State , invocable Fn> | |
using | meta::reverse_fold = _t<detail::reverse_fold_<L, State, Fn>> |
Return a new meta::list constructed by doing a right fold of the list L using binary invocable Fn and initial state State . That is, the State(N) for the list element A(N) is computed by Fn(A(N), State(N+1)) -> State(N) . | |
template<list_like L, invocable Fn> | |
using | meta::sort = _t<detail::sort_<L, Fn>> |
Return a new meta::list that is sorted according to invocable predicate Fn . | |
template<typename... Args> | |
using | meta::transform = _t<detail::transform_<Args...>> |
Return a new meta::list constructed by transforming all the elements in L with the unary invocable Fn . transform can also be called with two lists of the same length and a binary invocable, in which case it returns a new list constructed with the results of calling Fn with each element in the lists, pairwise. | |
template<list_like ListOfLists> | |
using | meta::transpose |
Given a list of lists of types ListOfLists , transpose the elements from the lists. | |
template<list_like L> | |
using | meta::unique = fold<L, list<>, quote_trait<detail::insert_back_>> |
Return a new meta::list where all duplicate elements have been removed. | |
template<list_like ListOfLists> | |
using | meta::zip = transpose<ListOfLists> |
Given a list of lists of types ListOfLists , construct a new list by grouping the elements from the lists pairwise into meta::list s. | |
template<invocable Fn, list_like ListOfLists> | |
using | meta::zip_with = transform<transpose<ListOfLists>, uncurry<Fn>> |
Given a list of lists of types ListOfLists and an invocable Fn , construct a new list by calling Fn with the elements from the lists pairwise. | |
Transformation algorithms
using meta::accumulate = fold<L, State, Fn> |
using meta::cartesian_product |
#include <meta/meta.hpp>
Given a list of lists ListOfLists
, return a new list of lists that is the Cartesian Product. Like the sequence
function from the Haskell Prelude.
O(N * M)
, where N
is the size of the outer list, and M
is the size of the inner lists. using meta::concat_ = _t<detail::concat_<Ls...>> |
#include <meta/meta.hpp>
Concatenates several lists into a single list.
meta::list
. O(L)
where L
is the number of lists in the list of lists.
|
related |
#include <meta/meta.hpp>
Return a new meta::list
by removing the first N
elements from L
.
O(1)
. using meta::drop_c = _t<detail::drop_<L, N>> |
#include <meta/meta.hpp>
Return a new meta::list
by removing the first N
elements from L
.
O(1)
.
|
related |
#include <meta/meta.hpp>
Returns a new meta::list where only those elements of L
that satisfy the Callable Pred
such that invoke<Pred,A>::value
is true
are present. That is, those elements that don't satisfy the Pred
are "removed".
O(N)
. using meta::fold = _t<detail::fold_<L, State, Fn>> |
#include <meta/meta.hpp>
Return a new meta::list
constructed by doing a left fold of the list L
using binary invocable Fn
and initial state State
. That is, the State(N)
for the list element A(N)
is computed by Fn(State(N-1), A(N)) -> State(N)
.
O(N)
.
|
related |
#include <meta/meta.hpp>
Joins a list of lists into a single list.
meta::list<T
...> where each T
is itself an instantiation of meta::list
. O(L)
where L
is the number of lists in the list of lists. using meta::partition = fold<L, pair<list<>, list<>>, detail::partition_<Fn>> |
#include <meta/meta.hpp>
Returns a pair of lists, where the elements of L
that satisfy the invocable Fn
such that invoke<Fn,A>::value
is true
are present in the first list and the rest are in the second.
O(N)
. using meta::pop_front = _t<detail::pop_front_<L>> |
#include <meta/meta.hpp>
Return a new meta::list
by removing the first element from the front of L
.
O(1)
. using meta::push_back = apply<bind_back<quote<list>, Ts...>, L> |
#include <meta/meta.hpp>
Return a new meta::list
by adding the element T
to the back of L
.
O(1)
. pop_back
not provided because it cannot be made to meet the complexity guarantees one would expect. using meta::push_front = apply<bind_front<quote<list>, Ts...>, L> |
#include <meta/meta.hpp>
Return a new meta::list
by adding the element T
to the front of L
.
O(1)
.
|
related |
#include <meta/meta.hpp>
Return a new meta::list
where all instances of type T
have been replaced with U
.
O(N)
.
|
related |
#include <meta/meta.hpp>
Return a new meta::list
where all elements A
of the list L
for which invoke<C,A>::value
is true
have been replaced with U
.
O(N)
.
|
related |
#include <meta/meta.hpp>
Return a new meta::list
by reversing the elements in the list L
.
O(N)
. using meta::reverse_fold = _t<detail::reverse_fold_<L, State, Fn>> |
#include <meta/meta.hpp>
Return a new meta::list
constructed by doing a right fold of the list L
using binary invocable Fn
and initial state State
. That is, the State(N)
for the list element A(N)
is computed by Fn(A(N), State(N+1)) -> State(N)
.
O(N)
. using meta::sort = _t<detail::sort_<L, Fn>> |
#include <meta/meta.hpp>
Return a new meta::list
that is sorted according to invocable predicate Fn
.
O(N log N)
Worst case: O(N^2)
.
|
related |
#include <meta/meta.hpp>
Return a new meta::list
constructed by transforming all the elements in L
with the unary invocable Fn
. transform
can also be called with two lists of the same length and a binary invocable, in which case it returns a new list constructed with the results of calling Fn
with each element in the lists, pairwise.
O(N)
. using meta::transpose |
#include <meta/meta.hpp>
Given a list of lists of types ListOfLists
, transpose the elements from the lists.
O(N * M)
, where N
is the size of the outer list, and M
is the size of the inner lists.
|
related |
#include <meta/meta.hpp>
Return a new meta::list
where all duplicate elements have been removed.
O(N^2)
. #include <meta/meta.hpp>
Given a list of lists of types ListOfLists
, construct a new list by grouping the elements from the lists pairwise into meta::list
s.
O(N * M)
, where N
is the size of the outer list, and M
is the size of the inner lists.
|
related |
#include <meta/meta.hpp>
Given a list of lists of types ListOfLists
and an invocable Fn
, construct a new list by calling Fn
with the elements from the lists pairwise.
O(N * M)
, where N
is the size of the outer list, and M
is the size of the inner lists.