title: Why does a CopyConstructible type also have to be MoveConstructible?
body: <p>As stated in <a href="https://en.cppreference.com/w/cpp/named_req/CopyConstructible" rel="noreferrer">cppreference</a>, a requirement for a type <strong>T</strong> to be <strong>CopyConstructible</strong> is that it also be <strong>MoveConstructible</strong>.</p>
  
  <p>The draft for the STL <a href="https://en.cppreference.com/w/cpp/concepts/CopyConstructible" rel="noreferrer">CopyConstructible</a> concept contains:</p>
  
  <blockquote>
  <pre><code>template &lt;class T&gt;
  concept CopyConstructible =
     std::MoveConstructible&lt;T&gt; &amp;&amp;
     std::Constructible&lt;T, T&amp;&gt; &amp;&amp; std::ConvertibleTo&lt;T&amp;, T&gt; &amp;&amp;
     std::Constructible&lt;T, const T&amp;&gt; &amp;&amp; std::ConvertibleTo&lt;const T&amp;, T&gt; &amp;&amp;
     std::Constructible&lt;T, const T&gt; &amp;&amp; std::ConvertibleTo&lt;const T, T&gt;;
  </code></pre>
  </blockquote>
  
  <p>which supports the named requirement statement. Given the above definition, a type like:</p>
  
  <pre><code>struct HaveCopy {
     HaveCopy(const HaveCopy&amp;)  = default;
     HaveCopy(HaveCopy&amp;&amp;)       = delete;
     HaveCopy&amp; operator= (const HaveCopy&amp;)  = default;
     HaveCopy&amp; operator= (HaveCopy&amp;&amp;)       = delete;
  };
  </code></pre>
  
  <p>fails the simple test:</p>
  
  <pre><code>static_assert(std::CopyConstructible&lt;HaveCopy&gt;);
  </code></pre>
  
  <p>whereas it passes the old:</p>
  
  <pre><code>static_assert(std::is_copy_constructible&lt;HaveCopy&gt;::value);
  </code></pre>
  
  <p>So, the question is <strong>why</strong>? What's the intention of the standards committee on that matter? HaveCopy is not move constructible but is pretty much copy constructible in my opinion and <code>std::is_copy_constructible&lt;&gt;</code> agrees with me.</p>
  
  <p>The same behavior is also inherited by the <a href="https://en.cppreference.com/w/cpp/concepts/Copyable" rel="noreferrer">Copyable</a> concept, which is:</p>
  
  <blockquote>
  <pre><code>template &lt;class T&gt;
  concept Copyable =
     std::CopyConstructible&lt;T&gt; &amp;&amp;
     std::Movable&lt;T&gt; &amp;&amp;
     std::Assignable&lt;T&amp;, const T&amp;&gt;;
  </code></pre>
  </blockquote>
  
  <p>So the test:</p>
  
  <pre><code>static_assert(std::Copyable&lt;HaveCopy&gt;);
  </code></pre>
  
  <p>will fail also. This time the failure is doubled. Both <code>CopyConstrucible&lt;&gt;</code> and <code>Movable&lt;&gt;</code> disagree that HaveCopy is copyable.</p>
  
  <p>The discussion <a href="https://stackoverflow.com/questions/35041787/are-all-copyconstructible-types-moveconstructible-types">here</a> is somehow similar but does not answer the <strong>why</strong>. Why do we need this behavior? Does this kind of check exclude valid copy constructible types or is HaveCopy not copy constructible at all? The last seems really weird to me if it is true.</p>
  
  <p>Any thoughts?</p>