chore: clang-format

include/iterator/capture_iterator.h

@@ -31,17 +31,23 @@ public:
 
   value_type const & dereference() const { return cache_; }
 
-  void increment() requires(forward<super_t>) {
+  void increment()
+    requires(forward<super_t>)
+  {
     super_t::increment();
     cache_ = super_t::dereference();
   }
 
-  void decrement() requires(bidirectional<super_t>) {
+  void decrement()
+    requires(bidirectional<super_t>)
+  {
     super_t::decrement();
     cache_ = super_t::dereference();
   }
 
-  void advance(difference_type off) requires(random_access<super_t>) {
+  void advance(difference_type off)
+    requires(random_access<super_t>)
+  {
     super_t::advance(off);
     cache_ = super_t::dereference();
   }

include/iterator/concepts.h

@@ -14,7 +14,7 @@
 
 namespace iterator {
 template <typename It>
-concept implements_distance_to = requires(It const &it) {
+concept implements_distance_to = requires(It const & it) {
   { it.distance_to(it) } -> std::integral;
 };
 
@@ -22,9 +22,8 @@ template <typename> struct infer_difference_type {
   using type = std::ptrdiff_t;
 };
 
-template <implements_distance_to It>
-struct infer_difference_type<It> {
-  static const It& _it;
+template <implements_distance_to It> struct infer_difference_type<It> {
+  static const It & _it;
   using type = decltype(_it.distance_to(_it));
 };
 
@@ -32,11 +31,11 @@ template <typename It>
 using infer_difference_type_t = typename infer_difference_type<It>::type;
 
 template <typename D, typename It>
-concept difference_type_arg = std::convertible_to<D, infer_difference_type_t<It>>;
+concept difference_type_arg =
+    std::convertible_to<D, infer_difference_type_t<It>>;
 
-template <typename It>
-struct infer_value_type {
-  static const It& _it;
+template <typename It> struct infer_value_type {
+  static const It & _it;
   using type = std::remove_cvref_t<decltype(*_it)>;
 };
 
@@ -46,19 +45,19 @@ struct infer_value_type<It> {
   using type = typename It::value_type;
 };
 
-template <typename It>
-using infer_value_type_t = infer_value_type<It>::type;
+template <typename It> using infer_value_type_t = infer_value_type<It>::type;
 
-template <typename T, typename U> concept not_same_as = not std::same_as<T, U>;
+template <typename T, typename U>
+concept not_same_as = not std::same_as<T, U>;
 
 template <typename It>
-concept has_sentinel = requires(It const &it) {
+concept has_sentinel = requires(It const & it) {
   typename It::sentinel_type;
   { it.at_end() } -> std::same_as<bool>;
 };
 
 template <typename It, typename S>
-concept sentinel_for = has_sentinel<It> && requires(It const &it, S s) {
+concept sentinel_for = has_sentinel<It> && requires(It const & it, S s) {
   { s - it } -> std::integral;
 };
 
@@ -66,38 +65,45 @@ template <typename It>
 concept single_pass = bool(It::single_pass_iterator);
 
 template <typename It>
-concept forward = requires(It &it) {
+concept forward = requires(It & it) {
   { it.dereference() } -> not_same_as<void>;
   { it.equal_to(it) } -> std::same_as<bool>;
   { it.increment() } -> std::same_as<void>;
 };
 
 template <typename It>
-concept bidirectional = forward<It> && requires(It &it) {
+concept bidirectional = forward<It> && requires(It & it) {
   { it.decrement() } -> std::same_as<void>;
 };
 
 template <typename It>
-concept random_access = requires(It &it, infer_difference_type_t<It> offset) {
+concept random_access = requires(It & it, infer_difference_type_t<It> offset) {
   { it.dereference() } -> not_same_as<void>;
   { it.equal_to(it) } -> std::same_as<bool>;
   { it.advance(offset) } -> std::same_as<void>;
 };
 
-template <typename C> concept Char = std::same_as<C, char> || std::same_as<C, wchar_t> || std::same_as<C, char16_t> || std::same_as<C, char32_t> || std::same_as<C, char8_t>;
+template <typename C>
+concept Char = std::same_as<C, char> || std::same_as<C, wchar_t> ||
+               std::same_as<C, char16_t> || std::same_as<C, char32_t> ||
+               std::same_as<C, char8_t>;
 
-template <typename S> concept LegacyString = requires(S const &t) {
+template <typename S>
+concept LegacyString = requires(S const & t) {
   { t.c_str() };
 };
 
-template <typename S> concept StringViewCompat = Char<typename S::value_type> && requires(S const &t) {
-  { std::basic_string_view{t} };
-};
+template <typename S>
+concept StringViewCompat =
+    Char<typename S::value_type> && requires(S const & t) {
+      { std::basic_string_view{t} };
+    };
 
-template <typename S> concept String = LegacyString<S> || StringViewCompat<S>;
+template <typename S>
+concept String = LegacyString<S> || StringViewCompat<S>;
 
 template <typename C>
 concept Range = (not String<C>) && std::ranges::range<C>;
 template <typename C>
-using iterator_t = decltype(std::begin(std::declval<C&>()));
+using iterator_t = decltype(std::begin(std::declval<C &>()));
 }

include/iterator/detail/recursive_traits.h

@@ -9,9 +9,17 @@ enum class recursion_type { END, THRU, ASSOC };
 // Helpers for condensing type deductions
 template <typename It> using value = decltype(std::begin(*std::declval<It>()));
 
-template <typename V> concept associative_value = std::is_const_v<typename V::first_type>;
-template <typename V> concept recursive_associative = associative_value<V> && Range<typename V::second_type>;
+template <typename V>
+concept associative_value = std::is_const_v<typename V::first_type>;
+template <typename V>
+concept recursive_associative =
+    associative_value<V> && Range<typename V::second_type>;
 
-template <typename V> constexpr auto typeclass = recursive_associative<V> ? recursion_type::ASSOC : (Range<V> ? recursion_type::THRU : recursion_type::END);
-template <typename It> constexpr auto iter_typeclass = typeclass<std::iter_value_t<It>>;
+template <typename V>
+constexpr auto typeclass =
+    recursive_associative<V>
+        ? recursion_type::ASSOC
+        : (Range<V> ? recursion_type::THRU : recursion_type::END);
+template <typename It>
+constexpr auto iter_typeclass = typeclass<std::iter_value_t<It>>;
 }

include/iterator/end_aware_iterator.h

@@ -44,8 +44,10 @@ public:
       return super_t::impl() == end_;
     }
   }
-  
-  friend auto operator-(sentinel_type, end_aware_iterator const &self) requires(std::random_access_iterator<It>) {
+
+  friend auto operator-(sentinel_type, end_aware_iterator const & self)
+    requires(std::random_access_iterator<It>)
+  {
     return self.end() - self.impl();
   }
 

include/iterator/facade.h

@@ -25,8 +25,8 @@ public:
     }
   }
 
-  template <typename D> requires (difference_type_arg<D, self_type> &&
-                                  random_access<self_type>)
+  template <typename D>
+    requires(difference_type_arg<D, self_type> && random_access<self_type>)
   decltype(auto) operator[](D off) const {
     return *(self() + off);
   }
@@ -35,7 +35,8 @@ public:
     if constexpr (forward<self_type>) {
       self().increment();
     } else {
-      static_assert(random_access<self_type>, "requires .increment() or .advance()");
+      static_assert(random_access<self_type>,
+                    "requires .increment() or .advance()");
       self() += 1;
     }
     return self();
@@ -55,7 +56,8 @@ public:
     if constexpr (bidirectional<self_type>) {
       self().decrement();
     } else {
-      static_assert(random_access<self_type>, "requires .decrement() or .advance()");
+      static_assert(random_access<self_type>,
+                    "requires .decrement() or .advance()");
       self() -= 1;
     }
     return self();
@@ -67,39 +69,41 @@ public:
     return tmp;
   }
 
-  template <typename D> requires (difference_type_arg<D, self_type> &&
-                                  random_access<self_type>)
+  template <typename D>
+    requires(difference_type_arg<D, self_type> && random_access<self_type>)
   friend self_type & operator+=(self_type & self, D off) {
     self.advance(off);
     return self;
   }
 
-  template <typename D> requires (difference_type_arg<D, self_type> &&
-                                  random_access<self_type>)
+  template <typename D>
+    requires(difference_type_arg<D, self_type> && random_access<self_type>)
   friend self_type & operator-=(self_type & self, D off) {
     self.advance(-off);
     return self;
   }
 
-  template <typename D> requires (difference_type_arg<D, self_type> &&
-                                  random_access<self_type>)
+  template <typename D>
+    requires(difference_type_arg<D, self_type> && random_access<self_type>)
   friend auto operator+(self_type self, D off) {
     return self += off;
   }
 
-  template <typename D> requires (difference_type_arg<D, self_type> &&
-                                  random_access<self_type>)
+  template <typename D>
+    requires(difference_type_arg<D, self_type> && random_access<self_type>)
   friend auto operator+(D off, self_type self) {
     return self += off;
   }
 
-  template <typename D> requires (difference_type_arg<D, self_type> &&
-                                  random_access<self_type>)
+  template <typename D>
+    requires(difference_type_arg<D, self_type> && random_access<self_type>)
   friend auto operator-(self_type self, D off) {
     return self -= off;
   }
 
-  friend auto operator-(self_type const & left, self_type const & right) requires(random_access<self_type>) {
+  friend auto operator-(self_type const & left, self_type const & right)
+    requires(random_access<self_type>)
+  {
     return right.distance_to(left);
   }
 
@@ -107,7 +111,9 @@ public:
     return left.equal_to(right);
   }
 
-  friend auto operator<=>(self_type const & left, self_type const & right) requires(random_access<self_type>) {
+  friend auto operator<=>(self_type const & left, self_type const & right)
+    requires(random_access<self_type>)
+  {
     return (left - right) <=> 0;
   }
 
@@ -123,58 +129,56 @@ protected:
 // macros.
 #define MAKE_ITERATOR_FACADE_TYPEDEFS_T(Iter)
 
-template <typename It> requires std::is_base_of_v<iterator::facade<It>, It>
+template <typename It>
+  requires std::is_base_of_v<iterator::facade<It>, It>
 struct std::iterator_traits<It> {
-  static const It& _it;
+  static const It & _it;
   using reference = decltype(*_it);
   using pointer = decltype(_it.operator->());
   using value_type = ::iterator::infer_value_type_t<It>;
   using difference_type = ::iterator::infer_difference_type_t<It>;
   using iterator_category = std::conditional_t<
-    ::iterator::random_access<It>,
-    random_access_iterator_tag,
-    std::conditional_t<
-      ::iterator::bidirectional<It>,
-      bidirectional_iterator_tag,
-      std::conditional_t<::iterator::single_pass<It>, input_iterator_tag, forward_iterator_tag>
-    >
-  >;
+      ::iterator::random_access<It>, random_access_iterator_tag,
+      std::conditional_t<
+          ::iterator::bidirectional<It>, bidirectional_iterator_tag,
+          std::conditional_t<::iterator::single_pass<It>, input_iterator_tag,
+                             forward_iterator_tag>>>;
 };
 
-//template <typename It> requires(std::derived_from<It, iterator::facade<It, iterator::category::single_pass>>)
-//struct std::iterator_traits<It> {
-//  using reference = decltype(std::declval<It>().operator*());
-//  using value_type = std::decay_t<reference>;
-//  using pointer = decltype(std::declval<It>().operator->());
-//  using difference_type = ::iterator::infer_difference_type_t<It>;
-//  using iterator_category = std::input_iterator_tag;
-//};
+// template <typename It> requires(std::derived_from<It, iterator::facade<It,
+// iterator::category::single_pass>>) struct std::iterator_traits<It> {
+//   using reference = decltype(std::declval<It>().operator*());
+//   using value_type = std::decay_t<reference>;
+//   using pointer = decltype(std::declval<It>().operator->());
+//   using difference_type = ::iterator::infer_difference_type_t<It>;
+//   using iterator_category = std::input_iterator_tag;
+// };
 //
-//template <typename It> requires(std::derived_from<It, iterator::facade<It, iterator::category::forward>>)
-//struct std::iterator_traits<It> {
-//  using reference = decltype(std::declval<It>().operator*());
-//  using value_type = std::decay_t<reference>;
-//  using pointer = decltype(std::declval<It>().operator->());
-//  using difference_type = ::iterator::infer_difference_type_t<It>;
-//  using iterator_category = std::forward_iterator_tag;
-//};
+// template <typename It> requires(std::derived_from<It, iterator::facade<It,
+// iterator::category::forward>>) struct std::iterator_traits<It> {
+//   using reference = decltype(std::declval<It>().operator*());
+//   using value_type = std::decay_t<reference>;
+//   using pointer = decltype(std::declval<It>().operator->());
+//   using difference_type = ::iterator::infer_difference_type_t<It>;
+//   using iterator_category = std::forward_iterator_tag;
+// };
 //
-//template <typename It> requires(std::derived_from<It, iterator::facade<It, iterator::category::bidirectional>>)
-//struct std::iterator_traits<It> {
-//  using reference = decltype(std::declval<It>().operator*());
-//  using value_type = std::decay_t<reference>;
-//  using pointer = decltype(std::declval<It>().operator->());
-//  using difference_type = ::iterator::infer_difference_type_t<It>;
-//  using iterator_category = std::bidirectional_iterator_tag;
-//};
+// template <typename It> requires(std::derived_from<It, iterator::facade<It,
+// iterator::category::bidirectional>>) struct std::iterator_traits<It> {
+//   using reference = decltype(std::declval<It>().operator*());
+//   using value_type = std::decay_t<reference>;
+//   using pointer = decltype(std::declval<It>().operator->());
+//   using difference_type = ::iterator::infer_difference_type_t<It>;
+//   using iterator_category = std::bidirectional_iterator_tag;
+// };
 //
-//template <typename It> requires(std::derived_from<It, iterator::facade<It, iterator::category::random_access>>)
-//struct std::iterator_traits<It> {
-//  using reference = decltype(std::declval<It>().operator*());
-//  using value_type = std::decay_t<reference>;
-//  using pointer = decltype(std::declval<It>().operator->());
-//  using difference_type = ::iterator::infer_difference_type_t<It>;
-//  using iterator_category = std::random_access_iterator_tag;
-//};
+// template <typename It> requires(std::derived_from<It, iterator::facade<It,
+// iterator::category::random_access>>) struct std::iterator_traits<It> {
+//   using reference = decltype(std::declval<It>().operator*());
+//   using value_type = std::decay_t<reference>;
+//   using pointer = decltype(std::declval<It>().operator->());
+//   using difference_type = ::iterator::infer_difference_type_t<It>;
+//   using iterator_category = std::random_access_iterator_tag;
+// };
 
 #include <iterator/detail/undef.h>

include/iterator/filter_iterator.h

@@ -17,8 +17,7 @@
 
 namespace iterator {
 template <typename Iter, typename Pred>
-class filter_iterator
-    : public facade<filter_iterator<Iter, Pred>> {
+class filter_iterator : public facade<filter_iterator<Iter, Pred>> {
 public:
   using sentinel_type = sentinel_t;
   using super_t = filter_iterator::facade;
@@ -49,7 +48,9 @@ public:
     } while (should_advance());
   }
 
-  void decrement() requires(std::bidirectional_iterator<Iter>) {
+  void decrement()
+    requires(std::bidirectional_iterator<Iter>)
+  {
     do {
       --base_;
     } while (should_advance());

include/iterator/forwards.h

@@ -34,8 +34,7 @@ template <typename OIt> class joining_iterator;
 template <typename It> class unkeyed_iterator;
 template <typename... Its> class zip_iterator;
 
-template <typename It>
-using recursive_iterator = recursive::rimpl<It>;
+template <typename It> using recursive_iterator = recursive::rimpl<It>;
 template <typename It, std::size_t N>
 using recursive_iterator_n = recursive::rimpl<It, recursive::bounded<N>>;
 

include/iterator/indexed_iterator.h

@@ -16,8 +16,7 @@
 
 namespace iterator {
 template <typename It>
-class indexed_iterator
-    : public facade<indexed_iterator<It>> {
+class indexed_iterator : public facade<indexed_iterator<It>> {
 public:
   using reference = std::pair<size_t, DEREF_TYPE(It)>;
   using difference_type = typename std::iterator_traits<It>::difference_type;
@@ -36,17 +35,23 @@ public:
 
   reference dereference() const { return {index_, *base_}; }
 
-  void increment() requires(std::forward_iterator<It>) {
+  void increment()
+    requires(std::forward_iterator<It>)
+  {
     ++base_;
     ++index_;
   }
 
-  void decrement() requires(std::bidirectional_iterator<It>) {
+  void decrement()
+    requires(std::bidirectional_iterator<It>)
+  {
     --base_;
     --index_;
   }
 
-  void advance(difference_type off) requires(std::random_access_iterator<It>) {
+  void advance(difference_type off)
+    requires(std::random_access_iterator<It>)
+  {
     base_ += off;
     index_ += off;
   }
@@ -55,11 +60,15 @@ public:
     return base_ == other.base_;
   }
 
-  difference_type distance_to(indexed_iterator const & other) const requires(std::random_access_iterator<It>) {
+  difference_type distance_to(indexed_iterator const & other) const
+    requires(std::random_access_iterator<It>)
+  {
     return other.base_ - base_;
   }
 
-  bool at_end() const requires(has_sentinel<It>) {
+  bool at_end() const
+    requires(has_sentinel<It>)
+  {
     return base_ == typename It::sentinel_type();
   }
 

include/iterator/join_iterator.h

@@ -20,8 +20,7 @@
 
 namespace iterator {
 template <typename It>
-class joining_iterator
-    : public facade<joining_iterator<It>> {
+class joining_iterator : public facade<joining_iterator<It>> {
 private:
   template <typename Ot> friend class joining_iterator;
   constexpr static bool requires_caching = !std::is_reference_v<DEREF_TYPE(It)>;
@@ -97,8 +96,7 @@ private:
   }
 };
 
-template <typename C>
-joining_iterator(C &) -> joining_iterator<iterator_t<C>>;
+template <typename C> joining_iterator(C &) -> joining_iterator<iterator_t<C>>;
 template <typename JI>
 joining_iterator(end_aware_iterator<JI>) -> joining_iterator<JI>;
 }

include/iterator/proxy.h

@@ -22,7 +22,9 @@ public:
   decltype(auto) dereference() const { return *impl_; }
   void increment() { ++impl_; }
   bool equal_to(Self const & other) const { return impl_ == other.impl_; }
-  bool at_end() const requires(has_sentinel<It>) {
+  bool at_end() const
+    requires(has_sentinel<It>)
+  {
     return impl() == typename It::sentinel_type();
   }
 
@@ -31,8 +33,7 @@ protected:
 };
 
 template <typename It, typename Self>
-class proxy<It, Self, std::forward_iterator_tag>
-    : public facade<Self> {
+class proxy<It, Self, std::forward_iterator_tag> : public facade<Self> {
 private:
   It impl_;
 
@@ -44,7 +45,9 @@ public:
   decltype(auto) dereference() const { return *impl_; }
   void increment() { ++impl_; }
   bool equal_to(Self const & other) const { return impl_ == other.impl_; }
-  bool at_end() const requires(has_sentinel<It>) {
+  bool at_end() const
+    requires(has_sentinel<It>)
+  {
     return impl() == typename It::sentinel_type();
   }
 
@@ -53,8 +56,7 @@ protected:
 };
 
 template <typename It, typename Self>
-class proxy<It, Self, std::bidirectional_iterator_tag>
-    : public facade<Self> {
+class proxy<It, Self, std::bidirectional_iterator_tag> : public facade<Self> {
 private:
   It impl_;
 
@@ -67,7 +69,9 @@ public:
   void increment() { ++impl_; }
   void decrement() { --impl_; }
   bool equal_to(Self const & other) const { return impl_ == other.impl_; }
-  bool at_end() const requires(has_sentinel<It>) {
+  bool at_end() const
+    requires(has_sentinel<It>)
+  {
     return impl() == typename It::sentinel_type();
   }
 
@@ -76,8 +80,7 @@ protected:
 };
 
 template <typename It, typename Self>
-class proxy<It, Self, std::random_access_iterator_tag>
-    : public facade<Self> {
+class proxy<It, Self, std::random_access_iterator_tag> : public facade<Self> {
 public:
   using difference_type = typename std::iterator_traits<It>::difference_type;
 
@@ -95,12 +98,14 @@ public:
   difference_type distance_to(Self const & other) const {
     return other.impl_ - impl_;
   }
-  
-  friend auto operator-(sentinel_for<It> auto sentinel, Self const &self) {
+
+  friend auto operator-(sentinel_for<It> auto sentinel, Self const & self) {
     return sentinel - self.impl();
   }
-  
-  bool at_end() const requires(has_sentinel<It>) {
+
+  bool at_end() const
+    requires(has_sentinel<It>)
+  {
     return (typename It::sentinel_type() - impl()) <= 0;
   }
 

include/iterator/recursive_iterator.h

@@ -118,7 +118,7 @@ public:
       return build_tuple();
     }
   }
-  
+
   void increment() { increment_i(); }
 
   bool at_end() const { return std::get<0>(impl_).at_end(); }
@@ -204,8 +204,7 @@ template <typename C> auto make_recursive_iterator(C && collect) {
 
 template <std::size_t Max, typename C>
 auto make_recursive_iterator(C && collect) {
-  return iterator::recursive_iterator_n<iterator::iterator_t<C>, Max>(
-      collect);
+  return iterator::recursive_iterator_n<iterator::iterator_t<C>, Max>(collect);
 }
 
 #include <iterator/detail/undef.h>

include/iterator/zip_iterator.h

@@ -26,10 +26,14 @@ public:
   void increment() {
     [[maybe_unused]] auto l = {((++std::get<Is>(_data)), 0)...};
   }
-  void decrement() requires(std::bidirectional_iterator<Ts> && ...) {
+  void decrement()
+    requires(std::bidirectional_iterator<Ts> && ...)
+  {
     [[maybe_unused]] auto l = {((--std::get<Is>(_data)), 0)...};
   }
-  void advance(difference_type d) requires(std::random_access_iterator<Ts> && ...) {
+  void advance(difference_type d)
+    requires(std::random_access_iterator<Ts> && ...)
+  {
     [[maybe_unused]] auto l = {((std::get<Is>(_data) += d), 0)...};
   }
 
@@ -37,7 +41,9 @@ public:
     return _data == other._data;
   }
 
-  auto distance_to(zip_iterator_impl const & other) const requires(std::random_access_iterator<Ts> && ...) {
+  auto distance_to(zip_iterator_impl const & other) const
+    requires(std::random_access_iterator<Ts> && ...)
+  {
     return std::get<0>(other._data) - std::get<0>(_data);
   }
 
@@ -54,9 +60,8 @@ using zip_impl =
     detail::zip_iterator_impl<std::tuple<Ts...>, index_sequence<Ts...>>;
 
 template <typename... Iters>
-class zip_iterator
-    : public zip_impl<Iters...>,
-      public facade<zip_iterator<Iters...>> {
+class zip_iterator : public zip_impl<Iters...>,
+                     public facade<zip_iterator<Iters...>> {
 public:
   zip_iterator() = default;
   zip_iterator(Iters... iters) : zip_impl<Iters...>(iters...) {}

test/end_aware_iterator_test.cxx

@@ -9,8 +9,9 @@ using iterator::end_aware_iterator;
 
 TEST(EndAwareIterator, IStreamIterator) {
   std::stringstream ss{"0 1 2 3"};
-  end_aware_iterator eai{std::istream_iterator<int>(ss), std::istream_iterator<int>()};
-  
+  end_aware_iterator eai{std::istream_iterator<int>(ss),
+                         std::istream_iterator<int>()};
+
   EXPECT_TRUE(iterator::single_pass<decltype(eai)>);
 }