cpp/iterator/indirect strict weak order - Revision history

Xmcgcg: c -> c/core.

2024-10-14T01:01:28Z

c -> c/core.

← Older revision		Revision as of 01:01, 14 October 2024
Line 1:		Line 1:
	{{cpp/title\|indirect_strict_weak_order}}		{{cpp/title\|indirect_strict_weak_order}}
	{{cpp/iterator/navbar}}		{{cpp/iterator/navbar}}
	{{~~dcl begin}}~~		{{ddcl\|header=iterator\|since=c++20\|1=
	~~{{dcl~~ header\|iterator}}
	~~{{dcl~~\|since=c++20\|1=
	template< class F, class I1, class I2 = I1 >		template< class F, class I1, class I2 = I1 >
	concept indirect_strict_weak_order =		concept indirect_strict_weak_order =
Line 9:		Line 7:
	std::indirectly_readable<I2> &&		std::indirectly_readable<I2> &&
	std::copy_constructible<F> &&		std::copy_constructible<F> &&
	std::strict_weak_order<F&, /indirect-value-t/<I1>, /indirect-value-t/<I2>> &&		std::strict_weak_order
			<F&, /indirect-value-t/<I1>, /indirect-value-t/<I2>> &&
	std::strict_weak_order		std::strict_weak_order
	<F&, /indirect-value-t/<I1>, std::iter_reference_t<I2>> &&		<F&, /indirect-value-t/<I1>, std::iter_reference_t<I2>> &&
Line 17:		Line 16:
	<F&, std::iter_reference_t<I1>, std::iter_reference_t<I2>>;		<F&, std::iter_reference_t<I1>, std::iter_reference_t<I2>>;
	}}		}}
	~~{{dcl end}}~~

	The concept {{tt\|indirect_strict_weak_order}} specifies requirements for algorithms that call strict weak orders as their arguments. The key difference between this concept and {{lc\|std::strict_weak_order}} is that it is applied to the types that {{tt\|I1}} and {{tt\|I2}} references, rather than {{tt\|I1}} and {{tt\|I2}} themselves.		The concept {{tt\|indirect_strict_weak_order}} specifies requirements for algorithms that call strict weak orders as their arguments. The key difference between this concept and {{lc\|std::strict_weak_order}} is that it is applied to the types that {{tt\|I1}} and {{tt\|I2}} references, rather than {{tt\|I1}} and {{tt\|I2}} themselves.
Line 23:		Line 21:
	===Defect reports===		===Defect reports===
	{{dr list begin}}		{{dr list begin}}
	{{dr list item\|paper=P2609R3\|std=C++20\|before=some requirements were defined in terms of {{c\|std::iter_value_t<I>&}}<br>~~which mishandled projections~~ resulting in incompatibility with strict weak order {{c\|F&}}\|after=defined in terms of {{c\|/indirect-value-t/<I>}}<br>to correctly handle such projections}}		{{dr list item\|paper=P2609R3\|std=C++20\|before=some requirements were defined in terms of<br>{{c/core\|std::iter_value_t<I>&}} which mishandled projections<br>resulting in incompatibility with strict weak order {{c/core\|F&}}\|after=defined in terms of<br>{{c/core\|/indirect-value-t/<I>}} to<br>correctly handle such projections}}
	{{dr list item\|paper=P2997R1\|std=C++20\|before={{tt\|indirect_strict_weak_order}} required {{c\|F&}} to satisfy {{lconcept\|strict_weak_order}} with~~<br>~~{{c\|std::iter_common_reference_t<I>}}\|after=does not require}}		{{dr list item\|paper=P2997R1\|std=C++20\|before={{tt\|indirect_strict_weak_order}} required {{c/core\|F&}} to satisfy<br>{{lconcept\|strict_weak_order}} with {{c/core\|std::iter_common_reference_t<I>}}\|after=does not require}}
	{{dr list end}}		{{dr list end}}

	{{langlinks\|de\|es\|fr\|it\|ja\|pt\|ru\|zh}}		{{langlinks\|de\|es\|fr\|it\|ja\|pt\|ru\|zh}}

Cooky: ~ apply P2997R1 as DR20

2024-08-24T02:09:22Z

~ apply P2997R1 as DR20

