diff --git a/include/preview/__ranges/views/join_view.h b/include/preview/__ranges/views/join_view.h
index b92ffde..a78b143 100644
--- a/include/preview/__ranges/views/join_view.h
+++ b/include/preview/__ranges/views/join_view.h
@@ -19,12 +19,14 @@
 #include "preview/__iterator/iter_move.h"
 #include "preview/__iterator/iter_swap.h"
 #include "preview/__memory/addressof.h"
+#include "preview/optional.h"
 #include "preview/__ranges/bidirectional_range.h"
 #include "preview/__ranges/common_range.h"
 #include "preview/__ranges/simple_view.h"
 #include "preview/__ranges/forward_range.h"
 #include "preview/__ranges/input_range.h"
 #include "preview/__ranges/movable_box.h"
+#include "preview/__ranges/non_propagating_cache.h"
 #include "preview/__ranges/range_difference_t.h"
 #include "preview/__ranges/range_reference_t.h"
 #include "preview/__ranges/sentinel_t.h"
@@ -43,6 +45,11 @@ namespace preview {
 namespace ranges {
 namespace detail {
 
+template <class T>
+constexpr T& as_lvalue(T&& x) noexcept {
+  return static_cast<T&>(x);
+}
+
 template<typename Base>
 using join_view_iterator_concept =
     conditional_t<
@@ -92,26 +99,97 @@ struct join_view_iterator_category<Base, forward_iterator_tag> {
       >;
 };
 
-} // namespace detail
+template<typename Base, typename OuterIter, bool Present = forward_range<Base>::value /* true */>
+struct join_view_iterator_outer_iter {
+  join_view_iterator_outer_iter() = default;
 
-template<typename V>
-class join_view : public view_interface<join_view<V>> {
+  explicit join_view_iterator_outer_iter(OuterIter outer)
+      : outer_(std::move(outer)) {}
+
+  template<typename Parent>
+  constexpr OuterIter& outer(Parent&) {
+    return outer_;
+  }
+
+  template<typename Parent>
+  constexpr const OuterIter& outer(Parent&) const {
+    return outer_;
+  }
+
+  OuterIter outer_ = OuterIter();
+};
+
+template<typename Base, typename OuterIter>
+struct join_view_iterator_outer_iter<Base, OuterIter, false> {
+  join_view_iterator_outer_iter() = default;
+
+  explicit join_view_iterator_outer_iter(OuterIter) {}
+
+  template<typename Parent>
+  constexpr OuterIter& outer(Parent& p) {
+    return *p->outer_;
+  }
+
+  template<typename Parent>
+  constexpr const OuterIter& outer(Parent& p) const {
+    return *p->outer_;
+  }
+};
+
+template<typename JoinView, typename V, bool UseCache = negation<forward_range<V>>::value /* true */>
+class join_view_outer_base : public view_interface<JoinView> {
  public:
-  static_assert(input_range<V>::value, "Constraints not satisfied");
-  static_assert(view<V>::value, "Constraints not satisfied");
-  static_assert(input_range<range_reference_t<V>>::value, "Constraints not satisfied");
 
+
+
+ protected:
+  non_propagating_cache<iterator_t<V>> outer_;
+};
+
+template<typename JoinView, typename V>
+class join_view_outer_base<JoinView, V, false> : public view_interface<JoinView> {
+ public:
+
+};
+
+template<typename JoinView, typename V, bool UseCache = negation<std::is_reference<range_reference_t<V>>>::value /* true */>
+class join_view_inner_base : public join_view_outer_base<JoinView, V> {
+ public:
+
+ protected:
+  non_propagating_cache<std::remove_cv_t<range_reference_t<V>>> inner_;
+};
+
+template<typename JoinView, typename V>
+class join_view_inner_base<JoinView, V, false> : public join_view_outer_base<JoinView, V> {
+ public:
+};
+
+} // namespace detail
+
+template<typename V>
+class join_view : public detail::join_view_inner_base<join_view<V>, V> {
  private:
   template <bool Const>
   using InnerRng = range_reference_t<maybe_const<Const, V>>;
 
  public:
+  static_assert(input_range<V>::value, "Constraints not satisfied");
+  static_assert(view<V>::value, "Constraints not satisfied");
+  static_assert(input_range<range_reference_t<V>>::value, "Constraints not satisfied");
+
   template<bool Const> class iterator;
   template<bool Const> friend class iterator;
   template<bool Const> class sentinel;
 
   template<bool Const>
-  class iterator : detail::join_view_iterator_category<maybe_const<Const, V>> {
+  class iterator
+      : public detail::join_view_iterator_category<maybe_const<Const, V>>
+      , private detail::join_view_iterator_outer_iter<
+            maybe_const<Const, V>, // Base
+            iterator_t<maybe_const<Const, V>> // OuterIter
+        >
+  {
     using Parent = maybe_const<Const, join_view>;
     using Base = maybe_const<Const, V>;
     using OuterIter = iterator_t<Base>;
@@ -121,6 +199,71 @@ class join_view : public view_interface<join_view<V>> {
     friend class join_view;
     template<bool> friend class sentinel;
 
+    using outer_iter_base = detail::join_view_iterator_outer_iter<
+        maybe_const<Const, V>,
+        iterator_t<maybe_const<Const, V>>
+    >;
+
+    constexpr OuterIter& outer() {
+      return outer_iter_base::outer(parent_);
+    }
+
+    constexpr const OuterIter& outer() const {
+      return outer_iter_base::outer(parent_);
+    }
+
+    constexpr decltype(auto) update_inner_impl(const iterator_t<Base>& x, std::true_type /* ref_is_glvalue */) {
+      return *x;
+    }
+    constexpr decltype(auto) update_inner_impl(const iterator_t<Base>& x, std::false_type /* ref_is_glvalue */) {
+      return parent_->inner_.emplace_deref(x);
+    }
+
+    constexpr decltype(auto) update_inner(const iterator_t<Base>& x) {
+      return update_inner_impl(x, bool_constant<ref_is_glvalue>{});
+    }
+
+    constexpr void satisfy_impl(std::true_type /* ref_is_glvalue */) {
+      for (; outer() != ranges::end(parent_->base_); ++outer()) {
+        auto&& inner = update_inner(outer());
+        inner_ = ranges::begin(inner);
+        if (*inner_ != ranges::end(inner))
+          return;
+      }
+      inner_.reset();
+    }
+    constexpr void satisfy_impl(std::false_type /* ref_is_glvalue */) {
+      for (; outer() != ranges::end(parent_->base_); ++outer()) {
+        auto&& inner = update_inner(outer());;
+        inner_ = ranges::begin(inner);
+        if (inner_ != ranges::end(inner))
+          return;
+      }
+    }
+
+    constexpr void satisfy() {
+      satisfy_impl(bool_constant<ref_is_glvalue>{});
+    }
+
+    template<typename Dummy = void, std::enable_if_t<conjunction<std::is_void<Dummy>,
+        forward_range<Base>
+    >::value, int> = 0>
+    constexpr iterator(Parent& parent, OuterIter outer)
+        : outer_iter_base(std::move(outer))
+        , parent_(preview::addressof(parent))
+    {
+      satisfy();
+    }
+
+    template<typename Dummy = void, std::enable_if_t<conjunction<std::is_void<Dummy>,
+        negation<forward_range<Base>>
+    >::value, int> = 0>
+    constexpr explicit iterator(Parent& parent)
+        : parent_(preview::addressof(parent))
+    {
+      satisfy();
+    }
+
    public:
     using iterator_concept = detail::join_view_iterator_concept<Base>;
 
@@ -131,18 +274,7 @@ class join_view : public view_interface<join_view<V>> {
     using reference = decltype(**std::declval<movable_box<InnerIter>&>());
 #endif
 
-    template<typename O = OuterIter, std::enable_if_t<conjunction<
-        default_initializable<O>,
-        default_initializable<InnerIter>
-    >::value, int> = 0>
-    iterator()
-        : outer_(), inner_(), parent_(nullptr) {}
-
-    constexpr iterator(Parent& parent, OuterIter outer)
-        : outer_(std::move(outer)), parent_(preview::addressof(parent))
-    {
-      satisfy();
-    }
+    iterator() = default;
 
     template<bool AntiConst, std::enable_if_t<conjunction<
         bool_constant<((Const != AntiConst) && Const)>,
@@ -150,51 +282,56 @@ class join_view : public view_interface<join_view<V>> {
         convertible_to<iterator_t<InnerRng<false>>, InnerIter>
     >::value, int> = 0>
     constexpr iterator(iterator<AntiConst> i)
-        : outer_(std::move(i.outer_)), inner_(std::move(i.inner_)), parent_(i.parent_) {}
+        : outer_iter_base(std::move(i.outer()))
+        , inner_(std::move(i.inner_))
+        , parent_(i.parent_) {}
 
     constexpr decltype(auto) operator*() const {
       return **inner_;
     }
 
-    template<typename II = InnerIter, std::enable_if_t<conjunction<
-        has_operator_arrow<II>,
-        copyable<II>
+    template<typename Dummy = void, std::enable_if_t<conjunction<std::is_void<Dummy>,
+        has_operator_arrow<InnerIter>,
+        copyable<InnerIter>
     >::value, int> = 0>
     constexpr decltype(auto) operator->() const {
       return *inner_;
     }
 
-    template<bool B = ref_is_glvalue, std::enable_if_t<B, int> = 0>
     constexpr iterator& operator++() {
-      auto&& inner_rng = *outer_;
-      if (++*inner_ == ranges::end(inner_rng)) {
-        ++outer_;
+      return pre_increment(bool_constant<ref_is_glvalue>{});
+    }
+
+   private:
+    constexpr iterator& pre_increment(std::true_type) {
+      if (++*inner_ == ranges::end(detail::as_lvalue(*outer()))) {
+        ++outer();
         satisfy();
       }
       return *this;
     }
-
-    template<bool B = ref_is_glvalue, std::enable_if_t<B == false, int> = 0>
-    constexpr iterator& operator++() {
-      auto&& inner_rng = *parent_->inner_;
-      if (++*inner_ == ranges::end(inner_rng)) {
-        ++outer_;
+    constexpr iterator& pre_increment(std::false_type) {
+      if (++*inner_ == ranges::end(detail::as_lvalue(*parent_->inner_))) {
+        ++outer();
         satisfy();
       }
       return *this;
     }
 
-    template<bool B = ref_is_glvalue, std::enable_if_t<conjunction<
-        bool_constant<B>,
-        forward_range<Base>,
-        forward_range<range_reference_t<Base>>
-    >::value == false, int> = 0>
+   public:
+    template<typename Dummy = void, std::enable_if_t<conjunction<std::is_void<Dummy>,
+        negation<conjunction<
+            bool_constant<ref_is_glvalue>,
+            forward_range<Base>,
+            forward_range<range_reference_t<Base>>
+        >>
+    >::value, int> = 0>
     constexpr void operator++(int) {
       ++*this;
     }
 
-    template<bool B = ref_is_glvalue, std::enable_if_t<conjunction<
-        bool_constant<B>,
+    template<typename Dummy = void, std::enable_if_t<conjunction<std::is_void<Dummy>,
+        bool_constant<ref_is_glvalue>,
         forward_range<Base>,
         forward_range<range_reference_t<Base>>
     >::value, int> = 0>
@@ -204,23 +341,23 @@ class join_view : public view_interface<join_view<V>> {
       return tmp;
     }
 
-    template<bool B = ref_is_glvalue, std::enable_if_t<conjunction<
-        bool_constant<B>,
+    template<typename Dummy = void, std::enable_if_t<conjunction<std::is_void<Dummy>,
+        bool_constant<ref_is_glvalue>,
         bidirectional_range<Base>,
         bidirectional_range<range_reference_t<Base>>,
         common_range<range_reference_t<Base>>
     >::value, int> = 0>
     constexpr iterator& operator--() {
-      if (outer_ == ranges::end(parent_->base_))
-        inner_ = ranges::end(*--outer_);
-      while (*inner_ == ranges::begin(*outer_))
-        inner_ = ranges::end(*--outer_);
+      if (outer() == ranges::end(parent_->base_))
+        inner_ = ranges::end(detail::as_lvalue(*--outer()));
+      while (*inner_ == ranges::begin(detail::as_lvalue(*outer())))
+        inner_ = ranges::end(detail::as_lvalue(*--outer()));
       --*inner_;
       return *this;
     }
 
-    template<bool B = ref_is_glvalue, std::enable_if_t<conjunction<
-        bool_constant<B>,
+    template<typename Dummy = void, std::enable_if_t<conjunction<std::is_void<Dummy>,
+        bool_constant<ref_is_glvalue>,
         bidirectional_range<Base>,
         bidirectional_range<range_reference_t<Base>>,
         common_range<range_reference_t<Base>>
@@ -231,22 +368,18 @@ class join_view : public view_interface<join_view<V>> {
       return tmp;
     }
 
-    constexpr void satisfy() {
-      satisfy_impl(bool_constant<ref_is_glvalue>{});
-    }
-
-    template<bool B = ref_is_glvalue, std::enable_if_t<conjunction<
-        bool_constant<B>,
-        equality_comparable<iterator_t<Base>>,
+    template<typename Dummy = void, std::enable_if_t<conjunction<std::is_void<Dummy>,
+        bool_constant<ref_is_glvalue>,
+        forward_range<Base>,
         equality_comparable<iterator_t<range_reference_t<Base>>>
     >::value, int> = 0>
     friend constexpr bool operator==(const iterator& x, const iterator& y) {
-      return (x.outer_ == y.outer_) && (*x.inner_ == *y.inner_);
+      return (x.outer_ == y.outer_) && (x.inner_ == y.inner_);
     }
 
-    template<bool B = ref_is_glvalue, std::enable_if_t<conjunction<
-        bool_constant<B>,
-        equality_comparable<iterator_t<Base>>,
+    template<typename Dummy = void, std::enable_if_t<conjunction<std::is_void<Dummy>,
+        bool_constant<ref_is_glvalue>,
+        forward_range<Base>,
         equality_comparable<iterator_t<range_reference_t<Base>>>
     >::value, int> = 0>
     friend constexpr bool operator!=(const iterator& x, const iterator& y) {
@@ -259,66 +392,19 @@ class join_view : public view_interface<join_view<V>> {
       return ranges::iter_move(*i.inner_);
     }
 
-    template<typename II = InnerIter, std::enable_if_t<indirectly_swappable<II>::value, int> = 0>
+    template<typename Dummy = void, std::enable_if_t<conjunction<std::is_void<Dummy>,
+        indirectly_swappable<InnerIter>
+    >::value, int> = 0>
     friend constexpr void iter_swap(const iterator& x, const iterator& y)
         noexcept(noexcept(ranges::iter_swap(*x.inner_, *y.inner_)))
     {
-      ranges::iter_swap(x.inner_, y.inner_);
+      ranges::iter_swap(*x.inner_, *y.inner_);
     }
 
    private:
-    constexpr OuterIter& get_outer() noexcept {
-      return get_outer(forward_range<Base>{});
-    }
-    constexpr const OuterIter& get_outer() const noexcept {
-      return get_outer(forward_range<Base>{});
-    }
-    constexpr OuterIter& get_outer_impl(std::true_type /* forward_range */) noexcept {
-        return outer_;
-    }
-    constexpr OuterIter& get_outer_impl(std::false_type /* forward_range */) noexcept {
-        return *parent_->outer_;
-    }
-    constexpr OuterIter& get_outer_impl(std::true_type /* forward_range */) const noexcept {
-        return outer_;
-    }
-    constexpr OuterIter& get_outer_impl(std::false_type /* forward_range */) const noexcept {
-        return *parent_->outer_;
-    }
-
-    constexpr decltype(auto) update_inner_impl(const iterator_t<Base>& x, std::true_type /* ref_is_glvalue */) {
-      return *x;
-    }
-    constexpr decltype(auto) update_inner_impl(const iterator_t<Base>& x, std::false_type /* ref_is_glvalue */) {
-      return parent_->inner_.emplace(x);
-    }
-
-    constexpr decltype(auto) update_inner(const iterator_t<Base>& x) {
-      return update_inner_impl(x, bool_constant<ref_is_glvalue>{});
-    }
 
-    constexpr void satisfy_impl(std::true_type /* ref_is_glvalue */) {
-      for (; outer_ != ranges::end(parent_->base_); ++outer_) {
-        auto&& inner = update_inner(outer_);
-        inner_ = ranges::begin(inner);
-        if (*inner_ != ranges::end(inner))
-          return;
-      }
-
-      inner_ = InnerIter();
-    }
-    constexpr void satisfy_impl(std::false_type /* ref_is_glvalue */) {
-      for (; outer_ != ranges::end(parent_->base_); ++outer_) {
-        auto&& inner = update_inner(outer_);;
-        inner_ = ranges::begin(inner);
-        if (inner_ != ranges::end(inner))
-          return;
-      }
-    }
-
-    OuterIter outer_;
-    movable_box<InnerIter> inner_;
-    Parent* parent_;
+    optional<InnerIter> inner_;
+    Parent* parent_ = nullptr;
   };
 
   template<bool Const>
@@ -339,33 +425,46 @@ class join_view : public view_interface<join_view<V>> {
     constexpr sentinel(sentinel<AntiConst> s)
         : end_(std::move(s.end_)) {}
 
-    friend constexpr bool operator==(const iterator<Const>& x, const sentinel& y) {
-      using namespace preview::rel_ops;
-      return x.get_outer() == y.end_;
+    template<bool OtherConst, std::enable_if_t<
+        sentinel_for<sentinel_t<Base>, iterator_t<maybe_const<OtherConst, V>>>
+    ::value, int> = 0>
+    friend constexpr bool operator==(const iterator<OtherConst>& x, const sentinel& y) {
+      return x.outer() == y.end_;
     }
 
-    friend constexpr bool operator==(const sentinel& y, const iterator<Const>& x) {
-      return x == y;
+    template<bool OtherConst, std::enable_if_t<
+        sentinel_for<sentinel_t<Base>, iterator_t<maybe_const<OtherConst, V>>>
+    ::value, int> = 0>
+    friend constexpr bool operator!=(const iterator<OtherConst>& x, const sentinel& y) {
+      return !(x == y);
     }
 
-    friend constexpr bool operator!=(const iterator<Const>& x, const sentinel& y) {
-      return !(x == y);
+    template<bool OtherConst, std::enable_if_t<
+        sentinel_for<sentinel_t<Base>, iterator_t<maybe_const<OtherConst, V>>>
+    ::value, int> = 0>
+    friend constexpr bool operator==(const sentinel& y, const iterator<OtherConst>& x) {
+      return x == y;
     }
 
-    friend constexpr bool operator!=(const sentinel& y, const iterator<Const>& x) {
+    template<bool OtherConst, std::enable_if_t<
+        sentinel_for<sentinel_t<Base>, iterator_t<maybe_const<OtherConst, V>>>
+    ::value, int> = 0>
+    friend constexpr bool operator!=(const sentinel& y, const iterator<OtherConst>& x) {
       return !(x == y);
     }
 
    private:
-    sentinel_t<Base> end_;
+    sentinel_t<Base> end_{};
   };
 
-  template<typename V2 = V, std::enable_if_t<default_initializable<V2>::value, int> = 0>
-  join_view() : base_(V()) {}
+  join_view() = default;
 
-  constexpr explicit join_view(V base) : base_(std::move(base)) {}
+  constexpr explicit join_view(V base)
+      : base_(std::move(base)) {}
 
-  template<typename V2 = V, std::enable_if_t<copy_constructible<V2>::value, int> = 0>
+  template<typename Dummy = void, std::enable_if_t<conjunction<std::is_void<Dummy>,
+      copy_constructible<V>
+  >::value, int> = 0>
   constexpr V base() const& {
     return base_;
   }
@@ -374,59 +473,76 @@ class join_view : public view_interface<join_view<V>> {
     return std::move(base_);
   }
 
+  // vvvvvvvvvv begin vvvvvvvvvv
   constexpr auto begin() {
-    using B = conjunction<simple_view<V>, std::is_reference<range_reference_t<V>>>;
+    return begin_impl(forward_range<V>{});
+  }
+
+ private:
+  constexpr auto begin_impl(std::true_type /* forward_range<V> */) {
+    using B = conjunction<simple_view<V>, std::is_reference<InnerRng<false>>>;
     return iterator<B::value>{*this, ranges::begin(base_)};
   }
+  constexpr auto begin_impl(std::false_type /* forward_range<V> */) {
+    this->outer_ = ranges::begin(base_);
+    return iterator<false>{*this};
+  }
+  // ^^^^^^^^^^ begin ^^^^^^^^^^
 
-  template<typename V2 = V, std::enable_if_t<conjunction<
-      input_range<const V2>,
-      std::is_reference<range_reference_t<const V2>>
+ public:
+  template<typename Dummy = void, std::enable_if_t<conjunction<std::is_void<Dummy>,
+      forward_range<const V>,
+      std::is_reference<range_reference_t<const V>>,
+      input_range<range_reference_t<const V>>
   >::value, int> = 0>
   constexpr auto begin() const {
     return iterator<true>{*this, ranges::begin(base_)};
   }
 
+  // vvvvvvvvvv end() vvvvvvvvvv
+
   constexpr auto end() {
     return end_impl(conjunction<
         forward_range<V>,
-        std::is_reference<range_reference_t<V>>,
-        forward_range<range_reference_t<V>>,
-        common_range<V>,
-        common_range<range_reference_t<V>>
-      >{});
+        std::is_reference<InnerRng<false>>, forward_range<InnerRng<false>>,
+        common_range<V>, common_range<InnerRng<false>>
+    >{});
+  }
+
+ private:
+  constexpr auto end_impl(std::true_type) {
+    return iterator<simple_view<V>::value>{*this, ranges::end(base_)};
+  }
+  constexpr auto end_impl(std::false_type) {
+    return sentinel<simple_view<V>::value>{*this};
   }
+  // ^^^^^^^^^^ end() ^^^^^^^^^^
 
-  template<typename V2 = V, std::enable_if_t<conjunction<
-      input_range<const V2>,
-      std::is_reference<range_reference_t<const V2>>
+  // vvvvvvvvvv end() const vvvvvvvvvv
+ public:
+  template<typename Dummy = void, std::enable_if_t<conjunction<std::is_void<Dummy>,
+      forward_range<const V>,
+      std::is_reference<range_reference_t<const V>>,
+      input_range<range_reference_t<const V>>
   >::value, int> = 0>
   constexpr auto end() const {
     return end_impl(conjunction<
-        forward_range<const V>,
-        std::is_reference<range_reference_t<const V>>,
         forward_range<range_reference_t<const V>>,
         common_range<const V>,
         common_range<range_reference_t<const V>>
-      >{});
+    >{});
   }
 
  private:
-  constexpr auto end_impl(std::true_type) {
-    return iterator<simple_view<V>::value>{*this, ranges::end(base_)};
-  }
-  constexpr auto end_impl(std::false_type) {
-    return sentinel<simple_view<V>::value>{*this};
-  }
-
   constexpr auto end_impl(std::true_type) const {
     return iterator<true>{*this, ranges::end(base_)};
   }
   constexpr auto end_impl(std::false_type) const {
     return sentinel<true>{*this};
   }
+  // ^^^^^^^^^^ end() const ^^^^^^^^^^
 
-  V base_;
+  V base_{};
 };
 
 #if __cplusplus >= 201703L
diff --git a/test/ranges_views.cc b/test/ranges_views.cc
index 572af0c..7e725cf 100644
--- a/test/ranges_views.cc
+++ b/test/ranges_views.cc
@@ -723,3 +723,40 @@ TEST(VERSIONED(RangesViews), drop_while_view) {
       {3, 4, 5}
   ));
 }
+
+TEST(VERSIONED(RangesViews), join_view) {
+  using namespace std::literals;
+  using namespace preview::literals;
+
+  const auto bits = {"https:"sv, "//"sv, "cppreference"sv, "."sv, "com"sv};
+  for (char const c : bits | views::join)
+    std::cout << c;
+  std::cout << '\n';
+  EXPECT_TRUE(ranges::equal(bits | views::join, "https://cppreference.com"_sv));
+
+  const std::vector<std::vector<int>> v{{1, 2}, {3, 4, 5}, {6}, {7, 8, 9}};
+#if PREVIEW_CXX_VERSION >= 17
+  auto jv = ranges::join_view(v);
+#else
+  auto jv = views::join(v);
+#endif
+  for (int const e : jv)
+    std::cout << e << ' ';
+  std::cout << '\n';
+  EXPECT_TRUE(ranges::equal(jv, views::iota(1, 10)));
+
+  std::vector<std::string> ss{"hello", " ", "world", "!"};
+  for (char ch : ss | views::join)
+    std::cout << ch;
+  EXPECT_TRUE(ranges::equal(
+      ss | views::join,
+      "hello world!"s
+  ));
+}
+
+struct Person { int age; std::string name; };
+TEST(VERSIONED(RangesViews), join_view_P2328R1) {
+  std::vector<Person> v;
+  (void)(v | views::transform([](auto& p) -> std::string& { return p.name; })
+           | views::join); // OK
+}