Transformation
Meta » Algorithms

Transformation algorithms. More...

## Modules

| lazy

## Typedefs

template<list_like L, typename State , invocable Fn>
using | meta::accumulate = fold< L, State, Fn >
| An alias for `meta::fold`. More...
template<list_like ListOfLists>
using | meta::cartesian_product = reverse_fold< ListOfLists, list< list<> >, quote_trait< detail::cartesian_product_fn > >
| 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. More...
template<list_like ... Ls>
using | meta::concat_ = _t< detail::concat_< Ls... > >
| Concatenates several lists into a single list. More...
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`. More...
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`. More...
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". More...
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)`. More...
template<list_like ListOfLists>
using | meta::join = apply< quote< concat >, ListOfLists >
| Joins a list of lists into a single list. More...
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. More...
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`. More...
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`. More...
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`. More...
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`. More...
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`. More...
template<list_like L>
using | meta::reverse = _t< detail::reverse_< L > >
| Return a new `meta::list` by reversing the elements in the list `L`. More...
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)`. More...
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`. More...
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. More...
template<list_like ListOfLists>
using | meta::transpose = fold< ListOfLists, repeat_n< size< front< ListOfLists > >, list<> >, bind_back< quote< transform >, quote< push_back > >>
| Given a list of lists of types `ListOfLists`, transpose the elements from the lists. More...
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. More...
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. More...
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. More...

## Detailed Description

Transformation algorithms.

## Typedef Documentation

## accumulate

template<list_like L, typename State , invocable Fn>

using meta::accumulate = typedef fold<L, State, Fn>

`#include <meta/meta.hpp>`

An alias for `meta::fold`.

Complexity
  `O(N)`.

## cartesian_product

template<list_like ListOfLists>

using meta::cartesian_product = typedef reverse_fold<ListOfLists, list<list<> >, quote_trait<detail::cartesian_product_fn> >

`#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.

Complexity
  `O(N * M)`, where `N` is the size of the outer list, and `M` is the size of the inner lists.

## concat_

template<list_like ... Ls>

using meta::concat_ = typedef _t<detail::concat_<Ls...> >

`#include <meta/meta.hpp>`

Concatenates several lists into a single list.

Precondition
  The parameters must all be instantiations of `meta::list`.

Complexity
  `O(L)` where `L` is the number of lists in the list of lists.

## drop

template<list_like L, integral N>

using meta::drop = typedef drop_c<L, N::type::value>

related

`#include <meta/meta.hpp>`

Return a new `meta::list` by removing the first `N` elements from `L`.

Complexity
  `O(1)`.

## drop_c

template<list_like L, std::size_t N>

using meta::drop_c = typedef _t<detail::drop_<L, N> >

`#include <meta/meta.hpp>`

Return a new `meta::list` by removing the first `N` elements from `L`.

Complexity
  `O(1)`.

## filter

template<typename L , typename Pred >

using meta::filter = typedef join<transform<L, detail::filter_<Pred> >>

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".

Complexity
  `O(N)`.

## fold

template<list_like L, typename State , invocable Fn>

using meta::fold = typedef _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)`.

Complexity
  `O(N)`.

## join

template<list_like ListOfLists>

using meta::join = typedef apply<quote<concat>, ListOfLists>

related

`#include <meta/meta.hpp>`

Joins a list of lists into a single list.

Precondition
  The parameter must be an instantiation of `meta::list<T`...> where each `T` is itself an instantiation of `meta::list`.

Complexity
  `O(L)` where `L` is the number of lists in the list of lists.

## partition

template<list_like L, invocable Fn>

using meta::partition = typedef 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.

Complexity
  `O(N)`.

## pop_front

template<list_like L>

using meta::pop_front = typedef _t<detail::pop_front_<L> >

`#include <meta/meta.hpp>`

Return a new `meta::list` by removing the first element from the front of `L`.

Complexity
  `O(1)`.

## push_back

template<list_like L, typename... Ts>

using meta::push_back = typedef 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`.

Complexity
  `O(1)`.

Note
  `pop_back` not provided because it cannot be made to meet the complexity guarantees one would expect.

## push_front

template<list_like L, typename... Ts>

using meta::push_front = typedef 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`.

Complexity
  `O(1)`.

## replace

template<list_like L, typename T , typename U >

using meta::replace = typedef _t<detail::replace_<L, T, U> >

related

`#include <meta/meta.hpp>`

Return a new `meta::list` where all instances of type `T` have been replaced with `U`.

Complexity
  `O(N)`.

## replace_if

template<list_like L, typename C , typename U >

using meta::replace_if = typedef _t<detail::replace_if_<L, C, U> >

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`.

Complexity
  `O(N)`.

## reverse

template<list_like L>

using meta::reverse = typedef _t<detail::reverse_<L> >

related

`#include <meta/meta.hpp>`

Return a new `meta::list` by reversing the elements in the list `L`.

Complexity
  `O(N)`.

## reverse_fold

template<list_like L, typename State , invocable Fn>

using meta::reverse_fold = typedef _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)`.

Complexity
  `O(N)`.

## sort

template<list_like L, invocable Fn>

using meta::sort = typedef _t<detail::sort_<L, Fn> >

related

`#include <meta/meta.hpp>`

Return a new `meta::list` that is sorted according to invocable predicate `Fn`.

Complexity
  Expected: `O(N log N)` Worst case: `O(N^2)`.
  using L0 = list<char[5], char[3], char[2], char[6], char[1], char[5], char[10]>;
  using L1 = meta::sort<L0, lambda<_a, _b, lazy::less<lazy::sizeof_<_a>, lazy::sizeof_<_b>>>>;
  static_assert(std::is_same_v<L1, list<char[1], char[2], char[3], char[5], char[5], char[6], char[10]>>, "");
  meta::sort
  _t< detail::sort_< L, Fn > > sort
  Return a new meta::list that is sorted according to invocable predicate Fn.
  Definition: meta.hpp:3277

## transform

template<typename... Args>

using meta::transform = typedef _t<detail::transform_<Args...> >

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.

Complexity
  `O(N)`.

## transpose

template<list_like ListOfLists>

using meta::transpose = typedef fold<ListOfLists, repeat_n<size<front<ListOfLists> >, list<> >, bind_back<quote<transform>, quote<push_back> >>

`#include <meta/meta.hpp>`

Given a list of lists of types `ListOfLists`, transpose the elements from the lists.

Complexity
  `O(N * M)`, where `N` is the size of the outer list, and `M` is the size of the inner lists.

## unique

template<list_like L>

using meta::unique = typedef fold<L, list<>, quote_trait<detail::insert_back_> >

related

`#include <meta/meta.hpp>`

Return a new `meta::list` where all duplicate elements have been removed.

Complexity
  `O(N^2)`.

## zip

template<list_like ListOfLists>

using meta::zip = typedef transpose<ListOfLists>

related

`#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.

Complexity
  `O(N * M)`, where `N` is the size of the outer list, and `M` is the size of the inner lists.

## zip_with

template<invocable Fn, list_like ListOfLists>

using meta::zip_with = typedef transform<transpose<ListOfLists>, uncurry<Fn> >

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.

Complexity
  `O(N * M)`, where `N` is the size of the outer list, and `M` is the size of the inner lists.