diff --git a/concat.md b/concat.md
index 7afa32a..e70ca07 100644
--- a/concat.md
+++ b/concat.md
@@ -13,6 +13,12 @@ toc: true
 
 # Revision History
 
+## R4
+ - Added additional constraint to `views::concat` to disable any combination of
+   range arguments that has a prvalue reference type, and another with a that of a
+   reference to that same type. Also added `views::concat_magic` to neglect this
+   additional constraint.
+
 ## R3
 
 - Redesigned `iter_swap`
@@ -463,12 +469,13 @@ namespace std::ranges {
   // [...]
 
   // [range.concat], concat view
-  template <input_range... Views>
+  template <bool allow_magic, input_range... Views>
     requires @*see below*@
   class concat_view;
 
   namespace views {
     inline constexpr @_unspecified_@ concat = @_unspecified_@;
+    inline constexpr @_unspecified_@ concat_magic = @_unspecified_@;
   }
 
 }
@@ -524,13 +531,21 @@ Add the following subclause to [range.adaptors]{.sref}.
 [1]{.pnum} `concat_view` presents a `view` that concatenates all the underlying
 ranges.
 
-[2]{.pnum} The name `views::concat` denotes a customization point object
+[2]{.pnum} The names `views::concat` and `views::concat_magic` denote two customization point objects
 ([customization.point.object]{.sref}). Given a pack of subexpressions `Es...`,
 the expression `views::concat(Es...)` is expression-equivalent to
 
 - [2.1]{.pnum} `views::all(Es...)` if `Es` is a pack with only one element
         and `views::all(Es...)` is a well formed expression,
