Implement N3642 - User-defined Literals for Standard Library Types

On 05/31/2013 10:41 AM, Daniel Krügler wrote:
> 2013/5/31 Ed Smith-Rowland <3dw4rd@verizon.net>:
>> Greetings,
>>
>> This patch implements N3642 - User-defined literals for
>> std::chrono::duration and std::basic_string
>> and N3660 - User-defined literals for std::complex.
>   N3660 was rejected during the Bristol meeting, the main reason being
> the ugliness of the complex-float literal and giving it some time to
> find a possible sore language solution. Is there still the idea to add
> this now?
>
> - Daniel
>
I would offer a modification of the lower-case rule for standard literal 
operators (I know this is bikeshed but I think such things are important 
and obviously prevent ideas from being adopted).

I would say:

   1. Put the precision first in upper case.  As a matter of style I 
prefer 123456L to 123456l for normal literals anyway.  Also, the 
precision snuggles next to the number - then you modify it.  That seems 
logical to me.  Also, if we involve <decimal> in this someday, those 
literals *have* to be all caps (for the old literals).  It seems using 
lower case precision indicators for decimal would be inconsistent.

   2. Use lower case for the other characters except...

   3. If the name derives from a proper name, such as SI unit Farad use 
capitals.  This will make literal operators for units match SI and the 
expectation of users most likely to use such literals.

For complex this gives us:

   std::complex<float>
operator"" Fi(long double imag) noexcept;

   std::complex<float>
operator"" Fi(unsigned long long imag) noexcept;

std::complex<double>
operator"" i(long double imag) noexcept;

std::complex<double>
operator"" i(unsigned long long imag) noexcept;

std::complex<long double>
operator"" Li(long double imag) noexcept;

std::complex<long double>
operator"" Li(unsigned long long imag) noexcept;

This avoids the i_f, and seems more logical to me.

For the issue at hand, I split the patch.

Ed

2013-05-30  Ed Smith-Rowland  <3dw4rd@verizon.net>

	Implement N3660 - User-defined Literals for std::complex,
	part 2 of UDL for Standard Library Types
	* include/std/complex: Add complex literal operators.
	* testsuite/26_numerics/complex/literals/types.cc: New.
	* testsuite/26_numerics/complex/literals/values.cc: New.
	* config/abi/pre/gnu.ver: Add literal operator symbols.
2013-05-30  Ed Smith-Rowland  <3dw4rd@verizon.net>

	Implement N3642 - User-defined Literals for Standard Library Types
	* include/bits/parse_numbers.h: New.
	* include/std/chrono: Add duration literal operators.
	* include/bits/basic_string.h: Add string literal operators.
	* include/Makefile.in: Add parse_numbers.h.
	* include/Makefile.am: Ditto.
	* testsuite/20_util/duration/literals/values.cc: New.
	* testsuite/20_util/duration/literals/types.cc: New.
	* testsuite/20_util/duration/requirements/typedefs_neg1.cc: Adjust.
	* testsuite/20_util/duration/requirements/typedefs_neg2.cc: Adjust.
	* testsuite/20_util/duration/requirements/typedefs_neg3.cc: Adjust.
	* testsuite/21_strings/basic_string/literals/values.cc: New.
	* testsuite/21_strings/basic_string/literals/types.cc: New.
	* config/abi/pre/gnu.ver: Add literal operator symbols.
Index: include/std/complex
===================================================================

--- include/std/complex	(revision 199471)
+++ include/std/complex	(working copy)
@@ -1930,4 +1930,45 @@
 
 #endif  // C++11
 
+#if __cplusplus > 201103L
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+inline namespace literals {
+inline namespace complex_literals {
+
+  inline constexpr std::complex<float>
+  operator"" i_f(long double __num)
+  { return std::complex<float>{0.0F, static_cast<float>(__num)}; }
+
+  inline constexpr std::complex<float>
+  operator"" i_f(unsigned long long __num)
+  { return std::complex<float>{0.0F, static_cast<float>(__num)}; }
+
+  inline constexpr std::complex<double>
+  operator"" i(long double __num)
+  { return std::complex<double>{0.0, static_cast<double>(__num)}; }
+
+  inline constexpr std::complex<double>
+  operator"" i(unsigned long long __num)
+  { return std::complex<double>{0.0, static_cast<double>(__num)}; }
+
+  inline constexpr std::complex<long double>
+  operator"" il(long double __num)
+  { return std::complex<long double>{0.0L, __num}; }
+
+  inline constexpr std::complex<long double>
+  operator"" il(unsigned long long __num)
+  { return std::complex<long double>{0.0L, static_cast<long double>(__num)}; }
+
+} // inline namespace complex_literals
+} // inline namespace literals
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace std
+
+#endif // __cplusplus > 201103L
+
 #endif  /* _GLIBCXX_COMPLEX */
