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

Common Requirements

All operators defined in the subsequent sections only participate in overload resolution if at least one of their operands is such that for its unqualified type T, the expression std::is_placeholder<T>::value || std::is_bind_expression<T>::value is true.

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) );