← Older revision		Revision as of 02:09, 24 August 2024
Line 3:		Line 3:
	{{dcl begin}}		{{dcl begin}}
	{{dcl header\|iterator}}		{{dcl header\|iterator}}
	~~{{dcl rev begin}}~~		{{dcl\|since=c++20\|1=
	{{dcl\|since=c++20~~\|until=c++26\|1=~~
	~~template< class F, class I1, class I2 = I1 >~~
	~~concept indirect_strict_weak_order =~~
	~~std::indirectly_readable<I1> &&~~
	~~std::indirectly_readable<I2> &&~~
	~~std::copy_constructible<F> &&~~
	~~std::strict_weak_order<F&, /indirect-value-t/<I1>, /indirect-value-t/<I2>> &&~~
	~~std::strict_weak_order~~
	~~<F&, /indirect-value-t/<I1>, std::iter_reference_t<I2>> &&~~
	~~std::strict_weak_order~~
	~~<F&, std::iter_reference_t<I1>, /indirect-value-t/<I2>> &&~~
	~~std::strict_weak_order~~
	~~<F&, std::iter_reference_t<I1>, std::iter_reference_t<I2>> &&~~
	~~std::strict_weak_order~~
	~~<F&, std::iter_common_reference_t<I1>, std::iter_common_reference_t<I2>>;~~
	}}
	~~{{dcl\|since=c++26~~\|1=
	template< class F, class I1, class I2 = I1 >		template< class F, class I1, class I2 = I1 >
	concept indirect_strict_weak_order =		concept indirect_strict_weak_order =
Line 34:		Line 17:
	<F&, std::iter_reference_t<I1>, std::iter_reference_t<I2>>;		<F&, std::iter_reference_t<I1>, std::iter_reference_t<I2>>;
	}}		}}
	~~{{dcl rev end}}~~
	{{dcl end}}		{{dcl end}}

Line 42:		Line 24:
	{{dr list begin}}		{{dr list begin}}
	{{dr list item\|paper=P2609R3\|std=C++20\|before=some requirements were defined in terms of {{c\|std::iter_value_t<I>&}}<br>which mishandled projections resulting in incompatibility with strict weak order {{c\|F&}}\|after=defined in terms of {{c\|/indirect-value-t/<I>}}<br>to correctly handle such projections}}		{{dr list item\|paper=P2609R3\|std=C++20\|before=some requirements were defined in terms of {{c\|std::iter_value_t<I>&}}<br>which mishandled projections resulting in incompatibility with strict weak order {{c\|F&}}\|after=defined in terms of {{c\|/indirect-value-t/<I>}}<br>to correctly handle such projections}}
			{{dr list item\|paper=P2997R1\|std=C++20\|before={{tt\|indirect_strict_weak_order}} required {{c\|F&}} to satisfy {{lconcept\|strict_weak_order}} with<br>{{c\|std::iter_common_reference_t<I>}}\|after=does not require}}
	{{dr list end}}		{{dr list end}}

	{{langlinks\|de\|es\|fr\|it\|ja\|pt\|ru\|zh}}		{{langlinks\|de\|es\|fr\|it\|ja\|pt\|ru\|zh}}

Cooky: apply DR20: P2609R3 Relaxing Ranges Just A Smidge (replace iter_value_t& with indirect-value-t)

2024-08-23T15:56:22Z

apply DR20: P2609R3 Relaxing Ranges Just A Smidge (replace iter_value_t& with indirect-value-t)

← Older revision Revision as of 15:56, 23 August 2024
Line 10: Line 10:

 std::indirectly_readable<I2> &&
 std::indirectly_readable<I2> &&

 std::copy_constructible<F> &&
 std::copy_constructible<F> &&

 std::strict_weak_order<F&, ~~std::iter_value_t~~<I1>&, ~~std::iter_value_t~~<I2>&> &&
 std::strict_weak_order<F&, /*indirect-value-t*/<I1>, /*indirect-value-t*/<I2>> &&

 std::strict_weak_order
 std::strict_weak_order

 <F&, ~~std::iter_value_t~~<I1>&, std::iter_reference_t<I2>> &&
 <F&, /*indirect-value-t*/<I1>, std::iter_reference_t<I2>> &&

 std::strict_weak_order
 std::strict_weak_order

 <F&, std::iter_reference_t<I1>, ~~std::iter_value_t~~<I2>&> &&
 <F&, std::iter_reference_t<I1>, /*indirect-value-t*/<I2>> &&

 std::strict_weak_order
 std::strict_weak_order

 <F&, std::iter_reference_t<I1>, std::iter_reference_t<I2>> &&
 <F&, std::iter_reference_t<I1>, std::iter_reference_t<I2>> &&

Line 26: Line 26:

 std::indirectly_readable<I2> &&
 std::indirectly_readable<I2> &&

 std::copy_constructible<F> &&
 std::copy_constructible<F> &&

 std::strict_weak_order<F&, ~~std::iter_value_t~~<I1>&, ~~std::iter_value_t~~<I2>&> &&
 std::strict_weak_order<F&, /*indirect-value-t*/<I1>, /*indirect-value-t*/<I2>> &&

 std::strict_weak_order
 std::strict_weak_order

 <F&, ~~std::iter_value_t~~<I1>&, std::iter_reference_t<I2>> &&
 <F&, /*indirect-value-t*/<I1>, std::iter_reference_t<I2>> &&

 std::strict_weak_order
 std::strict_weak_order

 <F&, std::iter_reference_t<I1>, ~~std::iter_value_t~~<I2>&> &&
 <F&, std::iter_reference_t<I1>, /*indirect-value-t*/<I2>> &&

 std::strict_weak_order
 std::strict_weak_order

 <F&, std::iter_reference_t<I1>, std::iter_reference_t<I2>>;
 <F&, std::iter_reference_t<I1>, std::iter_reference_t<I2>>;