-- [2.2]{.pnum} otherwise, `concat_view(Es...)`
+- [2.2]{.pnum} otherwise, `concat_view(Es...)`, which is deduced to be the type
+  `concat_view<false, views::all_t<Es>...>`.
+
+And, the expression `views::concat_magic(Es...)` is expression-equivalent to
+
+- [2.3]{.pnum} `views::all(Es...)` if `Es` is a pack with only one element
+        and `views::all(Es...)` is a well formed expression,
+- [2.4]{.pnum} otherwise, `concat_view<true, views::all_t<Es...>>(Es...)`.
+
 
 \[*Example:*
 ```cpp
@@ -561,6 +576,9 @@ namespace std::ranges {
   concept @*concat-indirectly-readable*@ = @*see below*@; // exposition only
 
   template <class... Rs>
+  concept @*concat-no-magic*@ =  @*see below*@; // exposition only
+
+  template <bool allow_magic, class... Rs>
   concept @_concatable_@ = @*see below*@;             // exposition only
 
   template <bool Const, class... Rs>
@@ -574,10 +592,10 @@ namespace std::ranges {
   template <bool Const, class... Rs>
   concept @_concat-is-bidirectional_@ = @*see below*@;   // exposition only
 
-  template <input_range... Views>
+  template <bool allow_magic, input_range... Views>
     requires (view<Views> && ...) && (sizeof...(Views) > 0) &&
-              @_concatable_@<Views...>
-  class concat_view : public view_interface<concat_view<Views...>> {
+              @_concatable_@<allow_magic, Views...>
+  class concat_view : public view_interface<concat_view<allow_magic, Views...>> {
     tuple<Views...> @*views_*@;                   // exposition only
 
     template <bool Const>
@@ -603,7 +621,7 @@ namespace std::ranges {
   };
 
   template <class... R>
-    concat_view(R&&...) -> concat_view<views::all_t<R>...>;
+    concat_view(R&&...) -> concat_view<false, views::all_t<R>...>;
 }
 ```
 
@@ -640,8 +658,29 @@ concept @*concat-indirectly-readable*@ = // exposition only
 
 :::
 
+
+```cpp
+template <class... Rs>
+concept @*concat-no-magic*@ =  @*see below*@; // exposition only
+```
+
+:::bq
+
+[2]{.pnum} The exposition-only `@*concat-no-magic*@` concept is equivalent to:
+
 ```cpp
 template <class... Rs>
+concept @*concat-no-magic*@ =  // exposition only
+    is_reference_v<@*concat-reference-t*@<Rs...>> ||
+    (is_reference_v<range_reference_t<Rs>> && ...) &&
+    (!same_as<remove_reference_t<range_reference_t<Rs>>,
+              @*concat-reference-t*@<Rs...>> && ...);
+```
+
+:::
+
+```cpp
+template <bool allow_magic, class... Rs>
 concept @_concatable_@ = @*see below*@; // exposition only
 ```
 
@@ -651,12 +690,13 @@ concept @_concatable_@ = @*see below*@; // exposition only
 concept is equivalent to:
 
 ```cpp
-template <class... Rs>
+template <bool allow_magic, class... Rs>
 concept @_concatable_@ = requires { // exposition only
   typename @*concat-reference-t*@<Rs...>;
   typename @*concat-value-t*@<Rs...>;
   typename @*concat-rvalue-reference-t*@<Rs...>;
-} && @*concat-indirectly-readable*@<Rs...>;
+} && @*concat-indirectly-readable*@<Rs...>
+  && (allow_magic || @*concat-no-magic*@<Rs...>);
 ```
 
 :::
@@ -709,7 +749,7 @@ constexpr explicit concat_view(Views... views);
 ```cpp
 constexpr @_iterator_@<false> begin() requires(!(@_simple-view_@<Views> && ...));
 constexpr @_iterator_@<true> begin() const
-  requires((range<const Views> && ...) && @_concatable_@<const Views...>);
+  requires((range<const Views> && ...) && @_concatable_@<allow_magic, const Views...>);
 ```
 
 :::bq
@@ -774,11 +814,11 @@ return apply(
 ```cpp
 namespace std::ranges{
 
-  template <input_range... Views>
+  template <bool allow_magic, input_range... Views>
     requires (view<Views> && ...) && (sizeof...(Views) > 0) &&
-              @_concatable_@<Views...>
+              @_concatable_@<allow_magic, Views...>
   template <bool Const>
-  class concat_view<Views...>::@_iterator_@ {
+  class concat_view<allow_magic, Views...>::@_iterator_@ {
   
   public:
     using iterator_category = @*see below*@;                  // not always present.
diff --git a/impl/concat/concat.hpp b/impl/concat/concat.hpp
index a21c71f..ee2595a 100644
--- a/impl/concat/concat.hpp
+++ b/impl/concat/concat.hpp
@@ -37,6 +37,16 @@ using concat_rvalue_reference_t =
 template <class... Rs>
 using concat_value_t = common_type_t<range_value_t<Rs>...>;
 
+template <class... Rs>
+concept concat_no_magic =  // modelled only if concat reference_t is a prvalue T
+                           // and at least one of the range's refernce_t is a T
+                           // reference
+    is_reference_v<concat_reference_t<Rs...>> ||
+    (is_reference_v<range_reference_t<Rs>>&&...) &&
+    (!same_as<std::remove_reference_t<range_reference_t<Rs>>,
+              concat_reference_t<Rs...>> &&
+     ...);
+
 // clang-format off
 template <class Ref, class RRef, class It>
 concept concat_indirectly_readable_impl = requires (const It it){
@@ -55,12 +65,14 @@ concept concat_indirectly_readable =
 }  // namespace not_to_spec
 
 // clang-format off
-template <class... Rs>
+template <bool allow_magic, class... Rs>
 concept concatable = requires {
     typename concat_reference_t<Rs...>;
     typename concat_value_t<Rs...>;
     typename concat_rvalue_reference_t<Rs...>;
-} && concat_indirectly_readable<Rs...>;
+} && concat_indirectly_readable<Rs...>
+  && (allow_magic || concat_no_magic<Rs...>)
+;
 // clang-format on
 
 static_assert(true);  // clang-format badness
@@ -246,9 +258,9 @@ using iter_cat_base_t = decltype(iter_cat_base_sel<Const, Views...>());
 
 // clang-format off
 // [TODO] constrain less and allow just a `view`? (i.e. including output_range in the mix - need an example)
-template <input_range... Views>
-    requires (view<Views>&&...) && (sizeof...(Views) > 0) && xo::concatable<Views...>  
-class concat_view : public view_interface<concat_view<Views...>> {
+template <bool allow_magic, input_range... Views>
+    requires (view<Views>&&...) && (sizeof...(Views) > 0) && xo::concatable<allow_magic, Views...>  
+class concat_view : public view_interface<concat_view<allow_magic, Views...>> {
   // clang-format on
   tuple<Views...> views_;  // exposition only
 
@@ -636,7 +648,7 @@ class concat_view : public view_interface<concat_view<Views...>> {
 
   constexpr iterator<true> begin() const
       requires((range<const Views> && ...) &&
-               xo::concatable<const Views...>)  //
+               xo::concatable<allow_magic, const Views...>)  //
   {
     iterator<true> it{this, in_place_index<0u>, ranges::begin(get<0>(views_))};
     it.template satisfy<0>();
@@ -685,7 +697,7 @@ class concat_view : public view_interface<concat_view<Views...>> {
 };
 
 template <class... R>
-concat_view(R&&...) -> concat_view<views::all_t<R>...>;
+concat_view(R&&...) -> concat_view<false, views::all_t<R>...>;
 
 // cpo:
 
@@ -702,7 +714,7 @@ class concat_fn {
   }
 
   template <input_range... V>
-  requires(sizeof...(V) > 1) && ranges::xo::concatable<all_t<V&&>...> &&
+  requires(sizeof...(V) > 1) && ranges::xo::concatable<false, all_t<V&&>...> &&
       (viewable_range<V> && ...)  //
       constexpr auto
       operator()(V&&... v)
@@ -710,9 +722,22 @@ class concat_fn {
     return concat_view{static_cast<V&&>(v)...};
   }
 };
+
+class concat_magic_fn : concat_fn {
+ public:
+  template <input_range... V>
+  requires(sizeof...(V) > 1) && ranges::xo::concatable<true, all_t<V&&>...> &&
+      (viewable_range<V> && ...)  //
+      constexpr auto
+      operator()(V&&... v)
+          const {  // noexcept(noexcept(concat_view{static_cast<V&&>(v)...})) {
+    return concat_view<true, views::all_t<V>...>{static_cast<V&&>(v)...};
+  }
+};
 }  // namespace xo
 
 inline constexpr xo::concat_fn concat;
+inline constexpr xo::concat_magic_fn concat_magic;
 }  // namespace views
 
 }  // namespace std::ranges