Range-v3 Range algorithms, views, and actions for the Standard Library |

Typedefs
lazy
Meta » Algorithms » Transformation

## Description

## Typedefs
template<typename L , typename State , typename Fn >
using | meta::lazy::accumulate = defer< accumulate, L, State, Fn >
template<typename ListOfLists >
using | meta::lazy::cartesian_product = defer< cartesian_product, ListOfLists >
template<typename... Lists>
using | meta::lazy::concat = defer< concat, Lists... >
template<typename L , typename N >
using | meta::lazy::drop = defer< drop, L, N >
template<typename L , typename Fn >
using | meta::lazy::filter = defer< filter, L, Fn >
template<typename L , typename State , typename Fn >
using | meta::lazy::fold = defer< fold, L, State, Fn >
template<typename ListOfLists >
using | meta::lazy::join = defer< join, ListOfLists >
template<typename L , typename Fn >
using | meta::lazy::partition = defer< partition, L, Fn >
template<typename L >
using | meta::lazy::pop_front = defer< pop_front, L >
template<typename... Ts>
using | meta::lazy::push_back = defer< push_back, Ts... >
template<typename... Ts>
using | meta::lazy::push_front = defer< push_front, Ts... >
template<typename L , typename T , typename U >
using | meta::lazy::replace = defer< replace, T, U >
template<typename L , typename C , typename U >
using | meta::lazy::replace_if = defer< replace_if, C, U >
template<typename L >
using | meta::lazy::reverse = defer< reverse, L >
template<typename L , typename State , typename Fn >
using | meta::lazy::reverse_fold = defer< reverse_fold, L, State, Fn >
template<typename L , typename Fn >
using | meta::lazy::sort = defer< sort, L, Fn >
template<typename... Args>
using | meta::lazy::transform = defer< transform, Args... >
template<typename ListOfLists >
using | meta::lazy::transpose = defer< transpose, ListOfLists >
template<typename L >
using | meta::lazy::unique = defer< unique, L >
template<typename ListOfLists >
using | meta::lazy::zip = defer< zip, ListOfLists >
template<typename Fn , typename ListOfLists >
using | meta::lazy::zip_with = defer< zip_with, Fn, ListOfLists >

## Typedef Documentation

## ◆ accumulate

template<typename L , typename State , typename Fn >

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

`#include <meta/meta.hpp>`

See also
  'meta::accumulate'

## ◆ cartesian_product

template<typename ListOfLists >

using meta::lazy::cartesian_product = typedef defer<cartesian_product, ListOfLists>

`#include <meta/meta.hpp>`

See also
  'meta::cartesian_product'

## ◆ concat

template<typename... Lists>

using meta::lazy::concat = typedef defer<concat, Lists...>
| related

`#include <meta/meta.hpp>`

See also
  'meta::concat'

## ◆ drop

template<typename L , typename N >

using meta::lazy::drop = typedef defer<drop, L, N>
| related

`#include <meta/meta.hpp>`

See also
  'meta::drop'

## ◆ filter

template<typename L , typename Fn >

using meta::lazy::filter = typedef defer<filter, L, Fn>
| related

`#include <meta/meta.hpp>`

See also
  'meta::filter'

## ◆ fold

template<typename L , typename State , typename Fn >

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

`#include <meta/meta.hpp>`

See also
  'meta::foldl'

## ◆ join

template<typename ListOfLists >

using meta::lazy::join = typedef defer<join, ListOfLists>
| related

`#include <meta/meta.hpp>`

See also
  'meta::join'

## ◆ partition

template<typename L , typename Fn >

using meta::lazy::partition = typedef defer<partition, L, Fn>

`#include <meta/meta.hpp>`

See also
  'meta::partition'

## ◆ pop_front

template<typename L >

using meta::lazy::pop_front = typedef defer<pop_front, L>

`#include <meta/meta.hpp>`

See also
  'meta::pop_front'

## ◆ push_back

template<typename... Ts>

using meta::lazy::push_back = typedef defer<push_back, Ts...>

`#include <meta/meta.hpp>`

See also
  'meta::push_back'

## ◆ push_front

template<typename... Ts>

using meta::lazy::push_front = typedef defer<push_front, Ts...>

`#include <meta/meta.hpp>`

See also
  'meta::push_front'

## ◆ replace

template<typename L , typename T , typename U >

using meta::lazy::replace = typedef defer<replace, T, U>
| related

`#include <meta/meta.hpp>`

See also
  'meta::replace'

## ◆ replace_if

template<typename L , typename C , typename U >

using meta::lazy::replace_if = typedef defer<replace_if, C, U>
| related

`#include <meta/meta.hpp>`

See also
  'meta::replace_if'

## ◆ reverse

template<typename L >

using meta::lazy::reverse = typedef defer<reverse, L>
| related

`#include <meta/meta.hpp>`

See also
  'meta::reverse'

## ◆ reverse_fold

template<typename L , typename State , typename Fn >

using meta::lazy::reverse_fold = typedef defer<reverse_fold, L, State, Fn>

`#include <meta/meta.hpp>`

See also
  'meta::foldr'

## ◆ sort

template<typename L , typename Fn >

using meta::lazy::sort = typedef defer<sort, L, Fn>
| related

`#include <meta/meta.hpp>`

See also
  'meta::sort'

## ◆ transform

template<typename... Args>

using meta::lazy::transform = typedef defer<transform, Args...>
| related

`#include <meta/meta.hpp>`

See also
  'meta::transform'

## ◆ transpose

template<typename ListOfLists >

using meta::lazy::transpose = typedef defer<transpose, ListOfLists>

`#include <meta/meta.hpp>`

See also
  'meta::transpose'

## ◆ unique

template<typename L >

using meta::lazy::unique = typedef defer<unique, L>
| related

`#include <meta/meta.hpp>`

See also
  'meta::unique'

## ◆ zip

template<typename ListOfLists >

using meta::lazy::zip = typedef defer<zip, ListOfLists>
| related

`#include <meta/meta.hpp>`

See also
  'meta::zip'

## ◆ zip_with

template<typename Fn , typename ListOfLists >

using meta::lazy::zip_with = typedef defer<zip_with, Fn, ListOfLists>
| related

`#include <meta/meta.hpp>`

See also
  'meta::zip_with'