Line 38: Line 38:

The concept {{tt|indirect_strict_weak_order}} specifies requirements for algorithms that call strict weak orders as their arguments. The key difference between this concept and {{lc|std::strict_weak_order}} is that it is applied to the types that {{tt|I1}} and {{tt|I2}} references, rather than {{tt|I1}} and {{tt|I2}} themselves.
The concept {{tt|indirect_strict_weak_order}} specifies requirements for algorithms that call strict weak orders as their arguments. The key difference between this concept and {{lc|std::strict_weak_order}} is that it is applied to the types that {{tt|I1}} and {{tt|I2}} references, rather than {{tt|I1}} and {{tt|I2}} themselves.

===Defect reports===

{{dr list begin}}

{{dr list item|paper=P2609R3|std=C++20|before=some requirements were defined in terms of {{c|std::iter_value_t&}} which mishandled projections resulting in incompatibility with strict weak order {{c|F&}}|after=defined in terms of {{c|/*indirect-value-t*/}} to correctly handle such projections}}

{{dr list end}}

{{langlinks|de|es|fr|it|ja|pt|ru|zh}}
{{langlinks|de|es|fr|it|ja|pt|ru|zh}}

Xmcgcg: Applied P2997R1 (Removing the common reference requirement from the indirectly invocable concepts).

2024-07-24T07:02:29Z

Applied P2997R1 (Removing the common reference requirement from the indirectly invocable concepts).

← Older revision Revision as of 07:02, 24 July 2024
Line 1: Line 1:

{{cpp/title|indirect_strict_weak_order}}
{{cpp/title|indirect_strict_weak_order}}

{{cpp/iterator/navbar}}
{{cpp/iterator/navbar}}

{{~~ddcl~~|~~header=~~iterator|since=c++20|1=
{{dcl begin}}

{{dcl header|iterator}}

{{dcl rev begin}}

{{dcl|since=c++20|until=c++26|1=

template< class F, class I1, class I2 = I1 >
template< class F, class I1, class I2 = I1 >

concept indirect_strict_weak_order =
concept indirect_strict_weak_order =

Line 8: Line 11:

 std::copy_constructible<F> &&
 std::copy_constructible<F> &&

 std::strict_weak_order<F&, std::iter_value_t<I1>&, std::iter_value_t<I2>&> &&
 std::strict_weak_order<F&, std::iter_value_t<I1>&, std::iter_value_t<I2>&> &&

 std::strict_weak_order<F&, std::iter_value_t<I1>&, std::iter_reference_t<I2>> &&
 std::strict_weak_order

 std::strict_weak_order<F&, std::iter_reference_t<I1>, std::iter_value_t<I2>&> &&
<F&, std::iter_value_t<I1>&, std::iter_reference_t<I2>> &&

 std::strict_weak_order<F&, std::iter_reference_t<I1>, std::iter_reference_t<I2>> &&
 std::strict_weak_order

 std::strict_weak_order<F&, std::iter_common_reference_t<I1>,
<F&, std::iter_reference_t<I1>, std::iter_value_t<I2>&> &&

std::iter_common_reference_t<I2>>;
 std::strict_weak_order

<F&, std::iter_reference_t<I1>, std::iter_reference_t<I2>> &&

 std::strict_weak_order

<F&, std::iter_common_reference_t<I1>, std::iter_common_reference_t<I2>>;

}}
}}

{{dcl|since=c++26|1=

template< class F, class I1, class I2 = I1 >

concept indirect_strict_weak_order =

std::indirectly_readable<I1> &&

std::indirectly_readable<I2> &&

std::copy_constructible<F> &&

std::strict_weak_order<F&, std::iter_value_t<I1>&, std::iter_value_t<I2>&> &&

std::strict_weak_order

<F&, std::iter_value_t<I1>&, std::iter_reference_t<I2>> &&

std::strict_weak_order

<F&, std::iter_reference_t<I1>, std::iter_value_t<I2>&> &&

std::strict_weak_order

<F&, std::iter_reference_t<I1>, std::iter_reference_t<I2>>;

}}

{{dcl rev end}}

{{dcl end}}

