1// -*- C++ -*-
2//===----------------------------------------------------------------------===//
3//
4// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
5// See https://llvm.org/LICENSE.txt for license information.
6// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7//
8//===----------------------------------------------------------------------===//
9
10#ifndef _LIBCPP_CONCEPTS
11#define _LIBCPP_CONCEPTS
12
13/*
14    concepts synopsis
15namespace std {
16  // [concepts.lang], language-related concepts
17  // [concept.same], concept same_as
18  template<class T, class U>
19    concept same_as = see below;
20
21  // [concept.derived], concept derived_from
22  template<class Derived, class Base>
23    concept derived_from = see below;
24
25  // [concept.convertible], concept convertible_to
26  template<class From, class To>
27    concept convertible_to = see below;
28
29  // [concept.commonref], concept common_reference_with
30  template<class T, class U>
31    concept common_reference_with = see below;
32
33  // [concept.common], concept common_with
34  template<class T, class U>
35    concept common_with = see below;
36
37  // [concepts.arithmetic], arithmetic concepts
38  template<class T>
39    concept integral = see below;
40  template<class T>
41    concept signed_integral = see below;
42  template<class T>
43    concept unsigned_integral = see below;
44  template<class T>
45    concept floating_point = see below;
46
47  // [concept.assignable], concept assignable_from
48  template<class LHS, class RHS>
49    concept assignable_from = see below;
50
51  // [concept.swappable], concept swappable
52  namespace ranges {
53    inline namespace unspecified {
54      inline constexpr unspecified swap = unspecified;
55    }
56  }
57  template<class T>
58    concept swappable = see below;
59  template<class T, class U>
60    concept swappable_with = see below;
61
62  // [concept.destructible], concept destructible
63  template<class T>
64    concept destructible = see below;
65
66  // [concept.constructible], concept constructible_from
67  template<class T, class... Args>
68    concept constructible_from = see below;
69
70  // [concept.default.init], concept default_initializable
71  template<class T>
72    concept default_initializable = see below;
73
74  // [concept.moveconstructible], concept move_constructible
75  template<class T>
76    concept move_constructible = see below;
77
78  // [concept.copyconstructible], concept copy_constructible
79  template<class T>
80    concept copy_constructible = see below;
81
82  // [concept.equalitycomparable], concept equality_comparable
83  template<class T>
84    concept equality_comparable = see below;
85  template<class T, class U>
86    concept equality_comparable_with = see below;
87
88  // [concept.totallyordered], concept totally_ordered
89  template<class T>
90    concept totally_ordered = see below;
91  template<class T, class U>
92    concept totally_ordered_with = see below;
93
94  // [concepts.object], object concepts
95  template<class T>
96    concept movable = see below;
97  template<class T>
98    concept copyable = see below;
99  template<class T>
100    concept semiregular = see below;
101  template<class T>
102    concept regular = see below;
103
104  // [concepts.callable], callable concepts
105  // [concept.invocable], concept invocable
106  template<class F, class... Args>
107    concept invocable = see below;
108
109  // [concept.regularinvocable], concept regular_invocable
110  template<class F, class... Args>
111    concept regular_invocable = see below;
112
113  // [concept.predicate], concept predicate
114  template<class F, class... Args>
115    concept predicate = see below;
116
117  // [concept.relation], concept relation
118  template<class R, class T, class U>
119    concept relation = see below;
120
121  // [concept.equiv], concept equivalence_relation
122  template<class R, class T, class U>
123    concept equivalence_relation = see below;
124
125  // [concept.strictweakorder], concept strict_weak_order
126  template<class R, class T, class U>
127    concept strict_weak_order = see below;
128}
129
130*/
131
132#include <__assert> // all public C++ headers provide the assertion handler
133#include <__concepts/arithmetic.h>
134#include <__concepts/assignable.h>
135#include <__concepts/boolean_testable.h>
136#include <__concepts/class_or_enum.h>
137#include <__concepts/common_reference_with.h>
138#include <__concepts/common_with.h>
139#include <__concepts/constructible.h>
140#include <__concepts/convertible_to.h>
141#include <__concepts/copyable.h>
142#include <__concepts/derived_from.h>
143#include <__concepts/destructible.h>
144#include <__concepts/different_from.h>
145#include <__concepts/equality_comparable.h>
146#include <__concepts/invocable.h>
147#include <__concepts/movable.h>
148#include <__concepts/predicate.h>
149#include <__concepts/regular.h>
150#include <__concepts/relation.h>
151#include <__concepts/same_as.h>
152#include <__concepts/semiregular.h>
153#include <__concepts/swappable.h>
154#include <__concepts/totally_ordered.h>
155#include <__config>
156#include <version>
157
158#if _LIBCPP_STD_VER <= 20 && !defined(_LIPCPP_REMOVE_TRANSITIVE_INCLUDES)
159#  include <type_traits>
160#endif
161
162#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
163#  pragma GCC system_header
164#endif
165
166#endif // _LIBCPP_CONCEPTS
167