Rename IteratorImpl to IteratorBase

danakj · danakj · commit f438578f6574 · 2023-03-02T23:42:05.000-05:00
Now that the old IteratorBase is gone.
diff --git a/subdoc/lib/path.h b/subdoc/lib/path.h
@@ -83,7 +83,7 @@ inline clang::NamespaceDecl* find_nearest_namespace(
 namespace __private {
 
 class RecordIter final
-    : public sus::iter::IteratorImpl<RecordIter, std::string_view> {
+    : public sus::iter::IteratorBase<RecordIter, std::string_view> {
  public:
   static RecordIter with(clang::RecordDecl* decl) noexcept {
     return RecordIter(decl);
@@ -128,7 +128,7 @@ inline auto iter_record_path(clang::RecordDecl* decl) {
 namespace __private {
 
 class NamespaceIter final
-    : public sus::iter::IteratorImpl<NamespaceIter, Namespace> {
+    : public sus::iter::IteratorBase<NamespaceIter, Namespace> {
  public:
   static NamespaceIter with(clang::Decl* decl) noexcept {
     return NamespaceIter(decl);
diff --git a/subspace/containers/__private/array_iter.h b/subspace/containers/__private/array_iter.h
@@ -32,7 +32,7 @@ class Array;
 
 template <::sus::mem::Move ItemT, size_t N>
 struct ArrayIntoIter final
-    : public ::sus::iter::IteratorImpl<ArrayIntoIter<ItemT, N>, ItemT> {
+    : public ::sus::iter::IteratorBase<ArrayIntoIter<ItemT, N>, ItemT> {
  public:
   using Item = ItemT;
 
diff --git a/subspace/containers/__private/slice_iter.h b/subspace/containers/__private/slice_iter.h
@@ -34,7 +34,7 @@ class Slice;
 
 template <class ItemT>
 struct [[sus_trivial_abi]] SliceIter final
-    : public ::sus::iter::IteratorImpl<SliceIter<ItemT>, ItemT> {
+    : public ::sus::iter::IteratorBase<SliceIter<ItemT>, ItemT> {
  public:
   using Item = ItemT;
 
@@ -104,7 +104,7 @@ struct [[sus_trivial_abi]] SliceIter final
 
 template <class ItemT>
 struct [[sus_trivial_abi]] SliceIterMut final
-    : public ::sus::iter::IteratorImpl<SliceIterMut<ItemT>, ItemT> {
+    : public ::sus::iter::IteratorBase<SliceIterMut<ItemT>, ItemT> {
  public:
   using Item = ItemT;
 
diff --git a/subspace/containers/__private/vec_iter.h b/subspace/containers/__private/vec_iter.h
@@ -31,7 +31,7 @@ class Vec;
 
 template <class ItemT>
 struct VecIntoIter final
-    : public ::sus::iter::IteratorImpl<VecIntoIter<ItemT>, ItemT> {
+    : public ::sus::iter::IteratorBase<VecIntoIter<ItemT>, ItemT> {
  public:
   using Item = ItemT;
 
diff --git a/subspace/iter/__private/into_iterator_archetype.h b/subspace/iter/__private/into_iterator_archetype.h
@@ -23,15 +23,15 @@ class Option;
 
 namespace sus::iter {
 template <class SubclassT, class ItemT>
-class IteratorImpl;
+class IteratorBase;
 }  // namespace sus::iter
 
 namespace sus::iter::__private {
 
 template <class T>
 struct IntoIteratorArchetype {
   template <class Item>
-  struct Iter final : public IteratorImpl<Iter<Item>, Item> {
+  struct Iter final : public IteratorBase<Iter<Item>, Item> {
     ::sus::option::Option<Item> next() noexcept {
       return ::sus::option::Option<Item>::none();
     }
diff --git a/subspace/iter/boxed_iterator.h b/subspace/iter/boxed_iterator.h
@@ -23,7 +23,7 @@
 namespace sus::iter {
 
 template <class Iter, class Item>
-class IteratorImpl;
+class IteratorBase;
 
 /// A BoxedIterator wraps another Iterator but pushes it onto the heap.
 ///
@@ -35,7 +35,7 @@ class IteratorImpl;
 template <class ItemT, size_t SubclassSize, size_t SubclassAlign,
           bool DoubleEnded>
 class [[nodiscard]] [[sus_trivial_abi]] BoxedIterator final
-    : public IteratorImpl<
+    : public IteratorBase<
           BoxedIterator<ItemT, SubclassSize, SubclassAlign, DoubleEnded>,
           ItemT> {
  public:
@@ -44,10 +44,10 @@ class [[nodiscard]] [[sus_trivial_abi]] BoxedIterator final
   template <::sus::mem::Move Iter>
   static BoxedIterator with(Iter&& iter) noexcept
     requires(
-        ::sus::convert::SameOrSubclassOf<Iter*, IteratorImpl<Iter, Item>*> &&
+        ::sus::convert::SameOrSubclassOf<Iter*, IteratorBase<Iter, Item>*> &&
         !::sus::mem::relocate_by_memcpy<Iter>)
   {
-    // IteratorImpl also checks this. It's needed for correctness of the move
+    // IteratorBase also checks this. It's needed for correctness of the move
     // onto the heap.
     static_assert(std::is_final_v<Iter>);
 
diff --git a/subspace/iter/empty.h b/subspace/iter/empty.h
@@ -22,7 +22,7 @@ namespace sus::iter {
 /// An Iterator that never returns an `Item`.
 template <class ItemT>
 class [[nodiscard]] [[sus_trivial_abi]] Empty final
-    : public IteratorImpl<Empty<ItemT>, ItemT> {
+    : public IteratorBase<Empty<ItemT>, ItemT> {
  public:
   using Item = ItemT;
 
diff --git a/subspace/iter/filter.h b/subspace/iter/filter.h
@@ -26,7 +26,7 @@ using ::sus::mem::relocate_by_memcpy;
 
 template <class InnerSizedIter>
 class [[nodiscard]] [[sus_trivial_abi]] Filter final
-    : public IteratorImpl<Filter<InnerSizedIter>,
+    : public IteratorBase<Filter<InnerSizedIter>,
                           typename InnerSizedIter::Item> {
   using Pred = ::sus::fn::FnMut<bool(
       // TODO: write a sus::const_ref<T>?
diff --git a/subspace/iter/iterator.h b/subspace/iter/iterator.h
@@ -20,7 +20,7 @@
 #include "subspace/iter/iterator_concept.h"
 
 // Once is included here, because there is a cycle between:
-// * Option->Once->IteratorImpl->Option
+// * Option->Once->IteratorBase->Option
 // * Result->Iterator->usize->Result
 // So Option and Result can't include Once or Iterator directly. But as long
 // as the user includes "iterator.h" they should be able to use the iterators on
diff --git a/subspace/iter/iterator_concept.h b/subspace/iter/iterator_concept.h
@@ -31,7 +31,7 @@ class Option;
 namespace sus::iter {
 
 template <class Iter, class Item>
-class IteratorImpl;
+class IteratorBase;
 
 /// A concept for all implementations of iterators.
 ///
@@ -44,7 +44,7 @@ class IteratorImpl;
 ///
 /// Types that satisfy this concept can be used in for loops and provide
 /// all the methods of an iterator type, which are found in
-/// `sus::iter::IteratorImpl`.
+/// `sus::iter::IteratorBase`.
 ///
 /// Any Iterator's full definition includes a number of other methods as well,
 /// built on top of next, and so you get them for free.
@@ -57,9 +57,9 @@ concept Iterator = requires(T& t) {
   requires(!std::is_void_v<typename std::decay_t<T>::Item>);
   // The T::Item matches the concept input.
   requires(std::same_as<typename std::decay_t<T>::Item, Item>);
-  // Subclasses from IteratorImpl<T, T::Item>.
+  // Subclasses from IteratorBase<T, T::Item>.
   requires ::sus::convert::SameOrSubclassOf<
-      std::decay_t<T>*, IteratorImpl<std::decay_t<T>, Item>*>;
+      std::decay_t<T>*, IteratorBase<std::decay_t<T>, Item>*>;
   // Required methods.
   { t.next() } noexcept -> std::same_as<::sus::option::Option<Item>>;
 };
diff --git a/subspace/iter/iterator_defn.h b/subspace/iter/iterator_defn.h
@@ -55,9 +55,9 @@ struct SizeHint {
 };
 
 template <class Iter, class ItemT>
-class IteratorImpl {
+class IteratorBase {
  protected:
-  constexpr IteratorImpl() noexcept {
+  constexpr IteratorBase() noexcept {
     static_assert(std::is_final_v<Iter>,
                   "Iterator implementations must be `final`, as the provided "
                   "methods must know the complete type.");
@@ -226,19 +226,18 @@ class IteratorImpl {
   //
   // TODO: If the iterator is over references, collect_vec() could map them to
   // NonNull.
-  template <int&..., class Vec = ::sus::containers::Vec<ItemT>>
-  Vec collect_vec() && noexcept;
+  ::sus::containers::Vec<ItemT> collect_vec() && noexcept;
 
   // TODO: cloned().
 };
 
 template <class Iter, class Item>
-SizeHint IteratorImpl<Iter, Item>::size_hint() const noexcept {
+SizeHint IteratorBase<Iter, Item>::size_hint() const noexcept {
   return SizeHint(0_usize, ::sus::Option<::sus::num::usize>::none());
 }
 
 template <class Iter, class Item>
-bool IteratorImpl<Iter, Item>::all(::sus::fn::FnMut<bool(Item)> f) noexcept {
+bool IteratorBase<Iter, Item>::all(::sus::fn::FnMut<bool(Item)> f) noexcept {
   while (true) {
     Option<Item> item = as_subclass_mut().next();
     if (item.is_none()) return true;
@@ -249,7 +248,7 @@ bool IteratorImpl<Iter, Item>::all(::sus::fn::FnMut<bool(Item)> f) noexcept {
 }
 
 template <class Iter, class Item>
-bool IteratorImpl<Iter, Item>::any(::sus::fn::FnMut<bool(Item)> f) noexcept {
+bool IteratorBase<Iter, Item>::any(::sus::fn::FnMut<bool(Item)> f) noexcept {
   while (true) {
     Option<Item> item = as_subclass_mut().next();
     if (item.is_none()) return false;
@@ -259,7 +258,7 @@ bool IteratorImpl<Iter, Item>::any(::sus::fn::FnMut<bool(Item)> f) noexcept {
 }
 
 template <class Iter, class Item>
-auto IteratorImpl<Iter, Item>::box() && noexcept
+auto IteratorBase<Iter, Item>::box() && noexcept
   requires(!::sus::mem::relocate_by_memcpy<Iter>)
 {
   using BoxedIterator =
@@ -269,7 +268,7 @@ auto IteratorImpl<Iter, Item>::box() && noexcept
 }
 
 template <class Iter, class Item>
-::sus::num::usize IteratorImpl<Iter, Item>::count() noexcept {
+::sus::num::usize IteratorBase<Iter, Item>::count() noexcept {
   auto c = 0_usize;
   while (as_subclass_mut().next().is_some()) c += 1_usize;
   return c;
@@ -278,7 +277,7 @@ ::sus::num::usize IteratorImpl<Iter, Item>::count() noexcept {
 template <class Iter, class Item>
 template <class MapFn, int&..., class R, class MapFnMut>
   requires(::sus::construct::Into<MapFn, MapFnMut> && !std::is_void_v<R>)
-auto IteratorImpl<Iter, Item>::map(MapFn fn) && noexcept
+auto IteratorBase<Iter, Item>::map(MapFn fn) && noexcept
   requires(::sus::mem::relocate_by_memcpy<Iter>)
 {
   using Sized = SizedIteratorType<Iter>::type;
@@ -288,7 +287,7 @@ auto IteratorImpl<Iter, Item>::map(MapFn fn) && noexcept
 }
 
 template <class Iter, class Item>
-auto IteratorImpl<Iter, Item>::filter(
+auto IteratorBase<Iter, Item>::filter(
     ::sus::fn::FnMut<bool(const std::remove_reference_t<Item>&)>
         pred) && noexcept
   requires(::sus::mem::relocate_by_memcpy<Iter>)
@@ -300,7 +299,7 @@ auto IteratorImpl<Iter, Item>::filter(
 }
 
 template <class Iter, class Item>
-auto IteratorImpl<Iter, Item>::rev() && noexcept
+auto IteratorBase<Iter, Item>::rev() && noexcept
   requires(::sus::mem::relocate_by_memcpy<Iter> &&
            ::sus::iter::DoubleEndedIterator<Iter, Item>)
 {
@@ -312,14 +311,13 @@ auto IteratorImpl<Iter, Item>::rev() && noexcept
 template <class Iter, class Item>
 template <::sus::iter::FromIterator<Item> C>
 ::sus::iter::FromIterator<Item> auto
-IteratorImpl<Iter, Item>::collect() && noexcept {
+IteratorBase<Iter, Item>::collect() && noexcept {
   return C::from_iter(static_cast<Iter&&>(*this));
 }
 
 template <class Iter, class Item>
-template <int&..., class Vec>
-Vec IteratorImpl<Iter, Item>::collect_vec() && noexcept {
-  return Vec::from_iter(static_cast<Iter&&>(*this));
+::sus::containers::Vec<Item> IteratorBase<Iter, Item>::collect_vec() && noexcept {
+  return ::sus::containers::Vec<Item>::from_iter(static_cast<Iter&&>(*this));
 }
 
 }  // namespace sus::iter
diff --git a/subspace/iter/iterator_unittest.cc b/subspace/iter/iterator_unittest.cc
@@ -29,7 +29,7 @@
 
 using sus::containers::Array;
 using sus::fn::Fn;
-using sus::iter::IteratorImpl;
+using sus::iter::IteratorBase;
 using sus::option::Option;
 
 namespace {
@@ -79,7 +79,7 @@ static_assert(
 // clang-format on
 
 template <class Item, size_t N>
-class ArrayIterator final : public IteratorImpl<ArrayIterator<Item, N>, Item> {
+class ArrayIterator final : public IteratorBase<ArrayIterator<Item, N>, Item> {
  public:
   static ArrayIterator with_array(Item (&items)[N]) noexcept {
     return ArrayIterator(items);
@@ -117,7 +117,7 @@ class ArrayIterator final : public IteratorImpl<ArrayIterator<Item, N>, Item> {
 static_assert(sus::iter::Iterator<ArrayIterator<int, 1>, int>);
 
 template <class Item>
-class EmptyIterator final : public IteratorImpl<EmptyIterator<Item>, Item> {
+class EmptyIterator final : public IteratorBase<EmptyIterator<Item>, Item> {
  public:
   EmptyIterator() {}
 
diff --git a/subspace/iter/map.h b/subspace/iter/map.h
@@ -23,7 +23,7 @@
 namespace sus::iter {
 
 template <class ToItem, class InnerSizedIter>
-class [[nodiscard]] [[sus_trivial_abi]] Map final : public IteratorImpl<Map<ToItem, InnerSizedIter>, ToItem> {
+class [[nodiscard]] [[sus_trivial_abi]] Map final : public IteratorBase<Map<ToItem, InnerSizedIter>, ToItem> {
   using FromItem = InnerSizedIter::Item;
   using MapFn = ::sus::fn::FnMut<ToItem(FromItem&&)>;
 
diff --git a/subspace/iter/once.h b/subspace/iter/once.h
@@ -24,7 +24,7 @@ using ::sus::option::Option;
 
 /// An Iterator that walks over at most a single Item.
 template <class ItemT>
-class [[nodiscard]] Once final : public IteratorImpl<Once<ItemT>, ItemT> {
+class [[nodiscard]] Once final : public IteratorBase<Once<ItemT>, ItemT> {
  public:
   using Item = ItemT;
 
diff --git a/subspace/iter/reverse.h b/subspace/iter/reverse.h
@@ -31,7 +31,7 @@ using ::sus::mem::relocate_by_memcpy;
 /// The iterator wrapped by Reverse must be a DoubleEndedIterator.
 template <class InnerSizedIter>
 class [[nodiscard]] [[sus_trivial_abi]] Reverse final
-    : public IteratorImpl<Reverse<InnerSizedIter>,
+    : public IteratorBase<Reverse<InnerSizedIter>,
                           typename InnerSizedIter::Item> {
   static_assert(InnerSizedIter::DoubleEnded);
 
diff --git a/subspace/iter/sized_iterator.h b/subspace/iter/sized_iterator.h
@@ -83,7 +83,7 @@ template <::sus::mem::Move Iter, int&..., class Item = typename Iter::Item>
 inline SizedIteratorType<Iter>::type make_sized_iterator(Iter&& iter)
   requires(::sus::iter::Iterator<Iter, Item> && ::sus::mem::relocate_by_memcpy<Iter>)
 {
-  // IteratorImpl also checks this. It's needed for correctness of the casts
+  // IteratorBase also checks this. It's needed for correctness of the casts
   // here.
   static_assert(std::is_final_v<Iter>);
 
diff --git a/subspace/ops/range.h b/subspace/ops/range.h
@@ -52,7 +52,7 @@ template <class Final, class T, bool = ::sus::iter::__private::Step<T>>
 class RangeIter;
 
 template <class Final, class T>
-class RangeIter<Final, T, true> : public ::sus::iter::IteratorImpl<Final, T> {
+class RangeIter<Final, T, true> : public ::sus::iter::IteratorBase<Final, T> {
  public:
   // sus::iter::Iterator trait.
   Option<T> next() noexcept {
@@ -94,7 +94,7 @@ class RangeFromIter;
 
 template <class Final, class T>
 class RangeFromIter<Final, T, true>
-    : public ::sus::iter::IteratorImpl<Final, T> {
+    : public ::sus::iter::IteratorBase<Final, T> {
  public:
   // sus::iter::Iterator trait.
   Option<T> next() noexcept {
@@ -128,7 +128,7 @@ class Range final : public __private::RangeIter<Range<T>, T> {
   T start;
   /// The end of the range, exclusive of the given value.
   //
-  // Not named `end` to avoid shadowing IteratorImpl::end(), which then breaks
+  // Not named `end` to avoid shadowing IteratorBase::end(), which then breaks
   // for loops on Range.
   T finish;
 
diff --git a/subspace/option/option.h b/subspace/option/option.h
@@ -50,10 +50,8 @@
 #include "subspace/result/__private/is_result_type.h"
 
 namespace sus::iter {
-template <class Item>
-class IteratorBase;
 template <class Iter, class Item>
-class IteratorImpl;
+class IteratorBase;
 template <class Item>
 class Once;
 namespace __private {
@@ -151,7 +149,7 @@ class Option final {
     // An iterator over `option_iter`'s iterator that returns each element in it
     // until it reaches a `None` or the end.
     struct UntilNoneIter final
-        : public ::sus::iter::IteratorImpl<UntilNoneIter, U> {
+        : public ::sus::iter::IteratorBase<UntilNoneIter, U> {
       UntilNoneIter(Iter&& iter, bool& found_none)
           : iter(iter), found_none(found_none) {}
 
@@ -167,8 +165,9 @@ class Option final {
     };
 
     bool found_none = false;
-    auto collected = T::from_iter(UntilNoneIter(
-        ::sus::move(option_iter).into_iter(), ::sus::mref(found_none)));
+    auto iter = UntilNoneIter(::sus::move(option_iter).into_iter(),
+                              ::sus::mref(found_none));
+    auto collected = T::from_iter(::sus::move(iter));
     if (found_none)
       return Option::none();
     else
diff --git a/subspace/option/option_unittest.cc b/subspace/option/option_unittest.cc
diff --git a/subspace/result/result.h b/subspace/result/result.h