The concept {{tt|indirect_strict_weak_order}} specifies requirements for algorithms that call strict weak orders as their arguments. The key difference between this concept and {{lc|std::strict_weak_order}} is that it is applied to the types that {{tt|I1}} and {{tt|I2}} references, rather than {{tt|I1}} and {{tt|I2}} themselves.
The concept {{tt|indirect_strict_weak_order}} specifies requirements for algorithms that call strict weak orders as their arguments. The key difference between this concept and {{lc|std::strict_weak_order}} is that it is applied to the types that {{tt|I1}} and {{tt|I2}} references, rather than {{tt|I1}} and {{tt|I2}} themselves.

~~===Semantic requirements===~~

~~{{tt|F}}, {{tt|I1}}, and {{tt|I2}} model {{tt|indirect_strict_weak_order}} only if all concepts it subsumes are modeled.~~

{{langlinks|de|es|fr|it|ja|pt|ru|zh}}
{{langlinks|de|es|fr|it|ja|pt|ru|zh}}

Space Mission: /* Synopsis */ narrowing ←→

2023-10-03T19:03:24Z

Synopsis: narrowing ←→

← Older revision Revision as of 19:03, 3 October 2023
Line 11: Line 11:

 std::strict_weak_order<F&, std::iter_reference_t<I1>, std::iter_value_t<I2>&> &&
 std::strict_weak_order<F&, std::iter_reference_t<I1>, std::iter_value_t<I2>&> &&

 std::strict_weak_order<F&, std::iter_reference_t<I1>, std::iter_reference_t<I2>> &&
 std::strict_weak_order<F&, std::iter_reference_t<I1>, std::iter_reference_t<I2>> &&

 std::strict_weak_order<F&, std::iter_common_reference_t<I1>, std::iter_common_reference_t<I2>>;
 std::strict_weak_order<F&, std::iter_common_reference_t<I1>,

std::iter_common_reference_t<I2>>;

}}
}}

Andreas Krug: fmt

2023-10-01T06:11:27Z

fmt

← Older revision Revision as of 06:11, 1 October 2023
Line 1: Line 1:

{{cpp/title|indirect_strict_weak_order}}
{{cpp/title|indirect_strict_weak_order}}

{{cpp/iterator/navbar}}
{{cpp/iterator/navbar}}

{{ddcl | header=iterator | since=c++20 | 1=
{{ddcl|header=iterator|since=c++20|1=

template< class F, class I1, class I2 = I1 >
template< class F, class I1, class I2 = I1 >

concept indirect_strict_weak_order =
concept indirect_strict_weak_order =

std::indirectly_readable<I1> &&
std::indirectly_readable<I1> &&

std::indirectly_readable<I2> &&
std::indirectly_readable<I2> &&

std::copy_constructible<F> &&
std::copy_constructible<F> &&

std::strict_weak_order<F&, std::iter_value_t<I1>&, std::iter_value_t<I2>&> &&
std::strict_weak_order<F&, std::iter_value_t<I1>&, std::iter_value_t<I2>&> &&

std::strict_weak_order<F&, std::iter_value_t<I1>&, std::iter_reference_t<I2>> &&
std::strict_weak_order<F&, std::iter_value_t<I1>&, std::iter_reference_t<I2>> &&

std::strict_weak_order<F&, std::iter_reference_t<I1>, std::iter_value_t<I2>&> &&
std::strict_weak_order<F&, std::iter_reference_t<I1>, std::iter_value_t<I2>&> &&

std::strict_weak_order<F&, std::iter_reference_t<I1>, std::iter_reference_t<I2>> &&
std::strict_weak_order<F&, std::iter_reference_t<I1>, std::iter_reference_t<I2>> &&

std::strict_weak_order<F&, std::iter_common_reference_t<I1>, std::iter_common_reference_t<I2>>;
std::strict_weak_order<F&, std::iter_common_reference_t<I1>, std::iter_common_reference_t<I2>>;

}}
}}

Space Mission: fmt, langlinks.

2021-11-23T00:20:21Z

fmt, langlinks.

← Older revision Revision as of 00:20, 23 November 2021
Line 1: Line 1:

{{cpp/title|indirect_strict_weak_order}}
{{cpp/title|indirect_strict_weak_order}}

{{cpp/iterator/navbar}}
{{cpp/iterator/navbar}}

{{~~dcl begin}}~~
{{ddcl | header=iterator | since=c++20 | 1=

~~{{dcl~~ header | iterator}}
template< class F, class I1, class I2 = I1 >

~~{{dcl~~ | since=c++20 | 1=

template<class F, class I1, class I2 = I1>

concept indirect_strict_weak_order =
concept indirect_strict_weak_order =

 std::indirectly_readable<I1> &&
 std::indirectly_readable<I1> &&

Line 15: Line 13:

 std::strict_weak_order<F&, std::iter_common_reference_t<I1>, std::iter_common_reference_t<I2>>;
 std::strict_weak_order<F&, std::iter_common_reference_t<I1>, std::iter_common_reference_t<I2>>;

}}
}}

