Rename the user-defined literal from _s to _dyno

_s is overly general, which is problematic since the only way to use the
literal is to bring it into scope with `using namespace dyno::literals`,
which pollutes the global namespace. Using _dyno is less problematic since
it is more specific to this library, even though the namespace pollution
problem still remains.

Author: ldionne

README.md

@@ -27,13 +27,13 @@ using namespace dyno::literals;
 
 // Define the interface of something that can be drawn
 struct Drawable : decltype(dyno::requires(
-  "draw"_s = dyno::method<void (std::ostream&) const>
+  "draw"_dyno = dyno::method<void (std::ostream&) const>
 )) { };
 
 // Define how concrete types can fulfill that interface
 template <typename T>
 auto const dyno::default_concept_map<Drawable, T> = dyno::make_concept_map(
-  "draw"_s = [](T const& self, std::ostream& out) { self.draw(out); }
+  "draw"_dyno = [](T const& self, std::ostream& out) { self.draw(out); }
 );
 
 // Define an object that can hold anything that can be drawn.
@@ -42,7 +42,7 @@ struct drawable {
   drawable(T x) : poly_{x} { }
 
   void draw(std::ostream& out) const
-  { poly_.virtual_("draw"_s)(out); }
+  { poly_.virtual_("draw"_dyno)(out); }
 
 private:
   dyno::poly<Drawable> poly_;
@@ -237,7 +237,7 @@ let's define an interface `Drawable` that describes types that can be drawn:
 using namespace dyno::literals;
 
 struct Drawable : decltype(dyno::requires(
-  "draw"_s = dyno::method<void (std::ostream&) const>
+  "draw"_dyno = dyno::method<void (std::ostream&) const>
 )) { };
 ```
 
@@ -273,7 +273,7 @@ struct Square { /* ... */ };
 
 template <>
 auto const dyno::concept_map<Drawable, Square> = dyno::make_concept_map(
-  "draw"_s = [](Square const& square, std::ostream& out) {
+  "draw"_dyno = [](Square const& square, std::ostream& out) {
     out << "square" << std::endl;
   }
 );
@@ -319,7 +319,7 @@ struct drawable {
   drawable(T x) : poly_{x} { }
 
   void draw(std::ostream& out) const
-  { poly_.virtual_("draw"_s)(out); }
+  { poly_.virtual_("draw"_dyno)(out); }
 
 private:
   dyno::poly<Drawable> poly_;
@@ -356,7 +356,7 @@ of the `draw` method:
 
 ```c++
 void draw(std::ostream& out) const
-{ poly_.virtual_("draw"_s)(out); }
+{ poly_.virtual_("draw"_dyno)(out); }
 ```
 
 What happens here is that when `.draw` is called on our `drawable` object,
@@ -414,7 +414,7 @@ struct drawable {
   drawable(T x) : poly_{x} { }
 
   void draw(std::ostream& out) const
-  { poly_.virtual_("draw"_s)(out); }
+  { poly_.virtual_("draw"_dyno)(out); }
 
 private:
   dyno::poly<Drawable, dyno::sbo_storage<16>> poly_;
@@ -465,7 +465,7 @@ struct drawable {
   drawable(T x) : poly_{x} { }
 
   void draw(std::ostream& out) const
-  { poly_.virtual_("draw"_s)(out); }
+  { poly_.virtual_("draw"_dyno)(out); }
 
 private:
   using Storage = dyno::sbo_storage<16>;                      // storage policy
@@ -490,12 +490,12 @@ struct drawable {
   drawable(T x) : poly_{x} { }
 
   void draw(std::ostream& out) const
-  { poly_.virtual_("draw"_s)(out); }
+  { poly_.virtual_("draw"_dyno)(out); }
 
 private:
   using Storage = dyno::sbo_storage<16>;
   using VTable = dyno::vtable<
-    dyno::local<dyno::only<decltype("draw"_s)>>,
+    dyno::local<dyno::only<decltype("draw"_dyno)>>,
     dyno::remote<dyno::everything_else>
   >;
   dyno::poly<Drawable, Storage, VTable> poly_;
@@ -523,7 +523,7 @@ For this, one can use `dyno::default_concept_map`:
 ```c++
 template <typename T>
 auto const dyno::default_concept_map<Drawable, T> = dyno::make_concept_map(
-  "draw"_s = [](auto const& self, std::ostream& out) { self.draw(out); }
+  "draw"_dyno = [](auto const& self, std::ostream& out) { self.draw(out); }
 );
 ```
 
@@ -549,7 +549,7 @@ default one:
 ```c++
 template <>
 auto dyno::concept_map<Drawable, Circle> = dyno::make_concept_map(
-  "draw"_s = [](Circle const& circle, std::ostream& out) {
+  "draw"_dyno = [](Circle const& circle, std::ostream& out) {
     out << "triangle" << std::endl;
   }
 );
@@ -569,7 +569,7 @@ template <typename T>
 auto const dyno::concept_map<Drawable, std::vector<T>, std::void_t<decltype(
   std::cout << std::declval<T>()
 )>> = dyno::make_concept_map(
-  "draw"_s = [](std::vector<T> const& v, std::ostream& out) {
+  "draw"_dyno = [](std::vector<T> const& v, std::ostream& out) {
     for (auto const& x : v)
       out << x << ' ';
   }
@@ -591,7 +591,7 @@ the concept using `dyno::function` instead of `dyno::method`, and use the
 ```c++
 // Define the interface of something that can be drawn
 struct Drawable : decltype(dyno::requires(
-  "draw"_s = dyno::function<void (dyno::T const&, std::ostream&)>
+  "draw"_dyno = dyno::function<void (dyno::T const&, std::ostream&)>
 )) { };
 ```
 
@@ -601,7 +601,7 @@ first parameter:
 
 ```c++
 struct Drawable : decltype(dyno::requires(
-  "draw"_s = dyno::function<void (std::ostream&, dyno::T const&)>
+  "draw"_dyno = dyno::function<void (std::ostream&, dyno::T const&)>
 )) { };
 ```
 
@@ -613,7 +613,7 @@ implementation match that of the function declared in the concept:
 // Define how concrete types can fulfill that interface
 template <typename T>
 auto const dyno::default_concept_map<Drawable, T> = dyno::make_concept_map(
-  "draw"_s = [](std::ostream& out, T const& self) { self.draw(out); }
+  "draw"_dyno = [](std::ostream& out, T const& self) { self.draw(out); }
   //            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ matches the concept definition
 );
 ```
@@ -630,7 +630,7 @@ struct drawable {
   drawable(T x) : poly_{x} { }
 
   void draw(std::ostream& out) const
-  { poly_.virtual_("draw"_s)(out, poly_); }
+  { poly_.virtual_("draw"_dyno)(out, poly_); }
   //                              ^^^^^ passing the poly explicitly
 
 private:

benchmark/any_iterator/dyno_generic.hpp

@@ -14,9 +14,9 @@ namespace dyno_generic {
   template <typename Reference>
   struct Iterator : decltype(dyno::requires(
     dyno::MoveConstructible{},
-    "increment"_s = dyno::function<void (dyno::T&)>,
-    "dereference"_s = dyno::function<Reference (dyno::T&)>,
-    "equal"_s = dyno::function<bool (dyno::T const&, dyno::T const&)>
+    "increment"_dyno = dyno::function<void (dyno::T&)>,
+    "dereference"_dyno = dyno::function<Reference (dyno::T&)>,
+    "equal"_dyno = dyno::function<bool (dyno::T const&, dyno::T const&)>
   )) { };
 
   template <typename Value, typename StoragePolicy, typename VTablePolicy, typename Reference = Value&>
@@ -27,9 +27,9 @@ namespace dyno_generic {
     template <typename It>
     explicit any_iterator(It it)
       : poly_{std::move(it), dyno::make_concept_map(
-        "increment"_s = [](It& self) { ++self; },
-        "dereference"_s = [](It& self) -> decltype(auto) { return *self; },
-        "equal"_s = [](It const& a, It const& b) -> bool { return a == b; }
+        "increment"_dyno = [](It& self) { ++self; },
+        "dereference"_dyno = [](It& self) -> decltype(auto) { return *self; },
+        "equal"_dyno = [](It const& a, It const& b) -> bool { return a == b; }
       )}
     { }
 
@@ -38,16 +38,16 @@ namespace dyno_generic {
     { }
 
     any_iterator& operator++() {
-      poly_.virtual_("increment"_s)(poly_);
+      poly_.virtual_("increment"_dyno)(poly_);
       return *this;
     }
 
     reference operator*() {
-      return poly_.virtual_("dereference"_s)(poly_);
+      return poly_.virtual_("dereference"_dyno)(poly_);
     }
 
     friend bool operator==(any_iterator const& a, any_iterator const& b) {
-      return a.poly_.virtual_("equal"_s)(a.poly_, b.poly_);
+      return a.poly_.virtual_("equal"_dyno)(a.poly_, b.poly_);
     }
 
   private:
@@ -66,9 +66,9 @@ namespace dyno_generic {
     int,
     dyno::local_storage<16>,
     dyno::vtable<
-      dyno::local<dyno::only<decltype("increment"_s),
-                             decltype("dereference"_s),
-                             decltype("equal"_s)>>,
+      dyno::local<dyno::only<decltype("increment"_dyno),
+                             decltype("dereference"_dyno),
+                             decltype("equal"_dyno)>>,
       dyno::remote<dyno::everything_else>
     >
   >;

benchmark/n_functions.cpp

@@ -180,11 +180,11 @@ namespace { namespace dyno_remote {
   using namespace dyno::literals;
 
   struct Concept : decltype(dyno::requires(
-    "f1"_s = dyno::function<void (dyno::T&)>,
-    "f2"_s = dyno::function<void (dyno::T&)>,
-    "f3"_s = dyno::function<void (dyno::T&)>,
-    "f4"_s = dyno::function<void (dyno::T&)>,
-    "f5"_s = dyno::function<void (dyno::T&)>
+    "f1"_dyno = dyno::function<void (dyno::T&)>,
+    "f2"_dyno = dyno::function<void (dyno::T&)>,
+    "f3"_dyno = dyno::function<void (dyno::T&)>,
+    "f4"_dyno = dyno::function<void (dyno::T&)>,
+    "f5"_dyno = dyno::function<void (dyno::T&)>
   )) { };
 
   template <typename Policy>
@@ -193,21 +193,21 @@ namespace { namespace dyno_remote {
     explicit any_template(T t)
       : vtable_{
         dyno::complete_concept_map<Concept, T>(dyno::make_concept_map(
-          "f1"_s = [](T& self) { ++self; },
-          "f2"_s = [](T& self) { --self; },
-          "f3"_s = [](T& self) { ++self; },
-          "f4"_s = [](T& self) { --self; },
-          "f5"_s = [](T& self) { ++self; }
+          "f1"_dyno = [](T& self) { ++self; },
+          "f2"_dyno = [](T& self) { --self; },
+          "f3"_dyno = [](T& self) { ++self; },
+          "f4"_dyno = [](T& self) { --self; },
+          "f5"_dyno = [](T& self) { ++self; }
         ))
       }
       , self_{new T(t)}
     { }
 
-    any_template& f1() { vtable_["f1"_s](self_); return *this; }
-    any_template& f2() { vtable_["f2"_s](self_); return *this; }
-    any_template& f3() { vtable_["f3"_s](self_); return *this; }
-    any_template& f4() { vtable_["f4"_s](self_); return *this; }
-    any_template& f5() { vtable_["f5"_s](self_); return *this; }
+    any_template& f1() { vtable_["f1"_dyno](self_); return *this; }
+    any_template& f2() { vtable_["f2"_dyno](self_); return *this; }
+    any_template& f3() { vtable_["f3"_dyno](self_); return *this; }
+    any_template& f4() { vtable_["f4"_dyno](self_); return *this; }
+    any_template& f5() { vtable_["f5"_dyno](self_); return *this; }
 
   private:
     using VTable = typename dyno::vtable<Policy>::template apply<Concept>;

benchmark/storage/model.hpp

@@ -16,16 +16,16 @@ struct Concept : decltype(dyno::requires(
   dyno::Swappable{},
   dyno::Destructible{},
   dyno::Storable{},
-  "f1"_s = dyno::function<void(dyno::T&)>,
-  "f2"_s = dyno::function<void(dyno::T&)>,
-  "f3"_s = dyno::function<void(dyno::T&)>
+  "f1"_dyno = dyno::function<void(dyno::T&)>,
+  "f2"_dyno = dyno::function<void(dyno::T&)>,
+  "f3"_dyno = dyno::function<void(dyno::T&)>
 )) { };
 
 template <typename T>
 auto const dyno::default_concept_map<Concept, T> = dyno::make_concept_map(
-  "f1"_s = [](T& self) { benchmark::DoNotOptimize(self); },
-  "f2"_s = [](T& self) { benchmark::DoNotOptimize(self); },
-  "f3"_s = [](T& self) { benchmark::DoNotOptimize(self); }
+  "f1"_dyno = [](T& self) { benchmark::DoNotOptimize(self); },
+  "f2"_dyno = [](T& self) { benchmark::DoNotOptimize(self); },
+  "f3"_dyno = [](T& self) { benchmark::DoNotOptimize(self); }
 );
 
 template <typename StoragePolicy>
@@ -37,9 +37,9 @@ struct model {
 
   void swap(model& other) { poly_.swap(other.poly_); }
 
-  void f1() { poly_.virtual_("f1"_s)(poly_); }
-  void f2() { poly_.virtual_("f2"_s)(poly_); }
-  void f3() { poly_.virtual_("f3"_s)(poly_); }
+  void f1() { poly_.virtual_("f1"_dyno)(poly_); }
+  void f2() { poly_.virtual_("f2"_dyno)(poly_); }
+  void f3() { poly_.virtual_("f3"_dyno)(poly_); }
 
 private:
   dyno::poly<Concept, StoragePolicy> poly_;

benchmark/vtable/dispatch.2.cpp

@@ -36,6 +36,6 @@ using inline_only = dyno::vtable<
 static constexpr int N = 100;
 BENCHMARK_TEMPLATE(BM_dispatch2, inheritance_tag)->Arg(N);
 BENCHMARK_TEMPLATE(BM_dispatch2, inline_only<>)->Arg(N);
-BENCHMARK_TEMPLATE(BM_dispatch2, inline_only<decltype("f1"_s)>)->Arg(N);
-BENCHMARK_TEMPLATE(BM_dispatch2, inline_only<decltype("f1"_s), decltype("f2"_s)>)->Arg(N);
+BENCHMARK_TEMPLATE(BM_dispatch2, inline_only<decltype("f1"_dyno)>)->Arg(N);
+BENCHMARK_TEMPLATE(BM_dispatch2, inline_only<decltype("f1"_dyno), decltype("f2"_dyno)>)->Arg(N);
 BENCHMARK_MAIN();

benchmark/vtable/dispatch.3.cpp

@@ -37,7 +37,7 @@ using inline_only = dyno::vtable<
 static constexpr int N = 100;
 BENCHMARK_TEMPLATE(BM_dispatch3, inheritance_tag)->Arg(N);
 BENCHMARK_TEMPLATE(BM_dispatch3, inline_only<>)->Arg(N);
-BENCHMARK_TEMPLATE(BM_dispatch3, inline_only<decltype("f1"_s)>)->Arg(N);
-BENCHMARK_TEMPLATE(BM_dispatch3, inline_only<decltype("f1"_s), decltype("f2"_s)>)->Arg(N);
-BENCHMARK_TEMPLATE(BM_dispatch3, inline_only<decltype("f1"_s), decltype("f2"_s), decltype("f3"_s)>)->Arg(N);
+BENCHMARK_TEMPLATE(BM_dispatch3, inline_only<decltype("f1"_dyno)>)->Arg(N);
+BENCHMARK_TEMPLATE(BM_dispatch3, inline_only<decltype("f1"_dyno), decltype("f2"_dyno)>)->Arg(N);
+BENCHMARK_TEMPLATE(BM_dispatch3, inline_only<decltype("f1"_dyno), decltype("f2"_dyno), decltype("f3"_dyno)>)->Arg(N);
 BENCHMARK_MAIN();

benchmark/vtable/dispatch.4.cpp

@@ -38,8 +38,8 @@ using inline_only = dyno::vtable<
 static constexpr int N = 100;
 BENCHMARK_TEMPLATE(BM_dispatch4, inheritance_tag)->Arg(N);
 BENCHMARK_TEMPLATE(BM_dispatch4, inline_only<>)->Arg(N);
-BENCHMARK_TEMPLATE(BM_dispatch4, inline_only<decltype("f1"_s)>)->Arg(N);
-BENCHMARK_TEMPLATE(BM_dispatch4, inline_only<decltype("f1"_s), decltype("f2"_s)>)->Arg(N);
-BENCHMARK_TEMPLATE(BM_dispatch4, inline_only<decltype("f1"_s), decltype("f2"_s), decltype("f3"_s)>)->Arg(N);
-BENCHMARK_TEMPLATE(BM_dispatch4, inline_only<decltype("f1"_s), decltype("f2"_s), decltype("f3"_s), decltype("f4"_s)>)->Arg(N);
+BENCHMARK_TEMPLATE(BM_dispatch4, inline_only<decltype("f1"_dyno)>)->Arg(N);
+BENCHMARK_TEMPLATE(BM_dispatch4, inline_only<decltype("f1"_dyno), decltype("f2"_dyno)>)->Arg(N);
+BENCHMARK_TEMPLATE(BM_dispatch4, inline_only<decltype("f1"_dyno), decltype("f2"_dyno), decltype("f3"_dyno)>)->Arg(N);
+BENCHMARK_TEMPLATE(BM_dispatch4, inline_only<decltype("f1"_dyno), decltype("f2"_dyno), decltype("f3"_dyno), decltype("f4"_dyno)>)->Arg(N);
 BENCHMARK_MAIN();

benchmark/vtable/model.hpp

@@ -17,18 +17,18 @@ struct Concept : decltype(dyno::requires(
   dyno::Swappable{},
   dyno::Destructible{},
   dyno::Storable{},
-  "f1"_s = dyno::function<void(dyno::T&)>,
-  "f2"_s = dyno::function<void(dyno::T&)>,
-  "f3"_s = dyno::function<void(dyno::T&)>,
-  "f4"_s = dyno::function<void(dyno::T&)>
+  "f1"_dyno = dyno::function<void(dyno::T&)>,
+  "f2"_dyno = dyno::function<void(dyno::T&)>,
+  "f3"_dyno = dyno::function<void(dyno::T&)>,
+  "f4"_dyno = dyno::function<void(dyno::T&)>
 )) { };
 
 template <typename T>
 auto const dyno::default_concept_map<Concept, T> = dyno::make_concept_map(
-  "f1"_s = [](T& self) { ++self; benchmark::DoNotOptimize(self); },
-  "f2"_s = [](T& self) { ++self; benchmark::DoNotOptimize(self); },
-  "f3"_s = [](T& self) { ++self; benchmark::DoNotOptimize(self); },
-  "f4"_s = [](T& self) { ++self; benchmark::DoNotOptimize(self); }
+  "f1"_dyno = [](T& self) { ++self; benchmark::DoNotOptimize(self); },
+  "f2"_dyno = [](T& self) { ++self; benchmark::DoNotOptimize(self); },
+  "f3"_dyno = [](T& self) { ++self; benchmark::DoNotOptimize(self); },
+  "f4"_dyno = [](T& self) { ++self; benchmark::DoNotOptimize(self); }
 );
 
 template <typename VTablePolicy>
@@ -38,10 +38,10 @@ struct model {
     : poly_{std::move(t)}
   { }
 
-  void f1() { poly_.virtual_("f1"_s)(poly_); }
-  void f2() { poly_.virtual_("f2"_s)(poly_); }
-  void f3() { poly_.virtual_("f3"_s)(poly_); }
-  void f4() { poly_.virtual_("f4"_s)(poly_); }
+  void f1() { poly_.virtual_("f1"_dyno)(poly_); }
+  void f2() { poly_.virtual_("f2"_dyno)(poly_); }
+  void f3() { poly_.virtual_("f3"_dyno)(poly_); }
+  void f4() { poly_.virtual_("f4"_dyno)(poly_); }
 
 private:
   dyno::poly<Concept, dyno::local_storage<8>, VTablePolicy> poly_;