Monoids: Binary Operators with an Identity - Monoids are mathematical objects, consisting of: - A commutative binary operator - A type T - A mathematical identity 113[DISTRIBUTION STATEMENT A] This Monoids: Binary Operators with an Identity - Monoids are mathematical objects, consisting of: - A commutative binary operator - A type T - A mathematical identity 114[DISTRIBUTION STATEMENT A] This Monoids: Binary Operators with an Identity 115 - Monoids are mathematical objects, consisting of: - A commutative binary operator - A type T - A mathematical identity[DISTRIBUTION STATEMENT A] This material

'*';“You can observe a lot by just implementing identity” – Yogi BerraNotion of Identity/Copying/Cloning is Crucial Allow me a little soapbox • Identity fundamental concept in Computer Science • Different objects central topic in C++ • Alias analysis, self-assignment, self-move, double deletion, … • “Identity Function:” can insert in any (sub)expression without changing meaning constexpr auto r = ^int; '*';Identity Function Example Allow me a little soapbox • We had to add && because C++98 couldn’t implement identity • The year was 2008 and this was C++0x: template T&& identity(T&& x)

Metafunctions • Simple regular function: identity 14 int int_identity(int x) { return x; } assert(42 == int_identity(42));Value Metafunctions • Simple regular function: identity • Simple metafunction: identity 14 int int_identity(int x) { return x; } assert(42 == int_identity(42)); template regular function: identity • Simple metafunction: identity 14 int int_identity(int x) { return x; } assert(42 == int_identity(42)); template

Widget( int ); }; int main() { f( 42 ); // Call 'f()' with a single 'int' argument } // Exact/identity match // Trivial conversions // Standard conversions // User-defined conversions // Default arguments Parameter) 49 For a single argument, the compiler chooses the best available option: 1. Exact/identity match 2. Trivial conversion 3. Promotion 4. Promotion + trivial conversion 5. Standard conversion double ); // (2) int main() { int i = 42; f( i ); } // Calls (1) (identity match, rank 1) Identity match (rank 1) Standard conversion (rank 3)Ranking 51 void f( int& ); // (1)

claim usable( x ); claim usable( result ); } fits a specific function Function interface int Identity( const int x ) interface { claim usable( x ); implementation; claim x == result; claim usable( Indirect caller’s interfaceint Identity( const int x ) interface { claim usable( x ); implementation; claim x == result; claim usable( x ); claim usable( result ); } Identity function interface int Nondecreasing( result ); } Nondecreasing interface adapterint Identity( const int x ) implementation { return x; } Nondecreasing -> Identity “Nondecreasing fronting Identity” int Nondecreasing( const int x ) interface

categories 4Determines the identity of an object, bit-field, or function CppCon 2023 | Forwarding References Value categories “GENERALIZED” LVALUES 4Determines the identity of an object, bit-field, or Forwarding References Value categories “GENERALIZED” LVALUES "PURE" RVALUES 4Determines the identity of an object, bit-field, or function Computes the value of the operand of an operator or initializes 33template [[nodiscard]] constexpr T&& forward(typename std::type_identity_t& param) { return static_castidentity_t&&>(param); } CppCon 2023 | Forwarding References std::forward

Compare comp); // C++20 templateidentity> requires sortable, Comp, Proj> constexpr borrowed_iterator_t ranges::sort(R&& link/P3179) templateidentity> requires sortable, Comp, Proj> constexpr borrowed_iterator_t ranges::sort(ExecutionPolicy&& parallel algorithms template identity, indirectly_unary_invocable, Proj>> Fun> requires

remove_lvalue_reference : std :: type_identity {}; 3 4 template 5 requires std :: is_lvalue_reference_v 6 struct remove_lvalue_reference : std:: type_identity > remove_rvalue_reference : std :: type_identity {}; 3 4 template 5 requires std :: is_rvalue_reference_v 6 struct remove_rvalue_reference : std:: type_identity

auto apply(auto) const { return std::type_identity{}; }Optional constexpr auto apply(destroy_action) const { return std::type_identity>(); } auto reset(auto return value; } constexpr auto apply(destroy_action) const { return std::type_identity>(); } private: T& value; }; Mark invalid when the object it points