~~{{dcl end}}~~

The concept {{tt|indirect_strict_weak_order}} specifies requirements for algorithms that call strict weak orders as their arguments. The key difference between this concept and {{lc|std::strict_weak_order}} is that it is applied to the types that {{tt|I1}} and {{tt|I2}} references, rather than {{tt|I1}} and {{tt|I2}} themselves.
The concept {{tt|indirect_strict_weak_order}} specifies requirements for algorithms that call strict weak orders as their arguments. The key difference between this concept and {{lc|std::strict_weak_order}} is that it is applied to the types that {{tt|I1}} and {{tt|I2}} references, rather than {{tt|I1}} and {{tt|I2}} themselves.

Line 22: Line 19:

{{tt|F}}, {{tt|I1}}, and {{tt|I2}} model {{tt|indirect_strict_weak_order}} only if all concepts it subsumes are modeled.
{{tt|F}}, {{tt|I1}}, and {{tt|I2}} model {{tt|indirect_strict_weak_order}} only if all concepts it subsumes are modeled.

{{langlinks|es|ja|zh}}
{{langlinks|de|es|fr|it|ja|pt|ru|zh}}

Fruderica: lc

2020-07-29T15:53:17Z

lc

← Older revision Revision as of 15:53, 29 July 2020
Line 17: Line 17:

{{dcl end}}
{{dcl end}}

The concept {{tt|indirect_strict_weak_order}} specifies requirements for algorithms that call strict weak orders as their arguments. The key difference between this concept and {{tt|std::strict_weak_order}} is that it is applied to the types that {{tt|I1}} and {{tt|I2}} references, rather than {{tt|I1}} and {{tt|I2}} themselves.
The concept {{tt|indirect_strict_weak_order}} specifies requirements for algorithms that call strict weak orders as their arguments. The key difference between this concept and {{lc|std::strict_weak_order}} is that it is applied to the types that {{tt|I1}} and {{tt|I2}} references, rather than {{tt|I1}} and {{tt|I2}} themselves.

===Semantic requirements===
===Semantic requirements===

Cjdb: removes equality preservation since it's not a direct requirement for this concept

2020-07-02T16:54:51Z

removes equality preservation since it's not a direct requirement for this concept

← Older revision Revision as of 16:54, 2 July 2020
Line 21: Line 21:

===Semantic requirements===
===Semantic requirements===

{{tt|F}}, {{tt|I1}}, and {{tt|I2}} model {{tt|indirect_strict_weak_order}} only if all concepts it subsumes are modeled.
{{tt|F}}, {{tt|I1}}, and {{tt|I2}} model {{tt|indirect_strict_weak_order}} only if all concepts it subsumes are modeled.

~~{{cpp/concepts/equality preservation}}~~

{{langlinks|es|ja|zh}}
{{langlinks|es|ja|zh}}

Cjdb: Created page with "{{cpp/title|indirect_strict_weak_order}} {{cpp/iterator/navbar}} {{dcl begin}} {{dcl header | iterator}} {{dcl | since=c++20 | 1= template co..."

2020-07-02T06:40:26Z

Created page with "{{cpp/title|indirect_strict_weak_order}} {{cpp/iterator/navbar}} {{dcl begin}} {{dcl header | iterator}} {{dcl | since=c++20 | 1= template<class F, class I1, class I2 = I1> co..."

New page
{{cpp/title|indirect_strict_weak_order}}
{{cpp/iterator/navbar}}
{{dcl begin}}
{{dcl header | iterator}}
{{dcl | since=c++20 | 1=
template<class F, class I1, class I2 = I1>
concept indirect_strict_weak_order =
std::indirectly_readable<I1> &&
std::indirectly_readable<I2> &&
std::copy_constructible<F> &&
std::strict_weak_order<F&, std::iter_value_t<I1>&, std::iter_value_t<I2>&> &&
std::strict_weak_order<F&, std::iter_value_t<I1>&, std::iter_reference_t<I2>> &&
std::strict_weak_order<F&, std::iter_reference_t<I1>, std::iter_value_t<I2>&> &&
std::strict_weak_order<F&, std::iter_reference_t<I1>, std::iter_reference_t<I2>> &&
std::strict_weak_order<F&, std::iter_common_reference_t<I1>, std::iter_common_reference_t<I2>>;
}}
{{dcl end}}

The concept {{tt|indirect_strict_weak_order}} specifies requirements for algorithms that call strict weak orders as their arguments. The key difference between this concept and {{tt|std::strict_weak_order}} is that it is applied to the types that {{tt|I1}} and {{tt|I2}} references, rather than {{tt|I1}} and {{tt|I2}} themselves.

