title: User-defined literal to MPL sequence: is this legal?
body: <p>Being able to convert the string passed to a literal operator into an MPL sequence would be useful, since we would then be able to control code generation based on the contents of the string. Previously, I thought this to be impossible, since the arguments to a constexpr function are not regarded as constant expressions within the function's body. However, I came up with the following workaround that compiles under Clang 3.4.2 and GCC 4.8.2:</p>
  
  <pre><code>#include &lt;cstdint&gt;
  #include &lt;iostream&gt;
  #include &lt;typeinfo&gt;
  
  struct string
  {
      const uintmax_t m_str[64];
      const size_t m_length;
  
      template &lt;class... Ts&gt;
      constexpr string(const Ts... ts) :
      m_str{(uintmax_t)ts...}, m_length{sizeof...(Ts)} {}
  
      constexpr size_t size() const { return m_length; }
      constexpr size_t length() const { return m_length; }
      constexpr uintmax_t operator[](size_t n) const { return m_str[n]; }
  };
  
  template &lt;uintmax_t... Ts&gt; struct sequence {};
  
  constexpr auto
  operator"" _tag(const char* str, size_t n)
  {
      return n == 0 ? string{} :
             n == 1 ? string{str[0]} :
             n == 2 ? string{str[0], str[1]} :
             n == 3 ? string{str[0], str[1], str[2]} :
             n == 4 ? string{str[0], str[1], str[2], str[3]} :
             n == 5 ? string{str[0], str[1], str[2], str[3], str[4]} :
                      string{str[0], str[1], str[2], str[3], str[4], str[5]};
  }
  
  int main()
  {
      static constexpr auto string = "Hello!"_tag;
      using sequence = sequence&lt;string[0], string[1], string[2], string[3], string[4], string[5]&gt;;
      std::cout &lt;&lt; typeid(sequence{}).name() &lt;&lt; std::endl;
  }
  </code></pre>
  
  <p>Output:</p>
  
  <pre><code>sequence&lt;72ul, 101ul, 108ul, 108ul, 111ul, 33ul&gt;
  </code></pre>
  
  <h2>Question</h2>
  
  <p>Does this code invoke undefined behavior, or is it legal?</p>