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

NAME
     std::experimental::ranges::ConvertibleTo  - std::experimental::ranges::Con-
     vertibleTo

Synopsis
	Defined in header <experimental/ranges/concepts>
	template< class From, class To >

	concept bool ConvertibleTo =
	    std::is_convertible<From, To>::value &&	  (ranges TS)
	    requires(From (&f)()) {
		static_cast<To>(f());

	    };

	The concept ConvertibleTo<From, To> specifies that an expression of  the
     type and
	value  category  specified by From can be implicitly and explicitly con-
     verted to the
	type To, and the two forms of conversion are equivalent.

	Specifically, ConvertibleTo<From, To> is satisfied only  if,  given  the
     invented
	function  To  test(From (&f)()) { return f(); } and a function f of type
     From () such
	that the expression f() is equality-preserving (see below),

	  * Either
	       * To is neither an object type nor a reference-to-object type, or
	       * static_cast<To>(f()) is equal to test(f), and
	  * One of the following is true:
	       * From is not a reference-to-object type, or
	       * From is an rvalue reference to a non-const-qualified type,  and
     the
		 resulting  state  of  the object referenced by f() is valid but
     unspecified
		 after either expression above; or
	       * the object referred to by f() is not modified by either expres-
     sion above.

	There  need  not  be  any  subsumption	relationship  between	Convert-
     ibleTo<From, To> and
	std::is_convertible<From, To>::value.

	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.

See also
	is_convertible
	is_nothrow_convertible checks if a type can be converted  to  the  other
     type
	(C++11) 	       (class template)
	(C++20)

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