===Semantic requirements===
{{tt|F}}, {{tt|I1}}, and {{tt|I2}} model {{tt|indirect_strict_weak_order}} only if all concepts it subsumes are modeled.

{{cpp/concepts/equality preservation}}

{{langlinks|es|ja|zh}}

← Older revision		Revision as of 15:56, 23 August 2024
Line 10:		Line 10:
	std::indirectly_readable<I2> &&		std::indirectly_readable<I2> &&
	std::copy_constructible<F> &&		std::copy_constructible<F> &&
	std::strict_weak_order<F&, ~~std::iter_value_t~~<I1>&, ~~std::iter_value_t~~<I2>&> &&		std::strict_weak_order<F&, /indirect-value-t/<I1>, /indirect-value-t/<I2>> &&
	std::strict_weak_order		std::strict_weak_order
	<F&, ~~std::iter_value_t~~<I1>&, std::iter_reference_t<I2>> &&		<F&, /indirect-value-t/<I1>, std::iter_reference_t<I2>> &&
	std::strict_weak_order		std::strict_weak_order
	<F&, std::iter_reference_t<I1>, ~~std::iter_value_t~~<I2>&> &&		<F&, std::iter_reference_t<I1>, /indirect-value-t/<I2>> &&
	std::strict_weak_order		std::strict_weak_order
	<F&, std::iter_reference_t<I1>, std::iter_reference_t<I2>> &&		<F&, std::iter_reference_t<I1>, std::iter_reference_t<I2>> &&
Line 26:		Line 26:
	std::indirectly_readable<I2> &&		std::indirectly_readable<I2> &&
	std::copy_constructible<F> &&		std::copy_constructible<F> &&
	std::strict_weak_order<F&, ~~std::iter_value_t~~<I1>&, ~~std::iter_value_t~~<I2>&> &&		std::strict_weak_order<F&, /indirect-value-t/<I1>, /indirect-value-t/<I2>> &&
	std::strict_weak_order		std::strict_weak_order
	<F&, ~~std::iter_value_t~~<I1>&, std::iter_reference_t<I2>> &&		<F&, /indirect-value-t/<I1>, std::iter_reference_t<I2>> &&
	std::strict_weak_order		std::strict_weak_order
	<F&, std::iter_reference_t<I1>, ~~std::iter_value_t~~<I2>&> &&		<F&, std::iter_reference_t<I1>, /indirect-value-t/<I2>> &&
	std::strict_weak_order		std::strict_weak_order
	<F&, std::iter_reference_t<I1>, std::iter_reference_t<I2>>;		<F&, std::iter_reference_t<I1>, std::iter_reference_t<I2>>;
Line 38:		Line 38:

	The concept {{tt\|indirect_strict_weak_order}} specifies requirements for algorithms that call strict weak orders as their arguments. The key difference between this concept and {{lc\|std::strict_weak_order}} is that it is applied to the types that {{tt\|I1}} and {{tt\|I2}} references, rather than {{tt\|I1}} and {{tt\|I2}} themselves.		The concept {{tt\|indirect_strict_weak_order}} specifies requirements for algorithms that call strict weak orders as their arguments. The key difference between this concept and {{lc\|std::strict_weak_order}} is that it is applied to the types that {{tt\|I1}} and {{tt\|I2}} references, rather than {{tt\|I1}} and {{tt\|I2}} themselves.

			===Defect reports===
			{{dr list begin}}
			{{dr list item\|paper=P2609R3\|std=C++20\|before=some requirements were defined in terms of {{c\|std::iter_value_t<I>&}}<br>which mishandled projections resulting in incompatibility with strict weak order {{c\|F&}}\|after=defined in terms of {{c\|/indirect-value-t/<I>}}<br>to correctly handle such projections}}
			{{dr list end}}

	{{langlinks\|de\|es\|fr\|it\|ja\|pt\|ru\|zh}}		{{langlinks\|de\|es\|fr\|it\|ja\|pt\|ru\|zh}}

