Float Plan Template: Fill & Download for Free

I think that what you are asking is how you could do something like the following:template<string_type str> struct X {}; X<"message"> x; for some type string_type.(My answer is going to delve beyond this question though.)Currently, the short answer is “you cannot”. In C++17 (the current standard language), the best you can do as an approximation is something like:template<auto &str> struct X {  static constexpr int N = sizeof(str); }; extern constexpr char const message[] = "a message"; X<message> x; However… C++20 is trying to improve that by enabling nontype template parameters of class types.Prior to the last standardization meeting (earlier this month in Belfast), the solution relied on “opting into the feature” by declaring a “trivial comparison operator”. Something like:#include <compare> #include <algorithm> template<int N> struct FixedString {  constexpr FixedString(char const (&s)[N]) {  std::copy_n(s, N, this->elems);  }   constexpr std::strong_equality  operator<=>(FixedString const&) const = default;  char elems[N]; }; template<int N> FixedString(char const(&)[N])->FixedString<N>; which, would permit:template<FixedString str> struct X { }; X<"a message"> x; There is a bit to unpack here. Remember that a (narrow) string literal is a fixed-length array of char const elements (e.g., “a message” is a 10-element array, including the terminating null). So it can be bound to a reference to array. E.g., I could write:FixedString<10> msg("a message"); C++17 introduced the notion of “class template argument deduction, which allows that last line to be rewritten as:FixedString msg("a message"); because the compiler can deduce N from the constructor signature and the array (i.e., string literal) that is passed to it. That mechanism is going to be extended in C++20 to cover other contexts, including nontype template arguments (see [temp.arg.nontype]/1), and so when I wrote:X<"a message"> x; above, that will (in C++20) trigger the deduction of type FixedString<10> for the actual nontype template parameter of X. Now, prior to this month (November 2019), a nontype template parameter could be of class type provided that the type is a literal type (essentially, a class type that can be constructed and destroyed as a constant-expression) and that it had strong structural equality, which approximately means that it has a “trivial” operator<=> (one where equality is known to be determined by recursively comparing subobject until you reach fundamental types). In the code for FixedString above, I achieved that by providing a = default definition for operator<=> with the “strong equality” return type. See http://wg21.link/P0732r2 for details.A few of us were quite concerned by that approach to nontype parameters of class type:equality (i.e., the result of comparing with ==) is really not the mechanism used to compare nontype template arguments, andthat approach would forever close the doors on the possibility of being able to use types like std::vector<int> or std::string for nontype template parameters.To illustrates my first bullet, consider this code:enum E { e, f, g }; template<E x> struct XE {}; constexpr bool operator==(E, E) { return false; } XE<e> xe; extern XE<e> xe; // Okay. This has been valid in every C++ standard so far: The type XE<e> is the same, despite the fact that e == e returns false. There are other examples like that (i.e., it’s not just enumeration types; pointer and pointer-to-member types can do similar things).In any case, during the comment period for the C++20 committee draft, the US entered an entry requesting this to be revised, and in Belfast a small group of us (David Herring, Jens Maurer, Richard Smith, Jeff Snyder, and myself) worked out a new model for nontype template arguments in general, and class type nontype template arguments in particular. Our plan was to move the base model into C++20, and then work out a generalization for C++23. That plan has been approved, and the C++20 “phase” has been voted in for C++20. Let me talk about both…For C++20, we’re dropping “equality” as a mechanism to compare template arguments, and instead we introduce the notion of template argument equivalence which you can think of as “X and Y are template-argument-equivalent if the compiler’s constant-evaluator cannot distinguish their values”. I won’t go into the details, but http://wg21.link/P1907r1 should produce the spec in a few weeks. One of the notable extensions is that this allows floating-point template arguments, with +0.0 and -0.0 potentially producing different instances (despite +0.0 == -0.0 in practice). Another one is that structural types include class types that only have public subobjects all the way down: The fact that the (base and member) subobjects are public is an indication that only their representational values matter since anyone can change those values at any time (i.e., the class cannot rely on invariant relations between the members, for example). So, the FixedString example above is still a valid nontype template parameter type, but the operator<=> is now ignored and can be omitted if desired (or be made nontrivial instead). Now, when we write:X<"a message"> x; the compiler will deduce type FixedString<10> as before, and create a compile time object (call it __argobj) of that type for the argument, which will be initialized with FixedString<10>(“a message”) (evaluated at compile time). We’ve recently (i.e., a few days ago) also concluded that we want the compiler to evaluate a copy of __argobj and verify that it is template-argument-equivalent to the original (to catch/diagnose shenanigans occurring in copy constructors). That (immutable) __argobj will then be the object used whenever the corresponding template parameter is referred to in the template itself.That’s for C++20. For C++23, we’re planning to go one step farther. The plan is to introduce a new special member function that produces a “canonical representation” of class type values. For example, suppose we have a Rational type that is internally represented with non-normalized nominator and denominator values:class Rational {  struct Repr { int num, denom; } r; public:  Rational(int n, int d): r{n, d} {}  ... }; and we want to use it as a template parameter:template<Rational R> struct Y {}; Then we’d want Y<Rational(6, 3)> to be the same type as Y<Rational(4, 2)>. But how do we communicate that to the compiler? The answer is that we introduce a new operator (syntax to be determined) that produces (at compile time) a “normalized value” that is of the kind that is acceptable as a C++20 class type nontype template argument. In our Rational example, Rational::Repr is such a type. Here is how it might look like:class Rational {  struct Repr { int num, denom; } r;  Repr operator<>() {  // Return a normalized representation:  return { num/gcd(num, denom), denom/gcd(num, denom) };  }  Rational(Repr r): r(r) {} public:  Rational(int n, int d): r{n, d} {}  ... }; Now, when we write Y<Rational(6, 3)>, the compiler will (a) evaluate Rational(6, 3), (b) apply operator<>() to it and evaluate that (which here produces the value Repr{ 2, 1 }), (c) evaluate a copy of this value and make sure it’s still Repr{ 2, 1 }, and (d) compute the template parameter value __argobj by converting Repr{ 2, 1 } to Rational. Whether two template arguments are equivalent will now be decided based on the intermediate representation object. So, since Y<Rational(4, 2)> also produces Repr{ 2, 1 } it will be the same type as Y<Rational(6, 3)>. In addition, we’re also planning to introduce a “magic” non-fixed-length array type that can be used to build intermediate representations, which will close the loop to enable std::string or std::vector<int> template argument types. All that is a bit complicated, admittedly, but the upshot of it is that hopefully in C++23 we’ll be able to write:#include <string> template<std::string str> struct Z {}; Z<"finally!"> z; 

