libcxx/include/concepts

   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
  15 namespace 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