Lambda2: A C++14 Lambda Library

Overview

Description

…

Usage Examples

…

Dependencies

None. A single, self-contained header.

Supported Compilers

GCC 5 or later with -std=c++14 or above
Clang 3.5 or later with -std=c++14 or above
Visual Studio 2015, 2017, 2019

Tested on Travis and Appveyor.

Reference

<boost/lambda2/lambda2.hpp>

Synopsis

namespace boost {
namespace lambda2 {

template<class A, class B> auto operator+( A && a, B && b );
template<class A, class B> auto operator-( A && a, B && b );
template<class A, class B> auto operator*( A && a, B && b );
template<class A, class B> auto operator/( A && a, B && b );
template<class A, class B> auto operator%( A && a, B && b );
template<class A> auto operator-( A && a );

template<class A, class B> auto operator==( A && a, B && b );
template<class A, class B> auto operator!=( A && a, B && b );
template<class A, class B> auto operator>( A && a, B && b );
template<class A, class B> auto operator<( A && a, B && b );
template<class A, class B> auto operator>=( A && a, B && b );
template<class A, class B> auto operator<=( A && a, B && b );

template<class A, class B> auto operator&&( A && a, B && b );
template<class A, class B> auto operator||( A && a, B && b );
template<class A> auto operator!( A && a );

template<class A, class B> auto operator&( A && a, B && b );
template<class A, class B> auto operator|( A && a, B && b );
template<class A, class B> auto operator^( A && a, B && b );
template<class A> auto operator~( A && a );

} // namespace lambda2
} // namespace boost

Definitions

A type T is a lambda expression if, for the type T2 that is std::remove_cv_t<std::remove_reference_t<T>>, the expression std::is_placeholder<T2>::value || std::is_bind_expression<T2>::value is true.

All operators defined in the subsequent sections only participate in overload resolution if at least one of their operands is a lambda expression.

Arithmetic Operators

template<class A, class B> auto operator+( A && a, B && b );

Returns:

std::bind( std::plus<>(), std::forward<A>(a), std::forward(b) );

template<class A, class B> auto operator-( A && a, B && b );

Returns:

std::bind( std::minus<>(), std::forward<A>(a), std::forward(b) );

template<class A, class B> auto operator*( A && a, B && b );

Returns:

std::bind( std::multiplies<>(), std::forward<A>(a), std::forward(b) );

template<class A, class B> auto operator/( A && a, B && b );

Returns:

std::bind( std::divides<>(), std::forward<A>(a), std::forward(b) );

template<class A, class B> auto operator%( A && a, B && b );

Returns:

std::bind( std::modulus<>(), std::forward<A>(a), std::forward(b) );

template<class A> auto operator-( A && a );

Returns:

std::bind( std::negate<>(), std::forward<A>(a) );

Relational Operators

template<class A, class B> auto operator==( A && a, B && b );

Returns:

std::bind( std::equal_to<>(), std::forward<A>(a), std::forward(b) );

template<class A, class B> auto operator!=( A && a, B && b );

Returns:

std::bind( std::not_equal_to<>(), std::forward<A>(a), std::forward(b) );

template<class A, class B> auto operator>( A && a, B && b );

Returns:

std::bind( std::greater<>(), std::forward<A>(a), std::forward(b) );

template<class A, class B> auto operator<( A && a, B && b );

Returns:

std::bind( std::less<>(), std::forward<A>(a), std::forward(b) );

template<class A, class B> auto operator>=( A && a, B && b );

Returns:

std::bind( std::greater_equal<>(), std::forward<A>(a), std::forward(b) );

template<class A, class B> auto operator<=( A && a, B && b );

Returns:

std::bind( std::less_equal<>(), std::forward<A>(a), std::forward(b) );

Logical Operators

template<class A, class B> auto operator&&( A && a, B && b );

Returns:

std::bind( std::logical_and<>(), std::forward<A>(a), std::forward(b) );

template<class A, class B> auto operator||( A && a, B && b );

Returns:

std::bind( std::logical_or<>(), std::forward<A>(a), std::forward(b) );

template<class A> auto operator!( A && a );

Returns:

std::bind( std::logical_not<>(), std::forward<A>(a) );

Bitwise Operators

template<class A, class B> auto operator&( A && a, B && b );

Returns:

std::bind( std::bit_and<>(), std::forward<A>(a), std::forward(b) );

template<class A, class B> auto operator|( A && a, B && b );

Returns:

std::bind( std::bit_or<>(), std::forward<A>(a), std::forward(b) );

template<class A, class B> auto operator^( A && a, B && b );

Returns:

std::bind( std::bit_xor<>(), std::forward<A>(a), std::forward(b) );

template<class A> auto operator~( A && a );

Returns:

std::bind( std::bit_not<>(), std::forward<A>(a) );