Index: testsuite/26_numerics/complex/literals/types.cc
===================================================================
--- testsuite/26_numerics/complex/literals/types.cc	(revision 0)
+++ testsuite/26_numerics/complex/literals/types.cc	(working copy)
@@ -0,0 +1,46 @@
+// { dg-options "-std=c++1y" }
+// { dg-do compile }
+
+// Copyright (C) 2013 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+#include <complex>
+#include <type_traits>
+
+void
+test02()
+{
+  using namespace std::literals::complex_literals;
+
+  static_assert(std::is_same<decltype(1.0i_f), std::complex<float>>::value,
+		"1.0i_f is std::complex<float>");
+
+  static_assert(std::is_same<decltype(1i_f), std::complex<float>>::value,
+		"1i_f is std::complex<float>");
+
+  static_assert(std::is_same<decltype(1.0i), std::complex<double>>::value,
+		"1.0i is std::complex<double>");
+
+  static_assert(std::is_same<decltype(1i), std::complex<double>>::value,
+		"1i is std::complex<double>");
+
+  static_assert(std::is_same<decltype(1.0il), std::complex<long double>>::value,
+		"1.0il is std::complex<long double>");
+
+  static_assert(std::is_same<decltype(1il), std::complex<long double>>::value,
+		"1il is std::complex<long double>");
+}
Index: testsuite/26_numerics/complex/literals/values.cc
===================================================================
--- testsuite/26_numerics/complex/literals/values.cc	(revision 0)
+++ testsuite/26_numerics/complex/literals/values.cc	(working copy)
@@ -0,0 +1,48 @@
+// { dg-options "-std=gnu++1y" }
+// { dg-do run }
+
+// Copyright (C) 2013 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+#include <complex>
+#include <testsuite_hooks.h>
+
+void
+test02()
+{
+  using namespace std::literals::complex_literals;
+
+  std::complex<float> j1 = 1.0i_f;
+  std::complex<float> k1 = 1i_f;
+  std::complex<double> j2 = 2.0i;
+  std::complex<double> k2 = 2i;
+  std::complex<long double> j4 = 4.0il;
+  std::complex<long double> k4 = 4il;
+
+  VERIFY( j1 == std::complex<float>(0.0F, 1.0F) );
+  VERIFY( k1 == std::complex<float>(0.0F, 1.0F) );
+  VERIFY( j2 == std::complex<double>(0.0, 2.0) );
+  VERIFY( k2 == std::complex<double>(0.0, 2.0) );
+  VERIFY( j4 == std::complex<long double>(0.0L, 4.0L) );
+  VERIFY( k4 == std::complex<long double>(0.0L, 4.0L) );
+}
+
+int
+main()
+{
+  test02();
+}
Index: config/abi/pre/gnu.ver
===================================================================
--- config/abi/pre/gnu.ver	(revision 199471)
+++ config/abi/pre/gnu.ver	(working copy)
@@ -1365,6 +1365,14 @@
     # std::get_unexpected()
     _ZSt14get_unexpectedv;
 
+    # std::literals::complex_literals::operator""()
+    _ZNSt8literals16complex_literalsli3i_fEe;
+    _ZNSt8literals16complex_literalsli3i_fEy;
+    _ZNSt8literals16complex_literalsli1iEe;
+    _ZNSt8literals16complex_literalsli1iEy;
+    _ZNSt8literals16complex_literalsli2ilEe;
+    _ZNSt8literals16complex_literalsli2ilEy;
+
 } GLIBCXX_3.4.19;
 
 # Symbols in the support library (libsupc++) have their own tag.


Implement N3642 - User-defined Literals for Standard Library Types

Commit Message

Patch