Thanks for A2A, Donna!Here are some of the templates we use at Reply (including some of my personal favorites):Template #1Hey {FirstName},Is there any chance you could share your thoughts on {Original Request}? Any feedback will be highly appreciated.ThanksThis follow-up is short and sweet - just a reminder that your original request was left unanswered.Template #2Hey {FirstName},I just wanted to float my emails to the top of your inbox one more time.I’ve been trying to reach out to you a few times about the possibility of attracting new customers at {Company} using an outbound channel. I’d love to know if you have any plans for this.Thank you for your time.It’s very brief and to the point. This makes it a perfect way to direct your prospect’s attention to your pitch one more time.Template #3Hi {FirstName},I have reached out a few times but haven’t heard back. I know things can get busy but I’m still hoping to hear your feedback on {Original Offer}.In the meantime, I thought you as {Standardized Job Title} would find value with this {Content Type}, {Content Description}.Hope you’ll find it useful!Looking forward to hearing back from you.What I like most about this follow-up is that it’s not your default “have you seem my previous email?” type of follow-up. It is personal and valuable, which means better chance to hear back from the prospect (even if it’s just to thank you for the relevant content).If you are struggling to build an effective follow-up strategy, take a look at a detailed guide my team has put together - A Beginner's Guide to Follow-Ups: When, Why, How (many).It is based on our first-hand experience with cold email outreach and packed with actionable tips on how to create a successful follow-up framework (plus, it also features several proven email templates!)

I get individual tattoos. Your son dies and you get an RIP tat on your shoulder with the date? A Marine Corps anchor? A cute little bunny? Whatever floats your boat.I also get mosaics. Everything from The Rocks shoulder to Yakuza full body prints are cool. Extreme, but cool.You may date my daughterWhat I don’t get are folks who clearly had no plan, but cover their whole body with random scribbles like an angsty teens notebook. Jarod Leto in Suicide Squad sets the template.You may not date my daughter. But you may take that cup you are drinking from. It's yours now.It is unfortunate. My social circles are full of folks with perma-scribbled bodies that make me not to want to sleep with or share beverages with them.There is just something about a person who makes a habit of going to bed with tattoos they did not plan to have when they woke up that screams “I have hepatitis C”.