lambda2/doc/lambda2/reference.adoc

////
Copyright 2020 Peter Dimov
Distributed under the Boost Software License, Version 1.0.
https://www.boost.org/LICENSE_1_0.txt
////

[#reference]
# Reference
:idprefix: ref_

## <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 );
```
[none]
* {blank}
+
Returns: :: `std::bind( std::plus<>(), std::forward<A>(a), std::forward<B>(b) );`

```
template<class A, class B> auto operator-( A && a, B && b );
```
[none]
* {blank}
+
Returns: :: `std::bind( std::minus<>(), std::forward<A>(a), std::forward<B>(b) );`

```
template<class A, class B> auto operator*( A && a, B && b );
```
[none]
* {blank}
+
Returns: :: `std::bind( std::multiplies<>(), std::forward<A>(a), std::forward<B>(b) );`

```
template<class A, class B> auto operator/( A && a, B && b );
```
[none]
* {blank}
+
Returns: :: `std::bind( std::divides<>(), std::forward<A>(a), std::forward<B>(b) );`

```
template<class A, class B> auto operator%( A && a, B && b );
```
[none]
* {blank}
+
Returns: :: `std::bind( std::modulus<>(), std::forward<A>(a), std::forward<B>(b) );`

```
template<class A> auto operator-( A && a );
```
[none]
* {blank}
+
Returns: ::
  `std::bind( std::negate<>(), std::forward<A>(a) );`

### Relational Operators

```
template<class A, class B> auto operator==( A && a, B && b );
```
[none]
* {blank}
+
Returns: :: `std::bind( std::equal_to<>(), std::forward<A>(a), std::forward<B>(b) );`

```
template<class A, class B> auto operator!=( A && a, B && b );
```
[none]
* {blank}
+
Returns: :: `std::bind( std::not_equal_to<>(), std::forward<A>(a), std::forward<B>(b) );`

```
template<class A, class B> auto operator>( A && a, B && b );
```
[none]
* {blank}
+
Returns: :: `std::bind( std::greater<>(), std::forward<A>(a), std::forward<B>(b) );`

```
template<class A, class B> auto operator<( A && a, B && b );
```
[none]
* {blank}
+
Returns: :: `std::bind( std::less<>(), std::forward<A>(a), std::forward<B>(b) );`

```
template<class A, class B> auto operator>=( A && a, B && b );
```
[none]
* {blank}
+
Returns: :: `std::bind( std::greater_equal<>(), std::forward<A>(a), std::forward<B>(b) );`

```
template<class A, class B> auto operator<=( A && a, B && b );
```
[none]
* {blank}
+
Returns: ::
  `std::bind( std::less_equal<>(), std::forward<A>(a), std::forward<B>(b) );`

### Logical Operators

```
template<class A, class B> auto operator&&( A && a, B && b );
```
[none]
* {blank}
+
Returns: :: `std::bind( std::logical_and<>(), std::forward<A>(a), std::forward<B>(b) );`

```
template<class A, class B> auto operator||( A && a, B && b );
```
[none]
* {blank}
+
Returns: :: `std::bind( std::logical_or<>(), std::forward<A>(a), std::forward<B>(b) );`

```
template<class A> auto operator!( A && a );
```
[none]
* {blank}
+
Returns: ::
  `std::bind( std::logical_not<>(), std::forward<A>(a) );`

### Bitwise Operators

```
template<class A, class B> auto operator&( A && a, B && b );
```
[none]
* {blank}
+
Returns: :: `std::bind( std::bit_and<>(), std::forward<A>(a), std::forward<B>(b) );`

```
template<class A, class B> auto operator|( A && a, B && b );
```
[none]
* {blank}
+
Returns: :: `std::bind( std::bit_or<>(), std::forward<A>(a), std::forward<B>(b) );`

```
template<class A, class B> auto operator^( A && a, B && b );
```
[none]
* {blank}
+
Returns: :: `std::bind( std::bit_xor<>(), std::forward<A>(a), std::forward<B>(b) );`

```
template<class A> auto operator~( A && a );
```
[none]
* {blank}
+
Returns: ::
  `std::bind( std::bit_not<>(), std::forward<A>(a) );`