fix: fix some iterator problems

external/iterator

@@ -1 +1 @@
-Subproject commit be1b61e465e3b9ef3baaafeb76b979aa25c1949c
+Subproject commit 5ee7b843d7add9743cf6f4f551ca3045f51b0c26

include/stream/any_view.h

@@ -0,0 +1,97 @@
+//
+//  view.h
+//  stream
+//
+//  Created by Sam Jaffe on 3/29/23.
+//
+
+#pragma once
+
+#include <memory>
+
+#include <iterator/sentinel_iterator.h>
+#include <stream/detail/traits.h>
+#include <stream/forward.h>
+
+namespace stream::ranges {
+
+template <typename T> class view_iterator : public facade<view_iterator<T>> {
+private:
+  T (*dereference_)(void *){nullptr};
+  bool (*equal_to_)(void *, void *){nullptr};
+  void (*increment_)(void *){nullptr};
+  std::shared_ptr<void> impl_{nullptr};
+
+public:
+  template <typename It>
+  view_iterator(It impl)
+      : dereference_([](void * p) -> T { return **((It *)p); }),
+        equal_to_([](void * l, void * r) { return *((It *)l) == *((It *)r); }),
+        increment_([](void * p) { ++(*(It *)(p)); }),
+        impl_(std::make_shared<It>(impl)) {}
+
+  T dereference() const { return dereference_(impl_.get()); }
+
+  void increment() { increment_(impl_.get()); }
+
+  bool equal_to(view_iterator const & other) const {
+    return impl_ == other.impl_ ||
+           (impl_ && other.impl_ && equal_to_(impl_.get(), other.impl_.get()));
+  }
+};
+
+template <typename T> class any_view {
+private:
+  template <typename S>
+  using sentinel_iterator =
+      iterator::sentinel_iterator<detail::begin_t<S>, detail::end_t<S>>;
+  template <typename S, typename It>
+  using iter_cast_t =
+      std::conditional_t<detail::is_sentinal_v<S>, sentinel_iterator<S>, It>;
+
+  using make_iter_t = view_iterator<T> (*)(void *);
+
+private:
+  std::shared_ptr<void> impl_{nullptr};
+  make_iter_t begin_{nullptr};
+  make_iter_t end_{nullptr};
+
+public:
+  template <typename S>
+  any_view(std::shared_ptr<S> impl)
+      : impl_(impl), begin_(begin_function<S>()), end_(end_function<S>()) {}
+
+  template <typename S>
+  any_view(S & impl) : any_view(std::shared_ptr<S>(&impl, [](void *) {})) {}
+
+  template <typename S>
+  any_view(S const & impl)
+      : any_view(std::shared_ptr<S const>(&impl, [](void *) {})) {}
+
+  template <typename S>
+  any_view(S && impl) : any_view(std::make_shared<S>(std::forward<S>(impl))) {}
+
+  auto begin() const { return begin_(impl_.get()); }
+  auto end() const { return end_(impl_.get()); }
+
+private:
+  template <typename S> static make_iter_t begin_function() {
+    return [](void * p) -> view_iterator<T> {
+      return iter_cast_t<S, detail::begin_t<S>>(static_cast<S *>(p)->begin());
+    };
+  }
+
+  template <typename S> static make_iter_t end_function() {
+    return [](void * p) -> view_iterator<T> {
+      return iter_cast_t<S, detail::end_t<S>>(static_cast<S *>(p)->end());
+    };
+  }
+};
+
+template <typename S>
+any_view(std::shared_ptr<S>) -> any_view<detail::value_type<S>>;
+template <typename S> any_view(S &) -> any_view<detail::value_type<S>>;
+template <typename S> any_view(S const &) -> any_view<detail::value_type<S>>;
+template <typename S> any_view(S &&) -> any_view<detail::value_type<S>>;
+
+}

include/stream/common_view.h

@@ -8,33 +8,31 @@
 #pragma once
 
 #include <iterator/sentinel_iterator.h>
-#include <stream/forward.h>
 #include <stream/detail/traits.h>