← Older revision		Revision as of 07:02, 24 July 2024
Line 1:		Line 1:
	{{cpp/title\|indirect_strict_weak_order}}		{{cpp/title\|indirect_strict_weak_order}}
	{{cpp/iterator/navbar}}		{{cpp/iterator/navbar}}
	{{~~ddcl~~\|~~header=~~iterator\|since=c++20\|1=		{{dcl begin}}
			{{dcl header\|iterator}}
			{{dcl rev begin}}
			{{dcl\|since=c++20\|until=c++26\|1=
	template< class F, class I1, class I2 = I1 >		template< class F, class I1, class I2 = I1 >
	concept indirect_strict_weak_order =		concept indirect_strict_weak_order =
Line 8:		Line 11:
	std::copy_constructible<F> &&		std::copy_constructible<F> &&
	std::strict_weak_order<F&, std::iter_value_t<I1>&, std::iter_value_t<I2>&> &&		std::strict_weak_order<F&, std::iter_value_t<I1>&, std::iter_value_t<I2>&> &&
	std::strict_weak_order<F&, std::iter_value_t<I1>&, std::iter_reference_t<I2>> &&		std::strict_weak_order
	std::strict_weak_order<F&, std::iter_reference_t<I1>, std::iter_value_t<I2>&> &&		<F&, std::iter_value_t<I1>&, std::iter_reference_t<I2>> &&
	std::strict_weak_order<F&, std::iter_reference_t<I1>, std::iter_reference_t<I2>> &&		std::strict_weak_order
	std::strict_weak_order<F&, std::iter_common_reference_t<I1>,		<F&, std::iter_reference_t<I1>, std::iter_value_t<I2>&> &&
	std::iter_common_reference_t<I2>>;		std::strict_weak_order
			<F&, std::iter_reference_t<I1>, std::iter_reference_t<I2>> &&
			std::strict_weak_order
			<F&, std::iter_common_reference_t<I1>, std::iter_common_reference_t<I2>>;
	}}		}}
			{{dcl\|since=c++26\|1=
			template< class F, class I1, class I2 = I1 >
			concept indirect_strict_weak_order =
			std::indirectly_readable<I1> &&
			std::indirectly_readable<I2> &&
			std::copy_constructible<F> &&
			std::strict_weak_order<F&, std::iter_value_t<I1>&, std::iter_value_t<I2>&> &&
			std::strict_weak_order
			<F&, std::iter_value_t<I1>&, std::iter_reference_t<I2>> &&
			std::strict_weak_order
			<F&, std::iter_reference_t<I1>, std::iter_value_t<I2>&> &&
			std::strict_weak_order
			<F&, std::iter_reference_t<I1>, std::iter_reference_t<I2>>;
			}}
			{{dcl rev end}}
			{{dcl end}}

	The concept {{tt\|indirect_strict_weak_order}} specifies requirements for algorithms that call strict weak orders as their arguments. The key difference between this concept and {{lc\|std::strict_weak_order}} is that it is applied to the types that {{tt\|I1}} and {{tt\|I2}} references, rather than {{tt\|I1}} and {{tt\|I2}} themselves.		The concept {{tt\|indirect_strict_weak_order}} specifies requirements for algorithms that call strict weak orders as their arguments. The key difference between this concept and {{lc\|std::strict_weak_order}} is that it is applied to the types that {{tt\|I1}} and {{tt\|I2}} references, rather than {{tt\|I1}} and {{tt\|I2}} themselves.

	~~===Semantic requirements===~~
	~~{{tt\|F}}, {{tt\|I1}}, and {{tt\|I2}} model {{tt\|indirect_strict_weak_order}} only if all concepts it subsumes are modeled.~~

	{{langlinks\|de\|es\|fr\|it\|ja\|pt\|ru\|zh}}		{{langlinks\|de\|es\|fr\|it\|ja\|pt\|ru\|zh}}

← Older revision		Revision as of 19:03, 3 October 2023
Line 11:		Line 11:
	std::strict_weak_order<F&, std::iter_reference_t<I1>, std::iter_value_t<I2>&> &&		std::strict_weak_order<F&, std::iter_reference_t<I1>, std::iter_value_t<I2>&> &&
	std::strict_weak_order<F&, std::iter_reference_t<I1>, std::iter_reference_t<I2>> &&		std::strict_weak_order<F&, std::iter_reference_t<I1>, std::iter_reference_t<I2>> &&
	std::strict_weak_order<F&, std::iter_common_reference_t<I1>, std::iter_common_reference_t<I2>>;		std::strict_weak_order<F&, std::iter_common_reference_t<I1>,
			std::iter_common_reference_t<I2>>;
	}}		}}

← Older revision		Revision as of 06:11, 1 October 2023
Line 1:		Line 1:
	{{cpp/title\|indirect_strict_weak_order}}		{{cpp/title\|indirect_strict_weak_order}}
	{{cpp/iterator/navbar}}		{{cpp/iterator/navbar}}
	{{ddcl \| header=iterator \| since=c++20 \| 1=		{{ddcl\|header=iterator\|since=c++20\|1=
	template< class F, class I1, class I2 = I1 >		template< class F, class I1, class I2 = I1 >
	concept indirect_strict_weak_order =		concept indirect_strict_weak_order =
	std::indirectly_readable<I1> &&		std::indirectly_readable<I1> &&
	std::indirectly_readable<I2> &&		std::indirectly_readable<I2> &&
	std::copy_constructible<F> &&		std::copy_constructible<F> &&
	std::strict_weak_order<F&, std::iter_value_t<I1>&, std::iter_value_t<I2>&> &&		std::strict_weak_order<F&, std::iter_value_t<I1>&, std::iter_value_t<I2>&> &&
	std::strict_weak_order<F&, std::iter_value_t<I1>&, std::iter_reference_t<I2>> &&		std::strict_weak_order<F&, std::iter_value_t<I1>&, std::iter_reference_t<I2>> &&
	std::strict_weak_order<F&, std::iter_reference_t<I1>, std::iter_value_t<I2>&> &&		std::strict_weak_order<F&, std::iter_reference_t<I1>, std::iter_value_t<I2>&> &&
	std::strict_weak_order<F&, std::iter_reference_t<I1>, std::iter_reference_t<I2>> &&		std::strict_weak_order<F&, std::iter_reference_t<I1>, std::iter_reference_t<I2>> &&
	std::strict_weak_order<F&, std::iter_common_reference_t<I1>, std::iter_common_reference_t<I2>>;		std::strict_weak_order<F&, std::iter_common_reference_t<I1>, std::iter_common_reference_t<I2>>;
	}}		}}

