function-templates | Twilio Function templates for different Voice | Serverless library

Does this two are equivalent? It seems like you create a overload instead of a partial specialization.

Follow this guide for Amplify Android's REST API category instead of the CLI @function docs.

Amplify started as a JavaScript library. Over 2020 we had a few engineers build out some of the same functionality for Android, too. @function didn't make the cut, that's just for JS right now.

Following the REST API guide, you'll end up with a system like this:

Why not use free functions, e.g., operator<<, defined on your type and the logger's stream output type, or just functions that are called if visible? For an example of how to do this: googletest is written so that it all of the assertions can be customized this way by you providing serialization methods. See Teaching Googletest How To Print Your Values and then you can look in the implementation to see how they do it.

(Notice that googletest has too methods: you can provide a PrintTo() method in your class or you can overload operator<<, with PrintTo() preferred if both are available. This has the advantage that you can serialize to logging differently than serializing to typical output streams (e.g., you already have an operator<< for your class that doesn't do what you want for logs).

(The magic is all contained in gtest-printer.h - see class UniversalPrinter at line 685 for the trigger.)

This also sas the advantage that it is very easy to add any class/struct/object to be logged properly without even going to the bother of extending the logging class. Furthermore ... what happens if someone extends the logger class (i.e., derives from it) to serialize class AAA, and in a different piece of code there is a different derivation to serialize class BBB and then finally you write some code where you'd like to log both AAAs and BBBs? The derived class approach doesn't work so well there ...

The first class above compiles and returns back the appropriate Foo

Yes, because

This is a bug in libc++: its equal_range implementation (at r315179) immediately returns both iterators upon finding an "equal" element even with heterogeneous comparison.

The term "forwarding reference" is described at [temp.deduct.call/3](from C++17 draft n4659):

A forwarding reference is an rvalue reference to a cv-unqualified template parameter that does not represent a template parameter of a class template (during class template argument deduction).

In your example Container is not a template parameter, it is a type you comprised from the template parameters T and Container. In order for the reference to be truly forwarding, you can use T&& only. While Conatiner is a template parameter, you can't have a reference to a template (the above paragraphs even mentions it explicitly). The type Container is not the same as the template Container. It's an instantiated class.¹

While you can use SFINAE to obtain a forwarding reference that can be bound only to the container type, I personally feel you're better off just overloading the function.

In C++, you cannot provide a default argument or default template argument more than once for the same parameter/template parameter. Default [template] arguments from all declarations (including the definition) of a function are combined (cascaded). You should remove the default template argument from the template's definition.