+#include <stream/forward.h>
+
+#include <iterator/detail/macro.h>
 
 #define FWD(x) std::forward<decltype(x)>(x)
 
 namespace stream::ranges {
 template <typename S> class common_view {
+private:
+  using iterator =
+      iterator::sentinel_iterator<detail::begin_t<S>, detail::end_t<S>>;
+
 private:
   S stream_;
 
 public:
   common_view(S && stream) : stream_(FWD(stream)) {}
 
-  auto begin() const { return iterator::sentinel_iterator(stream_.begin()); }
-  auto end() const { return decltype(begin())(); }
-  
-  auto empty() const {
-    if constexpr (traits::has_empty_v<S>) {
-      return stream_.empty();
-    }
-  }
-  
-  auto size() {
-    if constexpr (traits::has_size_v<S>) {
-      return stream_.size();
-    }
-  }
+  auto begin() const { return iterator(stream_.begin()); }
+  auto end() const { return iterator(stream_.end()); }
+
+  SFINAE(detail::has_empty_v<S>, bool) empty() const { return stream_.empty(); }
+
+  SFINAE(detail::has_size_v<S>, bool) size() const { return stream_.size(); }
 };
 
 template <typename S> common_view(S &&) -> common_view<S>;
@@ -43,9 +41,14 @@ template <typename S> common_view(S &&) -> common_view<S>;
 namespace stream::ranges::views {
 struct common {
   template <typename Stream> friend auto operator|(Stream && stream, common) {
-    return common_view(FWD(stream));
+    if constexpr (detail::is_sentinal_v<Stream>) {
+      return common_view(FWD(stream));
+    } else {
+      return FWD(stream);
+    }
   }
 };
 }
 
 #undef FWD
+#include <iterator/detail/undef.h>

include/stream/detail/sentinal.h

@@ -1,25 +0,0 @@
-//
-//  sentinal.h
-//  stream
-//
-//  Created by Sam Jaffe on 3/30/23.
-//
-
-#pragma once
-
-namespace stream::detail {
-struct sentinal_type {
-  template <typename It>
-  friend bool operator==(It const & iter, sentinal_type) {
-    return iter.at_end();
-  }
-  template <typename It>
-  friend bool operator!=(It const & iter, sentinal_type) {
-    return !iter.at_end();
-  }
-};
-}
-
-namespace stream::ranges {
-constexpr inline detail::sentinal_type sentinal;
-}

include/stream/detail/traits.h

@@ -15,14 +15,13 @@
 
 #include <stream/forward.h>
 
-#define _val(type) std::declval<type>()
-#define exists(expr) std::void_t<decltype(expr)>
+#include <iterator/detail/macro.h>
 
-namespace stream::traits {
-template <typename C> using begin_t = decltype(std::begin(_val(C)));
-template <typename C> using end_t = decltype(std::end(_val(C)));
+namespace stream::detail {
+template <typename C> using begin_t = decltype(std::begin(VAL(C)));
+template <typename C> using end_t = decltype(std::end(VAL(C)));
 
-template <typename C> using ref_t = decltype(*_val(begin_t<C>));
+template <typename C> using ref_t = decltype(*VAL(begin_t<C>));
 template <typename C> using value_type = std::remove_reference_t<ref_t<C>>;
 template <typename C> using cref_t = std::add_const_t<ref_t<C>>;
 
@@ -30,15 +29,17 @@ template <typename, typename = void> struct has_size : std::false_type {};
 template <typename, typename = void> struct has_empty : std::false_type {};
 
 template <typename C>
-struct has_size<C, std::enable_if_t<std::is_integral_v<decltype(_val(C).size())>>> : std::true_type {};
+struct has_size<C, std::enable_if_t<std::is_integral_v<TYPE(C, size())>>>
+    : std::true_type {};
 template <typename C>
-struct has_empty<C, std::enable_if_t<std::is_same_v<decltype(_val(C).empty()), bool>>> : std::true_type {};
+struct has_empty<C, std::enable_if_t<std::is_same_v<TYPE(C, empty()), bool>>>
+    : std::true_type {};
 
 template <typename It, typename S, typename = void>
 struct is_comparable : std::false_type {};
 
 template <typename It, typename S>
-struct is_comparable<It, S, exists(_val(It) == _val(S))> : std::true_type {};
+struct is_comparable<It, S, EXISTS(VAL(It) == VAL(S))> : std::true_type {};
 
 template <typename C> constexpr bool has_size_v = has_size<C>{};
 template <typename C> constexpr bool has_empty_v = has_empty<C>{};
@@ -49,5 +50,4 @@ template <typename S>
 constexpr bool is_sentinal_v = !std::is_same_v<begin_t<S>, end_t<S>>;
 }
 
-#undef _val
-#undef exists
+#include <iterator/detail/undef.h>

include/stream/filter_view.h

@@ -2,40 +2,35 @@
 
 #include <functional>
 
-#include <iterator/filter_iterator.hpp>
+#include <iterator/filter_iterator.h>
 
-#include <stream/detail/sentinal.h>
 #include <stream/detail/traits.h>
 
 #define FWD(x) std::forward<decltype(x)>(x)
 
 namespace stream::ranges {
-template <typename S> class filter_view {
-private:
-  using Pred = std::function<bool(traits::cref_t<S>)>;
-  using iterator = ::iterator::filter_iterator<iter<S>>;
-
+template <typename S, typename P> class filter_view {
 private:
   S stream_;
-  Pred predicate_;
+  P predicate_;
 
 public:
-  template <typename F>
-  filter_view(S && stream, F predicate)
+  filter_view(S && stream, P predicate)
       : stream_(FWD(stream)), predicate_(predicate) {}
 
-  auto begin() const { return iterator(predicate_, stream_); }
-  auto end() const { return sentinal; }
+  auto begin() const { return iterator::filter_iterator(stream_, predicate_); }
+  auto end() const { return iterator::sentinel; }
 };
 
-template <typename S, typename F> filter_view(S &&, F) -> filter_view<S>;
+template <typename S, typename P> filter_view(S &&, P) -> filter_view<S, P>;
 }
 
 namespace stream::ranges::views {
 template <typename Pred> class filter {
 public:
   filter(Pred const & predicate) : predicate_(predicate) {}
-  filter(Pred & predicate) : predicate_(std::move(predicate)) {}
+  filter(Pred && predicate) : predicate_(std::move(predicate)) {}
+  filter(Pred & predicate) : predicate_(predicate) {}
 
   template <typename Stream>
   friend auto operator|(Stream && stream, filter filt) {

include/stream/forward.h

@@ -1,14 +1,19 @@
 #pragma once
 
-#include <iterator/iterator_fwd.hpp>
+#include <iterator/forwards.h>
+
+namespace iterator::detail {
+}
+namespace stream::detail {
+using namespace ::iterator::detail;
+}
 
 namespace stream::ranges {
 using ::iterator::end_aware_iterator;
 using ::iterator::facade;
-using ::iterator::iter;
 using ::iterator::proxy;
 
-template <typename> class view;
+template <typename> class any_view;
 }
 namespace stream::ranges::views {
 }

include/stream/join_view.h

@@ -1,25 +1,19 @@
 #pragma once
 
-#include <iterator/join_iterator.hpp>
-
-#include <stream/detail/sentinal.h>
+#include <iterator/join_iterator.h>
 
 #define FWD(x) std::forward<decltype(x)>(x)
 
 namespace stream::ranges {
 template <typename S> struct join_view {
-private:
-  using iterator = ::iterator::joining_iterator<iter<S>>;
-
 private:
   S stream_;
 
 public:
   join_view(S && stream) : stream_(FWD(stream)) {}
 
-  auto begin() const { return iterator(stream_); }
-  auto end() const { return sentinal; }
-  bool empty() const { return begin() == end(); }
+  auto begin() const { return iterator::joining_iterator(stream_); }
+  auto end() const { return iterator::sentinel; }
 };
 }
 

include/stream/minmax.h

@@ -26,7 +26,7 @@ namespace stream::ranges {
 
 template <typename It, typename S, typename Comp = std::less<>,
           typename Proj = detail::identity,
-          typename = std::enable_if_t<traits::is_comparable_v<It, S>>>
+          typename = std::enable_if_t<detail::is_comparable_v<It, S>>>
 auto minmax(It it, S end, Comp comp = {}, Proj proj = {}) {
   detail::min_max_result v(*it, *it);
   for (++it; it != end; ++it) {
@@ -44,7 +44,7 @@ auto minmax(Stream const & stream, Comp comp = {}, Proj proj = {}) {
 
 template <typename It, typename S, typename Comp = std::less<>,
           typename Proj = detail::identity,
-          typename = std::enable_if_t<traits::is_comparable_v<It, S>>>
+          typename = std::enable_if_t<detail::is_comparable_v<It, S>>>
 auto min(It it, S end, Comp comp = {}, Proj proj = {}) {
   auto v = *it;
   for (++it; it != end; ++it) {
@@ -61,7 +61,7 @@ auto min(Stream const & stream, Comp comp = {}, Proj proj = {}) {
 
 template <typename It, typename S, typename Comp = std::less<>,
           typename Proj = detail::identity,
-          typename = std::enable_if_t<traits::is_comparable_v<It, S>>>
+          typename = std::enable_if_t<detail::is_comparable_v<It, S>>>
 auto max(It it, S end, Comp comp = {}, Proj proj = {}) {
   auto v = *it;
   for (++it; it != end; ++it) {

include/stream/owning_view.h

@@ -15,13 +15,10 @@ private:
 public:
   owning_view(C && container) : container_(std::move(container)) {}
 
-  auto begin() const { return end_aware_iterator(container_); }
-  auto end() const { return end_aware_iterator<iter<C>>(); }
+  auto begin() const { return container_.begin(); }
+  auto end() const { return container_.end(); }
   bool empty() const { return container_.empty(); }
   size_t size() const { return container_.size(); }
 };
 
 }
-
-namespace stream::ranges::views {
-}

include/stream/ref_view.h

@@ -2,9 +2,12 @@
 
 #include <iterator>
 
+#include <iterator/detail/facade_traits.h>
 #include <stream/forward.h>
 #include <stream/owning_view.h>
 
+#include <iterator/detail/macro.h>
+
 namespace stream::ranges {
 template <typename It> class ref_view {
 private:
@@ -17,14 +20,16 @@ public:
   ref_view(C & container)
       : begin_(std::begin(container)), end_(std::end(container)) {}
 
-  auto begin() const { return end_aware_iterator(begin_, end_); }
-  auto end() const { return end_aware_iterator<It>(); }
+  auto begin() const { return begin_; }
+  auto end() const { return end_; }
   bool empty() const { return begin_ == end_; }
-  size_t size() const { return std::distance(begin_, end_); }
+  SFINAE(detail::has_distance_to_v<It>, size_t) size() const {
+    return end_ - begin_;
+  }
 };
 
 template <typename It> ref_view(It, It) -> ref_view<It>;
-template <typename C> ref_view(C &) -> ref_view<iter<C>>;
+template <typename C> ref_view(C &) -> ref_view<detail::iter<C>>;
 }
 
 namespace stream::ranges::views {
@@ -36,3 +41,5 @@ template <typename C> auto all(C && container) {
   return owning_view(std::move(container));
 }
 }
+
+#include <iterator/detail/undef.h>

include/stream/size.h

@@ -15,7 +15,7 @@ template <typename It, typename S> std::ptrdiff_t distance(It it, S end) {
     return std::distance(it, end);
   } else {
     std::ptrdiff_t accum = 0;
-    while (it++ != end) {
+    for (; it != end; ++it) {
       ++accum;
     }
     return accum;
@@ -23,7 +23,7 @@ template <typename It, typename S> std::ptrdiff_t distance(It it, S end) {
 }
 
 template <typename Stream> size_t size(Stream const & stream) {
-  if constexpr (traits::has_size_v<Stream>) {
+  if constexpr (detail::has_size_v<Stream>) {
     return stream.size();
   } else {
     return distance(stream.begin(), stream.end());
@@ -31,7 +31,7 @@ template <typename Stream> size_t size(Stream const & stream) {
 }
 
 template <typename Stream> bool empty(Stream const & stream) {
-  if constexpr (traits::has_empty_v<Stream>) {
+  if constexpr (detail::has_empty_v<Stream>) {
     return stream.empty();
   } else {
     return size(stream) == 0;

include/stream/streams.hpp

@@ -16,7 +16,7 @@
 #include <stream/transform_view.h>
 #include <stream/tuple_view.h>
 
-#include <stream/view.h>
+#include <stream/any_view.h>
 
 #include <stream/count.h>
 #include <stream/fold.h>

include/stream/to.h

@@ -32,7 +32,7 @@ public:
 
 template <template <typename...> class C> struct to_range {
   template <typename Stream> friend auto operator|(Stream && stream, to_range) {
-    if constexpr (traits::is_sentinal_v<Stream>) {
+    if constexpr (detail::is_sentinal_v<Stream>) {
       common_view common(FWD(stream));
       return C(common.begin(), common.end());
     } else {

include/stream/transform_view.h

@@ -6,6 +6,8 @@
 #include <stream/detail/traits.h>
 #include <stream/forward.h>
 
+#include <iterator/detail/macro.h>
+
 #define FWD(x) std::forward<decltype(x)>(x)
 
 namespace stream::ranges {
@@ -40,30 +42,22 @@ public:
       : stream_(FWD(stream)), projection_(projection) {}
 
   auto begin() const { return transform_iterator(stream_.begin(), invoke()); }
-  
+
   auto end() const {
-    if constexpr (traits::is_sentinal_v<S>) {
+    if constexpr (detail::is_sentinal_v<S>) {
       return stream_.end();
     } else {
       return transform_iterator(stream_.end(), invoke());
     }
   }
-  
-  auto empty() const {
-    if constexpr (traits::has_empty_v<S>) {
-      return stream_.empty();
-    }
-  }
-  
-  auto size() {
-    if constexpr (traits::has_size_v<S>) {
-      return stream_.size();
-    }
-  }
+
+  SFINAE(detail::has_empty_v<S>, bool) empty() const { return stream_.empty(); }
+
+  SFINAE(detail::has_size_v<S>, size_t) size() { return stream_.size(); }
 
 private:
   auto invoke() const {
-    return std::function([this](traits::cref_t<S> t) -> decltype(auto) {
+    return std::function([this](detail::cref_t<S> t) -> decltype(auto) {
       return std::invoke(projection_, t);
     });
   }
@@ -92,3 +86,4 @@ private:
 }
 
 #undef FWD
+#include <iterator/detail/undef.h>

include/stream/view.h

@@ -1,99 +0,0 @@
-//
-//  view.h
-//  stream
-//
-//  Created by Sam Jaffe on 3/29/23.
-//
-
-#pragma once
-
-namespace stream::ranges {
-
-template <typename T>
-class view_iterator : public facade<view_iterator<T>> {
-private:
-  T (*dereference_)(void *){nullptr};
-  bool (*equal_to_)(void *, void *){nullptr};
-  void (*increment_)(void *){nullptr};
-  std::shared_ptr<void> impl_{nullptr};
-
-public:
-  template <typename It>
-  view_iterator(It impl)
-      : dereference_([](void * p) -> T { return **((It *)p); }),
-        equal_to_(
-            [](void * l, void * r) { return *((It *)l) == *((It *)r); }),
-        increment_([](void * p) { ++(*(It *)(p)); }),
-        impl_(std::make_shared<It>(impl)) {}
-
-  T dereference() const { return dereference_(impl_.get()); }
-  
-  void increment() { increment_(impl_.get()); }
-  
-  bool equal_to(view_iterator const & other) const {
-    return impl_ == other.impl_ ||
-           (impl_ && other.impl_ &&
-            equal_to_(impl_.get(), other.impl_.get()));
-  }
-};
-
-template <typename T> class view {
-private:
-  using make_iter_t = view_iterator<T>(*)(void*);
-private:
-  std::shared_ptr<void> impl_{nullptr};
-  make_iter_t begin_{nullptr};
-  make_iter_t end_{nullptr};
-
-public:
-  template <typename S>
-  view(std::shared_ptr<S> impl)
-      : impl_(impl), begin_(begin_function<S>()), end_(end_function<S>()) {}
-
-  template <typename S>
-  view(S & impl) : view(std::shared_ptr<S>(&impl, [](void *) {})) {}
-
-  template <typename S>
-  view(S const & impl) : view(std::shared_ptr<S const>(&impl, [](void *) {})) {}
-
-  template <typename S>
-  view(S && impl) : view(std::make_shared<S>(std::forward<S>(impl))) {}
-
-  auto begin() const { return begin_(impl_.get()); }
-  auto end() const { return end_(impl_.get()); }
-  
-private:
-  template <typename S>
-  static make_iter_t begin_function() {
-    if constexpr (traits::is_sentinal_v<S>) {
-      return [](void *p) -> view_iterator<T> {
-        return iterator::sentinel_iterator(static_cast<S *>(p)->begin());
-      };
-    } else {
-      return [](void * p) -> view_iterator<T> {
-        return static_cast<S *>(p)->begin();
-      };
-    }
-  }
-  
-  template <typename S>
-  static make_iter_t end_function() {
-    if constexpr (traits::is_sentinal_v<S>) {
-      return [](void *p) -> view_iterator<T> {
-        return iterator::sentinel_iterator<iter<S>>();
-      };
-    } else {
-      return [](void * p) -> view_iterator<T> {
-        return static_cast<S *>(p)->end();
-      };
-    }
-  }
-
-};
-
-template <typename S> view(std::shared_ptr<S>) -> view<traits::value_type<S>>;
-template <typename S> view(S &) -> view<traits::value_type<S>>;
-template <typename S> view(S const &) -> view<traits::value_type<S>>;
-template <typename S> view(S &&) -> view<traits::value_type<S>>;
-
-}

stream.xcodeproj/project.pbxproj

@@ -78,7 +78,7 @@
 		CD52827829D4EF0E001A84DE /* single_view.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = single_view.h; sourceTree = "<group>"; };
 		CD52827929D4EF43001A84DE /* owning_view.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = owning_view.h; sourceTree = "<group>"; };
 		CD52827A29D4EFBE001A84DE /* iota_view.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = iota_view.h; sourceTree = "<group>"; };
-		CD52827B29D4F764001A84DE /* view.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = view.h; sourceTree = "<group>"; };
+		CD52827B29D4F764001A84DE /* any_view.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = any_view.h; sourceTree = "<group>"; };
 		CD52827C29D4FB11001A84DE /* to.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = to.h; sourceTree = "<group>"; };
 		CD52827D29D50081001A84DE /* for_each.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = for_each.h; sourceTree = "<group>"; };
 		CD52827E29D50BFA001A84DE /* reference_view.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = reference_view.h; sourceTree = "<group>"; };
@@ -90,7 +90,6 @@
 		CD64CCB926232D6900770A30 /* xcode_gtest_helper.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = xcode_gtest_helper.h; sourceTree = "<group>"; };
 		CD6EBE1C29D5C61700F387C1 /* common_view.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = common_view.h; sourceTree = "<group>"; };
 		CD6EBE2329D5CAD900F387C1 /* size.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = size.h; sourceTree = "<group>"; };
-		CD6EBE2429D5CE6500F387C1 /* sentinal.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = sentinal.h; sourceTree = "<group>"; };
 		CD6EBE2629D63B9E00F387C1 /* minmax.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = minmax.h; sourceTree = "<group>"; };
 		CD9337281E3CD78B00699FF5 /* stream_test.cxx */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = stream_test.cxx; sourceTree = "<group>"; };
 		CDAA170121A3A738007BBA11 /* stream */ = {isa = PBXFileReference; lastKnownFileType = folder; name = stream; path = include/stream; sourceTree = "<group>"; };
@@ -163,7 +162,7 @@
 				CD52827F29D50E24001A84DE /* fold.h */,
 				CD5A8D3529D63C05008C2A4F /* count.h */,
 				CD6EBE2629D63B9E00F387C1 /* minmax.h */,
-				CD52827B29D4F764001A84DE /* view.h */,
+				CD52827B29D4F764001A84DE /* any_view.h */,
 				CD5281F029D3B173001A84DE /* forward.h */,
 				CD5281F729D3B173001A84DE /* streams.hpp */,
 			);
@@ -176,7 +175,6 @@
 				CD52828029D51166001A84DE /* identity.h */,
 				CD5A8D3B29D63DF5008C2A4F /* named_pair.h */,
 				CD5281EC29D3B173001A84DE /* traits.h */,
-				CD6EBE2429D5CE6500F387C1 /* sentinal.h */,
 			);
 			path = detail;
 			sourceTree = "<group>";