home | help 
std::experi...mparableWith(3)  C++ Standard Libary std::experi...mparableWith(3)

NAME
     std::experimental::ranges::WeaklyEqualityComparableWith  -  std::experimen-
     tal::ranges::WeaklyEqualityComparableWith

Synopsis
	Defined in header <experimental/ranges/concepts>
	template< class T, class U >

	concept bool WeaklyEqualityComparableWith =
	    requires(const std::remove_reference_t<T>& t,
		     const std::remove_reference_t<U>& u) {
		{ t == u } -> Boolean&&;		     (ranges TS)
		{ t != u } -> Boolean&&;
		{ u == t } -> Boolean&&;
		{ u != t } -> Boolean&&;

	    };

	The concept WeaklyEqualityComparableWith<T, U> specifies that an  object
     of type T
	and an object of type U can be compared for equality with each other (in
     either
	order) using both == and !=, and the results of the comparisons are con-
     sistent. More
	formally, WeaklyEqualityComparableWith<T, U> is satisfied only if given

	  * t, an lvalue of type const std::remove_reference_t<T> and
	  * u, an lvalue of type const std::remove_reference_t<U>,

	the following are true:

	  * t == u, u == t, t != u,u != t have the same domain;
	  * bool(u == t) == bool(t == u);
	  * bool(t != u) == !bool(t == u); and
	  * bool(u != t) == bool(t != u).

	Equality preservation

	An  expression	is  equality  preserving  if it results in equal outputs
     given equal
	inputs.

	  * The inputs to an expression consist of its operands.
	  * The outputs of an expression consist of its result and all	operands
     modified by
	    the expression (if any).

	Every  expression required to be equality preserving is further required
     to be
	stable: two evaluations of such an expression with the	same  input  ob-
     jects must have
	equal  outputs absent any explicit intervening modification of those in-
     put objects.

	Unless noted otherwise, every expression used in  a  requires-expression
     is required
	to  be equality preserving and stable, and the evaluation of the expres-
     sion may only
	modify its non-constant operands. Operands that are constant must not be
     modified.

	Implicit expression variations

	A requires-expression that uses an expression that is non-modifying  for
     some
	constant  lvalue  operand also implicitly requires additional variations
     of that
	expression that accept a  non-constant	lvalue	or  (possibly  constant)
     rvalue for the
	given operand unless such an expression variation is explicitly required
     with
	differing  semantics. These implicit expression variations must meet the
     same
	semantic requirements of the declared expression. The extent to which an
	implementation validates the syntax of the variations is unspecified.

See also
	EqualityComparable     specifies that operator == is an equivalence  re-
     lation
	EqualityComparableWith (concept)

http://cppreference.com 	   2024.06.10	   std::experi...mparableWith(3)
home | help