← Older revision		Revision as of 00:20, 23 November 2021
Line 1:		Line 1:
	{{cpp/title\|indirect_strict_weak_order}}		{{cpp/title\|indirect_strict_weak_order}}
	{{cpp/iterator/navbar}}		{{cpp/iterator/navbar}}
	{{~~dcl begin}}~~		{{ddcl \| header=iterator \| since=c++20 \| 1=
	~~{{dcl~~ header \| iterator}}		template< class F, class I1, class I2 = I1 >
	~~{{dcl~~ \| since=c++20 \| 1=
	template<class F, class I1, class I2 = I1>
	concept indirect_strict_weak_order =		concept indirect_strict_weak_order =
	std::indirectly_readable<I1> &&		std::indirectly_readable<I1> &&
Line 15:		Line 13:
	std::strict_weak_order<F&, std::iter_common_reference_t<I1>, std::iter_common_reference_t<I2>>;		std::strict_weak_order<F&, std::iter_common_reference_t<I1>, std::iter_common_reference_t<I2>>;
	}}		}}
	~~{{dcl end}}~~

	The concept {{tt\|indirect_strict_weak_order}} specifies requirements for algorithms that call strict weak orders as their arguments. The key difference between this concept and {{lc\|std::strict_weak_order}} is that it is applied to the types that {{tt\|I1}} and {{tt\|I2}} references, rather than {{tt\|I1}} and {{tt\|I2}} themselves.		The concept {{tt\|indirect_strict_weak_order}} specifies requirements for algorithms that call strict weak orders as their arguments. The key difference between this concept and {{lc\|std::strict_weak_order}} is that it is applied to the types that {{tt\|I1}} and {{tt\|I2}} references, rather than {{tt\|I1}} and {{tt\|I2}} themselves.
Line 22:		Line 19:
	{{tt\|F}}, {{tt\|I1}}, and {{tt\|I2}} model {{tt\|indirect_strict_weak_order}} only if all concepts it subsumes are modeled.		{{tt\|F}}, {{tt\|I1}}, and {{tt\|I2}} model {{tt\|indirect_strict_weak_order}} only if all concepts it subsumes are modeled.

	{{langlinks\|es\|ja\|zh}}		{{langlinks\|de\|es\|fr\|it\|ja\|pt\|ru\|zh}}

← Older revision		Revision as of 15:53, 29 July 2020
Line 17:		Line 17:
	{{dcl end}}		{{dcl end}}

	The concept {{tt\|indirect_strict_weak_order}} specifies requirements for algorithms that call strict weak orders as their arguments. The key difference between this concept and {{tt\|std::strict_weak_order}} is that it is applied to the types that {{tt\|I1}} and {{tt\|I2}} references, rather than {{tt\|I1}} and {{tt\|I2}} themselves.		The concept {{tt\|indirect_strict_weak_order}} specifies requirements for algorithms that call strict weak orders as their arguments. The key difference between this concept and {{lc\|std::strict_weak_order}} is that it is applied to the types that {{tt\|I1}} and {{tt\|I2}} references, rather than {{tt\|I1}} and {{tt\|I2}} themselves.

	===Semantic requirements===		===Semantic requirements===

← Older revision		Revision as of 16:54, 2 July 2020
Line 21:		Line 21:
	===Semantic requirements===		===Semantic requirements===
	{{tt\|F}}, {{tt\|I1}}, and {{tt\|I2}} model {{tt\|indirect_strict_weak_order}} only if all concepts it subsumes are modeled.		{{tt\|F}}, {{tt\|I1}}, and {{tt\|I2}} model {{tt\|indirect_strict_weak_order}} only if all concepts it subsumes are modeled.

	~~{{cpp/concepts/equality preservation}}~~

	{{langlinks\|es\|ja\|zh}}		{{langlinks\|es\|ja\|zh}}