__gnu_cxx(3cxx)

🦋 __gnu_cxx (3cxx) 🦋

okay bestie, this is the __gnu_cxx page from manual section 3cxx — GNU extensions for public use, and it is lowkey a whole buffet of C++ goodies. 💅✨

🌸 NAME 🌸

__gnu_cxx — GNU extensions for public use. That's the whole vibe, periodt. 🫶

🎀 SYNOPSIS 🎀

okay so the synopsis is split into namespaces, classes, typedefs, and enumerations. Buckle up, because this list is long and iconic. 👑

🧚 Namespaces 🧚

namespace __detail — implementation details that are not part of the __gnu_cxx namespace interface. It's backstage, bestie. 🎭
namespace typelist — GNU typelist extensions for public compile-time use. Compile-time slay. ⚡

🧸 Classes 🧸

Some of these have no little blurb in the original, and I'm not about to invent lore — those are marked as name-only. No cap. 🫡

struct __alloc_traits — uniform interface to C++98 and C++11 allocators. The bridge between eras. 🌉
struct __common_pool_policy — policy for shared __pool objects. Shared pool energy. 🏊
class __mt_alloc — this is a fixed size (power of 2) allocator which, when compiled with thread support, will maintain one freelist per size per thread plus a global one. Steps are taken to limit the per thread freelist sizes (by returning excess back to the global list). Multithreaded allocator behavior, no cap. 🧵
class __mt_alloc_base — base class for _Tp dependent member functions. Base-class business. 🧱
struct __per_type_pool_policy — policy for individual __pool objects. Personalized pool policy. 🎀
class __pool — data describing the underlying memory pool, parameterized on threading support. Pool lore. 💧
class __pool< false > — specialization for single thread. Solo pool. 🚶
class __pool< true > — specialization for thread enabled, via gthreads.h. Threaded pool. 🧵
class __pool_alloc — allocator using a memory pool with a single lock. One lock, pool vibes. 🔐
class __pool_alloc_base — base class for __pool_alloc. The foundation, bestie. 🧱
struct __pool_base — base class for pool object. Pool object parent energy. 🫶
class __rc_string_base — name only in the original. 🎈
class __scoped_lock — scoped lock idiom. Lock it down, scoped-style. 🔒
class __versa_string — template class __versa_string. Template string royalty. 👑
struct _Caster — name only in the original. 🎈
struct _Char_types — mapping from character type to associated types. Character-type matchmaking. 💘
class _ExtPtr_allocator — an example allocator which uses a non-standard pointer type. Example allocator with main character energy. 🌟
struct _Invalid_type — name only in the original. 🎈
class _Pointer_adapter — name only in the original. 🎈
class _Relative_pointer_impl — a storage policy for use with _Pointer_adapter<> which stores the pointer's address as an offset value which is relative to its own address. Relative-address realness. 📍
class _Relative_pointer_impl< const _Tp > — name only in the original. 🎈
class _Std_pointer_impl — a storage policy for use with _Pointer_adapter<> which yields a standard pointer. Standard pointer, standard slay. ✨
struct _Unqualified_type — name only in the original. 🎈
struct annotate_base — base class for checking address and label information about allocations. Create a std::map between the allocated address (void*) and a datum for annotations, which are a pair of numbers corresponding to label and allocated size. Annotation station. 🏷️
class binary_compose — an SGI extension. 🧩
class bitmap_allocator — Bitmap Allocator, primary template. Bitmap bestie. 🗺️
struct char_traits — base class used to implement std::char_traits. Trait school. 🎓
struct character — a POD class that serves as a character abstraction class. Character abstraction, cute. 🔤
struct condition_base — base struct for condition policy. Condition policy foundation. 🧱
struct constant_binary_fun — an SGI extension. 🧩
struct constant_unary_fun — an SGI extension. 🧩
struct constant_void_fun — an SGI extension. 🧩
class debug_allocator — a meta-allocator with debugging bits. Debugging allocator, very detective. 🕵️
class enc_filebuf — class enc_filebuf. That's the blurb, bestie. 🎈
struct encoding_char_traits — encoding_char_traits. Name so nice it's the description. 🎈
class encoding_state — extension to use iconv for dealing with character encodings. Encoding state, globally minded. 🌍
struct forced_error — thrown by utilities for testing exception safety. Error on demand, for science. 🧪
class free_list — the free list class for managing chunks of memory to be given to and returned by the bitmap_allocator. Free-list management realness. 📋
class hash_map — name only in the original. 🎈
class hash_multimap — name only in the original. 🎈
class hash_multiset — name only in the original. 🎈
class hash_set — name only in the original. 🎈
struct limit_condition — base class for incremental control and throw. Limit-condition behavior. 🚦
class malloc_allocator — an allocator that uses malloc. malloc girlie. 🧠
class new_allocator — an allocator that uses global new, as per C++03 [20.4.1]. new-school allocator. 🆕
struct project1st — an SGI extension. 🧩
struct project2nd — an SGI extension. 🧩
struct random_condition — base class for random probability control and throw. Random-condition chaos, controlled. 🎲
struct rb_tree — name only in the original. 🎈
class rope — name only in the original. 🪢
struct select1st — an SGI extension. 🧩
struct select2nd — an SGI extension. 🧩
class slist — name only in the original. 🎈
class stdio_filebuf — provides a layer of compatibility for C/POSIX. Compatibility layer, doing important work. 🫶
class stdio_sync_filebuf — provides a layer of compatibility for C. C-compatible sync filebuf. 🧵
class subtractive_rng — name only in the original. 🎈
struct temporary_buffer — name only in the original. 🎈
class throw_allocator_base — allocator class with logging and exception generation control. Intended to be used as an allocator_type in templatized code. Throwy allocator base. 🎯
struct throw_allocator_limit — allocator throwing via limit condition. Limit-throwing allocator. 🚦
struct throw_allocator_random — allocator throwing via random condition. Random-throwing allocator. 🎲
struct throw_value_base — class with exception generation control. Intended to be used as a value_type in templatized code. Throwy value base. 🎯
struct throw_value_limit — type throwing via limit condition. Limit-throwing type. 🚦
struct throw_value_random — type throwing via random condition. Random-throwing type. 🎲
class unary_compose — an SGI extension. 🧩

🧵 Typedefs 🧵

okay these are exact, so read them like the sacred texts they are. 📜

typedef void(* __destroy_handler) (void *)
template<typename _Tp > using __int_traits = __numeric_traits_integer< _Tp > — convenience alias for __numeric_traits<integer-type>. 🧠
typedef __versa_string< char, std::char_traits< char >, std::allocator< char >, __rc_string_base > __rc_string
typedef __vstring __sso_string
typedef __versa_string< char16_t, std::char_traits< char16_t >, std::allocator< char16_t >, __rc_string_base > __u16rc_string
typedef __u16vstring __u16sso_string
typedef __versa_string< char16_t > __u16vstring
typedef __versa_string< char32_t, std::char_traits< char32_t >, std::allocator< char32_t >, __rc_string_base > __u32rc_string
typedef __u32vstring __u32sso_string
typedef __versa_string< char32_t > __u32vstring
typedef __versa_string< char > __vstring
typedef __versa_string< wchar_t, std::char_traits< wchar_t >, std::allocator< wchar_t >, __rc_string_base > __wrc_string
typedef __wvstring __wsso_string
typedef __versa_string< wchar_t > __wvstring
typedef rope< char > crope
typedef rope< wchar_t > wrope

🔮 Enumerations 🔮

enum { _S_num_primes } — the unnamed enum with _S_num_primes. 🔢
enum _Lock_policy { _S_single, _S_mutex, _S_atomic } — the lock-policy enum, with _S_single, _S_mutex, and _S_atomic. 🔐

okay so the Functions section is a whole buffet bestie, like 90-plus entries, and we're going through every single one because we don't skip 💅 the double underscore at the front is giving "internal, do not touch" energy, iykyk, but here they all are in order, no skips, no cap.

void __atomic_add (volatile _Atomic_word *, int) noexcept — atomic add, exactly what it says on the tin, and it's noexcept so it is not about to throw hands 🙅‍♀️
void __atomic_add_dispatch (_Atomic_word *__mem, int __val) — the dispatch-y version, takes __mem and __val 🌸
void __atomic_add_single (_Atomic_word *__mem, int __val) — the _single flavored one, same __mem + __val duo 🫶
template<class _Tp > void __aux_require_boolean_expr (const _Tp &__t) — templated on _Tp, takes const _Tp &__t, and it's literally begging for a boolean expression ✨
template<typename _ToType , typename _FromType > _ToType __const_pointer_cast (_FromType *__arg) — const pointer cast, pointer-flavored, returns _ToType 🎀
template<typename _ToType , typename _FromType > _ToType __const_pointer_cast (const _FromType &__arg) — same cast but reference-flavored, const _FromType &__arg bestie 💖
template<typename _InputIterator , typename _Size , typename _OutputIterator > std::pair< _InputIterator, _OutputIterator > __copy_n (_InputIterator __first, _Size __count, _OutputIterator __result, std::input_iterator_tag) — __copy_n with the std::input_iterator_tag dispatch, hands you back a std::pair of the two iterators 👑
template<typename _RAIterator , typename _Size , typename _OutputIterator > std::pair< _RAIterator, _OutputIterator > __copy_n (_RAIterator __first, _Size __count, _OutputIterator __result, std::random_access_iterator_tag) — the random-access twin, std::random_access_iterator_tag, same std::pair return 🌈
template<typename _InputIterator , typename _Distance > void __distance (_InputIterator __first, _InputIterator __last, _Distance &__n, std::input_iterator_tag) — __distance for input iterators, drops the answer into __n 🦋
template<typename _RandomAccessIterator , typename _Distance > void __distance (_RandomAccessIterator __first, _RandomAccessIterator __last, _Distance &__n, std::random_access_iterator_tag) — and the random-access version, also writing into __n ⭐
template<typename _ToType , typename _FromType > _ToType __dynamic_pointer_cast (_FromType *__arg) — dynamic pointer cast, pointer intake, _ToType out 💅
template<typename _ToType , typename _FromType > _ToType __dynamic_pointer_cast (const _FromType &__arg) — reference edition of the dynamic cast, she's versatile 💜
void __error_type_must_be_a_signed_integer_type () — no args, no return, and the function name is the error message 😭 iconic
void __error_type_must_be_an_integer_type () — same vibe, different complaint 🧚
void __error_type_must_be_an_unsigned_integer_type () — and the unsigned one, completing the trio 🙈
_Atomic_word __exchange_and_add (volatile _Atomic_word *, int) noexcept — exchange-and-add, returns _Atomic_word, and again noexcept because she's drama-free 🔥
_Atomic_word __exchange_and_add_dispatch (_Atomic_word *__mem, int __val) — dispatch flavor, __mem + __val, returns _Atomic_word 🍓
_Atomic_word __exchange_and_add_single (_Atomic_word *__mem, int __val) — the _single one, same signature energy 🌸
template<class _Concept > constexpr void __function_requires () — constexpr, returns void, templated on a _Concept, zero arguments, maximum concept-check energy ✨
template<typename _Type > constexpr bool __is_null_pointer (_Type *__ptr) — pointer overload, constexpr bool, taking _Type *__ptr 🎀
template<typename _Type > constexpr bool __is_null_pointer (_Type) — non-pointer overload, still constexpr bool 🫶
constexpr bool __is_null_pointer (std::nullptr_t) — and the std::nullptr_t special, honestly the main character of the three 👑
bool __is_single_threaded () noexcept — zero args, bool out, noexcept, giving "are we single-threaded" realness 💖
template<typename _InputIterator1 , typename _InputIterator2 > int __lexicographical_compare_3way (_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2) — three-way lexicographical compare, two iterator pairs, int return 🌈
int __lexicographical_compare_3way (const char *__first1, const char *__last1, const char *__first2, const char *__last2) — the const char * overload, same four args, same int ⭐
int __lexicographical_compare_3way (const unsigned char *__first1, const unsigned char *__last1, const unsigned char *__first2, const unsigned char *__last2) — and the const unsigned char * one, completing the set 🦋
template<typename _Tp > const _Tp & __median (const _Tp &__a, const _Tp &__b, const _Tp &__c) — Find the median of three values. that's literally the whole job, three values in, median out 🔥
template<typename _Tp , typename _Compare > const _Tp & __median (const _Tp &__a, const _Tp &__b, const _Tp &__c, _Compare __comp) — Find the median of three values using a predicate for comparison. so you bring your own __comp and she respects it 💅
crope::reference __mutable_reference_at (crope &__c, std::size_t __i) — takes a crope &__c and a std::size_t __i, hands back a crope::reference 🌸
template<typename _Tp , typename _Integer > _Tp __power (_Tp __x, _Integer __n) — __power, base __x, exponent __n, _Tp all the way out ⚡
template<typename _Tp , typename _Integer , typename _MonoidOperation > _Tp __power (_Tp __x, _Integer __n, _MonoidOperation __monoid_op) — same but you also pass a __monoid_op, fancy 🎀
template<typename _InputIterator , typename _RandomAccessIterator , typename _RandomNumberGenerator , typename _Distance > _RandomAccessIterator __random_sample (_InputIterator __first, _InputIterator __last, _RandomAccessIterator __out, _RandomNumberGenerator &__rand, const _Distance __n) — random sample time, you bring your own __rand generator and a const _Distance __n, returns the _RandomAccessIterator out 🎲 vibes
template<typename _InputIterator , typename _RandomAccessIterator , typename _Distance > _RandomAccessIterator __random_sample (_InputIterator __first, _InputIterator __last, _RandomAccessIterator __out, const _Distance __n) — the no-generator version, same __first/__last/__out/__n lineup ✨
template<typename _ToType , typename _FromType > _ToType __reinterpret_pointer_cast (_FromType *__arg) — reinterpret pointer cast, pointer flavor, _ToType returned 🙈
template<typename _ToType , typename _FromType > _ToType __reinterpret_pointer_cast (const _FromType &__arg) — reference flavor of the same, she contains multitudes 💜
_Slist_node_base * __slist_make_link (_Slist_node_base *__prev_node, _Slist_node_base *__new_node) — slist link-making, two _Slist_node_base * in, one out 🔗
_Slist_node_base * __slist_previous (_Slist_node_base *__head, const _Slist_node_base *__node) — mutable __head, const __node, returns _Slist_node_base * 🦋
const _Slist_node_base * __slist_previous (const _Slist_node_base *__head, const _Slist_node_base *__node) — the fully const overload, both args const, const return, she's keeping it pure ✨
_Slist_node_base * __slist_reverse (_Slist_node_base *__node) — reverse the slist, __node in, _Slist_node_base * out 🔄
std::size_t __slist_size (_Slist_node_base *__node) — size of the slist, returns std::size_t 📏
void __slist_splice_after (_Slist_node_base *__pos, _Slist_node_base *__before_first, _Slist_node_base *__before_last) — splice-after with the range trio __pos, __before_first, __before_last 🌸
void __slist_splice_after (_Slist_node_base *__pos, _Slist_node_base *__head) — the shorter splice-after, just __pos and __head 🎀
template<typename _ToType , typename _FromType > _ToType __static_pointer_cast (_FromType *__arg) — static pointer cast, pointer flavor, slay 🫶
template<typename _ToType , typename _FromType > _ToType __static_pointer_cast (const _FromType &__arg) — reference flavor, same deal 💖
size_t __stl_hash_string (const char *__s) — STL hash a string, const char *__s in, size_t out 🍓
unsigned long __stl_next_prime (unsigned long __n) — STL next prime, unsigned long __n in, unsigned long out, primes are lowkey iconic 🔢
template<typename _TRet , typename _Ret = _TRet, typename _CharT , typename... _Base> _Ret __stoa (_TRet(*__convf)(const _CharT *, _CharT **, _Base...), const char *__name, const _CharT *__str, std::size_t *__idx, _Base... __base) — okay this one is a whole meal bestie, variadic _Base..., a _TRet(*__convf) function pointer, __name, __str, __idx, the works, no notes 🔥
void __throw_concurrence_lock_error () — zero args, throws the concurrence lock error, that's the whole personality 😭
void __throw_concurrence_unlock_error () — same but unlock, the matching set 💀
void __throw_forced_error () — forced error, literally named after the drama 🙈
template<typename _String , typename _CharT = typename _String::value_type> _String __to_xstring (int(*__convf)(_CharT *, std::size_t, const _CharT *, __builtin_va_list), std::size_t __n, const _CharT *__fmt,...) — __to_xstring, note the ... varargs at the end, plus __convf, __n, __fmt, and a _CharT defaulted from _String::value_type ✨
template<typename _InputIter , typename _Size , typename _ForwardIter > std::pair< _InputIter, _ForwardIter > __uninitialized_copy_n (_InputIter __first, _Size __count, _ForwardIter __result) — uninitialized copy n, __first/__count/__result, std::pair return 🎀
template<typename _InputIter , typename _Size , typename _ForwardIter > std::pair< _InputIter, _ForwardIter > __uninitialized_copy_n (_InputIter __first, _Size __count, _ForwardIter __result, std::input_iterator_tag) — same trio plus std::input_iterator_tag dispatch 💅
template<typename _RandomAccessIter , typename _Size , typename _ForwardIter > std::pair< _RandomAccessIter, _ForwardIter > __uninitialized_copy_n (_RandomAccessIter __first, _Size __count, _ForwardIter __result, std::random_access_iterator_tag) — and the std::random_access_iterator_tag one, _RandomAccessIter front and center 🦋
template<typename _InputIter , typename _Size , typename _ForwardIter , typename _Allocator > std::pair< _InputIter, _ForwardIter > __uninitialized_copy_n_a (_InputIter __first, _Size __count, _ForwardIter __result, _Allocator __alloc) — the _a version so you can pass an _Allocator __alloc too 🌸
template<typename _InputIter , typename _Size , typename _ForwardIter , typename _Tp > std::pair< _InputIter, _ForwardIter > __uninitialized_copy_n_a (_InputIter __first, _Size __count, _ForwardIter __result, std::allocator< _Tp >) — and the std::allocator< _Tp > overload, note the allocator arg has no name here, that's not a typo bestie 🫶
void __verbose_terminate_handler () — A replacement for the standard terminate_handler which prints more information about the terminating exception (if any) on stderr. so when everything is on fire, this one spills the tea to stderr 🔥😭
std::size_t _Bit_scan_forward (std::size_t __num) — Generic Version of the bsf instruction. std::size_t __num in, std::size_t out, bit-scanning realness ⭐
template<typename _ForwardIterator , typename _Allocator > void _Destroy_const (_ForwardIterator __first, _ForwardIterator __last, _Allocator __alloc) — _Destroy_const with __first, __last, __alloc 🎀
template<typename _ForwardIterator , typename _Tp > void _Destroy_const (_ForwardIterator __first, _ForwardIterator __last, std::allocator< _Tp >) — and the std::allocator< _Tp > overload, again the allocator arg is unnamed 💜
template<class _CharT , class _Traits > void _Rope_fill (std::basic_ostream< _CharT, _Traits > &__o, std::size_t __n) — rope fill, takes the stream __o and std::size_t __n 🌈
template<class _CharT > bool _Rope_is_simple (_CharT *) — _Rope_is_simple, templated, bool out ✨
bool _Rope_is_simple (char *) — the char * overload 🍓
bool _Rope_is_simple (wchar_t *) — and the wchar_t * overload, trio complete 🧚
template<class _Rope_iterator > void _Rope_rotate (_Rope_iterator __first, _Rope_iterator __middle, _Rope_iterator __last) — rope rotate with the classic __first, __middle, __last lineup 🔄
template<class _CharT > void _S_cond_store_eos (_CharT &) — cond store end-of-string, templated, returns void 🎀
void _S_cond_store_eos (char &__c) — the char &__c overload 💖
void _S_cond_store_eos (wchar_t &__c) — the wchar_t &__c overload, and that's all three 🫶
template<class _CharT > _CharT _S_eos (_CharT *) — _S_eos, templated, returns _CharT 🌸
template<class _CharT > bool _S_is_basic_char_type (_CharT *) — is-basic-char-type, templated, bool out ⭐
bool _S_is_basic_char_type (char *) — the char * one 🌈
bool _S_is_basic_char_type (wchar_t *) — and the wchar_t * one 🦋
template<class _CharT > bool _S_is_one_byte_char_type (_CharT *) — one-byte-char-type check, templated, bool 💅
bool _S_is_one_byte_char_type (char *) — the char * overload, she only has two, that's it, that's the list 🍓

okay and now the math girlies enter the chat 🧮✨

template<typename _Tp > __gnu_cxx::__promote< _Tp >::__type airy_ai (_Tp __x) — airy_ai, templated, returns __gnu_cxx::__promote< _Tp >::__type, takes _Tp __x 💜
float airy_aif (float __x) — the float one, airy_aif, returns float 🎀
long double airy_ail (long double __x) — the long double one, returns long double 🌸
template<typename _Tp > __gnu_cxx::__promote< _Tp >::__type airy_bi (_Tp __x) — airy_bi, same promote-type return energy ✨
float airy_bif (float __x) — float flavor, airy_bif 💖
long double airy_bil (long double __x) — long double flavor, airy_bil 🫶
template<class _Operation1 , class _Operation2 > unary_compose< _Operation1, _Operation2 > compose1 (const _Operation1 &__fn1, const _Operation2 &__fn2) — An SGI extension. composes __fn1 and __fn2 into a unary_compose, lowkey elegant 🎀
template<class _Operation1 , class _Operation2 , class _Operation3 > binary_compose< _Operation1, _Operation2, _Operation3 > compose2 (const _Operation1 &__fn1, const _Operation2 &__fn2, const _Operation3 &__fn3) — An SGI extension. three functions, one binary_compose, the sequel slaps 🔥
template<typename _Tpa , typename _Tpc , typename _Tp > __gnu_cxx::__promote_3< _Tpa, _Tpc, _Tp >::__type conf_hyperg (_Tpa __a, _Tpc __c, _Tp __x) — conf_hyperg, three separate types _Tpa/_Tpc/_Tp, __promote_3 return 💅
float conf_hypergf (float __a, float __c, float __x) — the float trio version, conf_hypergf 🌈
long double conf_hypergl (long double __a, long double __c, long double __x) — the long double trio version, conf_hypergl ⭐
template<class _Result > constant_void_fun< _Result > constant0 (const _Result &__val) — An SGI extension. constant0, hands back a constant_void_fun 🦋
template<class _Result > constant_unary_fun< _Result, _Result > constant1 (const _Result &__val) — An SGI extension. constant1, now it's a constant_unary_fun ✨
template<class _Result > constant_binary_fun< _Result, _Result, _Result > constant2 (const _Result &__val) — An SGI extension. constant2, constant_binary_fun with _Result three times because she's extra 💖
template<typename _InputIterator , typename _Size , typename _OutputIterator > std::pair< _InputIterator, _OutputIterator > copy_n (_InputIterator __first, _Size __count, _OutputIterator __result) — Copies the range [first,first+count) into [result,result+count). so __first plus __count goes into __result, and you get the std::pair back 🎀
template<typename _InputIterator , typename _Tp , typename _Size > void count (_InputIterator __first, _InputIterator __last, const _Tp &__value, _Size &__n) — count, writes the tally into __n 💅
template<typename _InputIterator , typename _Predicate , typename _Size > void count_if (_InputIterator __first, _InputIterator __last, _Predicate __pred, _Size &__n) — count_if but with a __pred, also dropping into __n 🫶
template<typename _InputIterator , typename _Distance > void distance (_InputIterator __first, _InputIterator __last, _Distance &__n) — distance, __first to __last, result in __n 🌸
template<typename _Tpa , typename _Tpb , typename _Tpc , typename _Tp > __gnu_cxx::__promote_4< _Tpa, _Tpb, _Tpc, _Tp >::__type hyperg (_Tpa __a, _Tpb __b, _Tpc __c, _Tp __x) — hyperg, four types deep, __promote_4, she's committed 👑
float hypergf (float __a, float __b, float __c, float __x) — float edition, hypergf 🍓
long double hypergl (long double __a, long double __b, long double __c, — and this is literally where the page cuts off bestie 😭 the long double hypergl signature with __a, __b, __c, and then… nothing. no cap, that's the end of this part. stay tuned 🧚✨
and we're literally starting mid-signature 😭 the last one from before trails off here, so here's its tail:

long double __x)

identity_element (multiplication version) — the "what's the neutral element for ×" hook. An SGI extension ✨

template<class _Tp > _Tp identity_element (std::multiplies< _Tp >)

identity_element (addition version) — same energy but for +. An SGI extension 💖

template<class _Tp > _Tp identity_element (std::plus< _Tp >)

lexicographical_compare_3way — bestie. it's literally memcmp on steroids 💪

template<typename _InputIterator1 , typename _InputIterator2 > int
lexicographical_compare_3way (_InputIterator1 __first1,
_InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2
__last2)

mem_fun1 (const flavor) — wraps a const member function that takes one arg into a std::const_mem_fun1_t< _Ret, _Tp, _Arg >:

template<class _Ret , class _Tp , class _Arg > std::const_mem_fun1_t<
_Ret, _Tp, _Arg > mem_fun1 (_Ret(_Tp::*__f)(_Arg) const)

mem_fun1 (non-const flavor) — same deal, no const, returns std::mem_fun1_t< _Ret, _Tp, _Arg >:

template<class _Ret , class _Tp , class _Arg > std::mem_fun1_t< _Ret,
_Tp, _Arg > mem_fun1 (_Ret(_Tp::*__f)(_Arg))

mem_fun1_ref (const flavor) — the reference-y sibling, hands you a std::const_mem_fun1_ref_t< _Ret, _Tp, _Arg >:

template<class _Ret , class _Tp , class _Arg >
std::const_mem_fun1_ref_t< _Ret, _Tp, _Arg > mem_fun1_ref
(_Ret(_Tp::*__f)(_Arg) const)

mem_fun1_ref (non-const flavor) — and the non-const one, giving std::mem_fun1_ref_t< _Ret, _Tp, _Arg >:

template<class _Ret , class _Tp , class _Arg > std::mem_fun1_ref_t<
_Ret, _Tp, _Arg > mem_fun1_ref (_Ret(_Tp::*__f)(_Arg))

ok now the `operator!=` era 👑 (there are SO many, buckle up)

operator!= for _Pointer_adapter vs raw _Tp2 — not-equal check, pointer-adapter-on-the-left style:

template<typename _Tp1 , typename _Tp2 > bool operator!= (_Tp1 __lhs,
const _Pointer_adapter< _Tp2 > &__rhs)

operator!= for two __versa_strings — Test difference of two strings. 🎀

template<typename _CharT , typename _Traits , typename _Alloc ,
template< typename, typename, typename > class _Base> bool
operator!= (const __versa_string< _CharT, _Traits, _Alloc, _Base >
&__lhs, const __versa_string< _CharT, _Traits, _Alloc, _Base >
&__rhs)

operator!= for __versa_string vs C string — Test difference of string and C string. ✨

template<typename _CharT , typename _Traits , typename _Alloc ,
template< typename, typename, typename > class _Base> bool
operator!= (const __versa_string< _CharT, _Traits, _Alloc, _Base >
&__lhs, const _CharT *__rhs)

operator!= for C string vs __versa_string — Test difference of C string and string. 💖

template<typename _CharT , typename _Traits , typename _Alloc ,
template< typename, typename, typename > class _Base> bool
operator!= (const _CharT *__lhs, const __versa_string< _CharT,
_Traits, _Alloc, _Base > &__rhs)

operator!= for two _Pointer_adapters — both sides adapter, no cap:

template<typename _Tp > bool operator!= (const _Pointer_adapter< _Tp >
&__lhs, const _Pointer_adapter< _Tp > &__rhs)

operator!= for _Pointer_adapter vs int — adapter on the left, plain int on the right:

template<typename _Tp > bool operator!= (const _Pointer_adapter< _Tp >
&__lhs, int __rhs)

operator!= for _Pointer_adapter vs arbitrary _Tp2 — left is the adapter, right is whatever:

template<typename _Tp1 , typename _Tp2 > bool operator!= (const
_Pointer_adapter< _Tp1 > &__lhs, _Tp2 __rhs)

operator!= for two different _Pointer_adapter types — _Tp1 and _Tp2 are not the same type, and that's the whole point 🦋

template<typename _Tp1 , typename _Tp2 > bool operator!= (const
_Pointer_adapter< _Tp1 > &__lhs, const _Pointer_adapter< _Tp2 >
&__rhs)

operator!= for _Rope_char_ptr_proxy — yep, even the rope char proxy gets a not-equal:

template<class _CharT , class _Alloc > bool operator!= (const
_Rope_char_ptr_proxy< _CharT, _Alloc > &__x, const
_Rope_char_ptr_proxy< _CharT, _Alloc > &__y)

operator!= for _Rope_const_iterator — comparing two const rope iterators, iconic:

template<class _CharT , class _Alloc > bool operator!= (const
_Rope_const_iterator< _CharT, _Alloc > &__x, const
_Rope_const_iterator< _CharT, _Alloc > &__y)

operator!= for _Rope_iterator — the non-const iterator version, equally slay:

template<class _CharT , class _Alloc > bool operator!= (const
_Rope_iterator< _CharT, _Alloc > &__x, const _Rope_iterator< _CharT,
_Alloc > &__y)

operator!= for hash_map — two whole hash maps, compared for difference:

template<class _Key , class _Tp , class _HashFn , class _EqlKey , class
_Alloc > bool operator!= (const hash_map< _Key, _Tp, _HashFn,
_EqlKey, _Alloc > &__hm1, const hash_map< _Key, _Tp, _HashFn,
_EqlKey, _Alloc > &__hm2)

operator!= for hash_multimap — same but the multi one, note the template params got renamed to _HF / _EqKey 💅

template<class _Key , class _Tp , class _HF , class _EqKey , class
_Alloc > bool operator!= (const hash_multimap< _Key, _Tp, _HF,
_EqKey, _Alloc > &__hm1, const hash_multimap< _Key, _Tp, _HF,
_EqKey, _Alloc > &__hm2)

operator!= for hash_multiset — multiset edition, _Val / _HashFcn / _EqualKey / _Alloc:

template<class _Val , class _HashFcn , class _EqualKey , class _Alloc >
bool operator!= (const hash_multiset< _Val, _HashFcn, _EqualKey,
_Alloc > &__hs1, const hash_multiset< _Val, _HashFcn, _EqualKey,
_Alloc > &__hs2)

operator!= for hash_set — and the plain hash set, right after:

template<class _Value , class _HashFcn , class _EqualKey , class _Alloc
> bool operator!= (const hash_set< _Value, _HashFcn, _EqualKey,
_Alloc > &__hs1, const hash_set< _Value, _HashFcn, _EqualKey, _Alloc
> &__hs2)

operator!= for hashtable — the lowkey main character underneath all of the above, six template params deep:

template<class _Val , class _Key , class _HF , class _Ex , class _Eq ,
class _All > bool operator!= (const hashtable< _Val, _Key, _HF, _Ex,
_Eq, _All > &__ht1, const hashtable< _Val, _Key, _HF, _Ex, _Eq, _All
> &__ht2)

operator!= for rope — the big string, not equal:

template<class _CharT , class _Alloc > bool operator!= (const rope<
_CharT, _Alloc > &__x, const rope< _CharT, _Alloc > &__y)

operator!= for slist — note the arg names are literally _SL1 and _SL2, we love a naming choice 🙈

template<class _Tp , class _Alloc > bool operator!= (const slist< _Tp,
_Alloc > &_SL1, const slist< _Tp, _Alloc > &_SL2)

operator!= with int on the left, _Pointer_adapter on the right — the mirror of the earlier one:

template<typename _Tp > bool operator!= (int __lhs, const
_Pointer_adapter< _Tp > &__rhs)

arithmetic operators, we're in our math era 🔥

operator* for throw_value_base — multiplying two of them together:

template<typename _Cond > throw_value_base< _Cond > operator* (const
throw_value_base< _Cond > &__a, const throw_value_base< _Cond >
&__b)

operator+ for two rvalue __versa_strings — move-y plus move-y:

template<typename _CharT , typename _Traits , typename _Alloc ,
template< typename, typename, typename > class _Base>
__versa_string< _CharT, _Traits, _Alloc, _Base > operator+
(__versa_string< _CharT, _Traits, _Alloc, _Base > &&__lhs,
__versa_string< _CharT, _Traits, _Alloc, _Base > &&__rhs)

operator+ rvalue __versa_string + _CharT — string-ish thing plus one character:

template<typename _CharT , typename _Traits , typename _Alloc ,
template< typename, typename, typename > class _Base>
__versa_string< _CharT, _Traits, _Alloc, _Base > operator+
(__versa_string< _CharT, _Traits, _Alloc, _Base > &&__lhs, _CharT
__rhs)

operator+ rvalue __versa_string + const __versa_string — moving string plus lvalue string:

template<typename _CharT , typename _Traits , typename _Alloc ,
template< typename, typename, typename > class _Base>
__versa_string< _CharT, _Traits, _Alloc, _Base > operator+
(__versa_string< _CharT, _Traits, _Alloc, _Base > &&__lhs, const
__versa_string< _CharT, _Traits, _Alloc, _Base > &__rhs)

operator+ rvalue __versa_string + const _CharT * — moving string plus a C string:

template<typename _CharT , typename _Traits , typename _Alloc ,
template< typename, typename, typename > class _Base>
__versa_string< _CharT, _Traits, _Alloc, _Base > operator+
(__versa_string< _CharT, _Traits, _Alloc, _Base > &&__lhs, const
_CharT *__rhs)

operator+ _CharT + rvalue __versa_string — character first this time:

template<typename _CharT , typename _Traits , typename _Alloc ,
template< typename, typename, typename > class _Base>
__versa_string< _CharT, _Traits, _Alloc, _Base > operator+ (_CharT
__lhs, __versa_string< _CharT, _Traits, _Alloc, _Base > &&__rhs)

operator+ _CharT + const __versa_string — Concatenate character and string. 🎀

template<typename _CharT , typename _Traits , typename _Alloc ,
template< typename, typename, typename > class _Base>
__versa_string< _CharT, _Traits, _Alloc, _Base > operator+ (_CharT
__lhs, const __versa_string< _CharT, _Traits, _Alloc, _Base >
&__rhs)

operator+ const __versa_string + rvalue __versa_string — lvalue plus mover:

template<typename _CharT , typename _Traits , typename _Alloc ,
template< typename, typename, typename > class _Base>
__versa_string< _CharT, _Traits, _Alloc, _Base > operator+ (const
__versa_string< _CharT, _Traits, _Alloc, _Base > &__lhs,
__versa_string< _CharT, _Traits, _Alloc, _Base > &&__rhs)

operator+ const __versa_string + _CharT — Concatenate string and character. ✨

template<typename _CharT , typename _Traits , typename _Alloc ,
template< typename, typename, typename > class _Base>
__versa_string< _CharT, _Traits, _Alloc, _Base > operator+ (const
__versa_string< _CharT, _Traits, _Alloc, _Base > &__lhs, _CharT
__rhs)

operator+ const __versa_string + const __versa_string — Concatenate two strings. the classic 💖

template<typename _CharT , typename _Traits , typename _Alloc ,
template< typename, typename, typename > class _Base>
__versa_string< _CharT, _Traits, _Alloc, _Base > operator+ (const
__versa_string< _CharT, _Traits, _Alloc, _Base > &__lhs, const
__versa_string< _CharT, _Traits, _Alloc, _Base > &__rhs)

operator+ const __versa_string + const _CharT * — Concatenate string and C string. 🦋

template<typename _CharT , typename _Traits , typename _Alloc ,
template< typename, typename, typename > class _Base>
__versa_string< _CharT, _Traits, _Alloc, _Base > operator+ (const
__versa_string< _CharT, _Traits, _Alloc, _Base > &__lhs, const
_CharT *__rhs)

operator+ const _CharT * + rvalue __versa_string — C string then mover:

template<typename _CharT , typename _Traits , typename _Alloc ,
template< typename, typename, typename > class _Base>
__versa_string< _CharT, _Traits, _Alloc, _Base > operator+ (const
_CharT *__lhs, __versa_string< _CharT, _Traits, _Alloc, _Base >
&&__rhs)

operator+ const _CharT * + const __versa_string — Concatenate C string and string. 🌸

template<typename _CharT , typename _Traits , typename _Alloc ,
template< typename, typename, typename > class _Base>
__versa_string< _CharT, _Traits, _Alloc, _Base > operator+ (const
_CharT *__lhs, const __versa_string< _CharT, _Traits, _Alloc, _Base
> &__rhs)

rope + iterator arithmetic, aka the pointer math chapter 🧚

operator+ on _Rope_const_iterator + std::ptrdiff_t — jump forward __n:

template<class _CharT , class _Alloc > _Rope_const_iterator< _CharT,
_Alloc > operator+ (const _Rope_const_iterator< _CharT, _Alloc >
&__x, std::ptrdiff_t __n)

operator+ on _Rope_iterator + std::ptrdiff_t — same jump, non-const iterator:

template<class _CharT , class _Alloc > _Rope_iterator< _CharT, _Alloc >
operator+ (const _Rope_iterator< _CharT, _Alloc > &__x,
std::ptrdiff_t __n)

operator+ rope + _CharT — rope, then one character on the end:

template<class _CharT , class _Alloc > rope< _CharT, _Alloc > operator+
(const rope< _CharT, _Alloc > &__left, _CharT __right)

operator+ rope + const _CharT * — rope, then a C string:

template<class _CharT , class _Alloc > rope< _CharT, _Alloc > operator+
(const rope< _CharT, _Alloc > &__left, const _CharT *__right)

operator+ rope + rope — two ropes, one concatenation, no notes 💅

template<class _CharT , class _Alloc > rope< _CharT, _Alloc > operator+
(const rope< _CharT, _Alloc > &__left, const rope< _CharT, _Alloc >
&__right)

operator+ for throw_value_base — adding two of them:

template<typename _Cond > throw_value_base< _Cond > operator+ (const
throw_value_base< _Cond > &__a, const throw_value_base< _Cond >
&__b)

operator+ std::ptrdiff_t + _Rope_const_iterator — flipped order, __n first:

template<class _CharT , class _Alloc > _Rope_const_iterator< _CharT,
_Alloc > operator+ (std::ptrdiff_t __n, const _Rope_const_iterator<
_CharT, _Alloc > &__x)

operator+ std::ptrdiff_t + _Rope_iterator — same but non-const:

template<class _CharT , class _Alloc > _Rope_iterator< _CharT, _Alloc >
operator+ (std::ptrdiff_t __n, const _Rope_iterator< _CharT, _Alloc
> &__x)

operator+ difference_type + __normal_iterator — and it's constexpr and noexcept, she's got range and she's trustworthy 😌:

template<typename _Iterator , typename _Container > constexpr
__normal_iterator< _Iterator, _Container > operator+ (typename
__normal_iterator< _Iterator, _Container >::difference_type __n,
const __normal_iterator< _Iterator, _Container > &__i) noexcept

`operator+=` and `operator-` (yes they're different, bestie) 🍓

operator+= rope + _CharT — appends one character, returns the rope by reference:

template<class _CharT , class _Alloc > rope< _CharT, _Alloc > &
operator+= (rope< _CharT, _Alloc > &__left, _CharT __right)

operator+= rope + const _CharT * — appends a C string, also by reference:

template<class _CharT , class _Alloc > rope< _CharT, _Alloc > &
operator+= (rope< _CharT, _Alloc > &__left, const _CharT *__right)

operator+= rope + rope — appends a whole other rope:

template<class _CharT , class _Alloc > rope< _CharT, _Alloc > &
operator+= (rope< _CharT, _Alloc > &__left, const rope< _CharT,
_Alloc > &__right)

operator- between two __normal_iterators (same type) — gives you the difference_type, constexpr, noexcept:

template<typename _Iterator , typename _Container > constexpr
__normal_iterator< _Iterator, _Container >::difference_type
operator- (const __normal_iterator< _Iterator, _Container > &__lhs,
const __normal_iterator< _Iterator, _Container > &__rhs) noexcept

operator- between different __normal_iterator types — _IteratorL and _IteratorR, with a trailing return type doing decltype(__lhs.base() - __rhs.base()), constexpr + noexcept too:

template<typename _IteratorL , typename _IteratorR , typename _Container
> constexpr auto operator- (const __normal_iterator< _IteratorL,
_Container > &__lhs, const __normal_iterator< _IteratorR, _Container
> &__rhs) noexcept -> decltype(__lhs.base() - __rhs.base())

operator- on _Rope_const_iterator — returns std::ptrdiff_t... and the source honestly cuts off right here mid-signature 😭

template<class _CharT , class _Alloc > std::ptrdiff_t operator- (const

_Rope_const_iterator< _CharT, _Alloc > &__x, const _Rope_const_iterator< _CharT, _Alloc > &__y) — this is literally the tail end of the previous signature, bestie; the manpage split it mid-flex, not me 💅
template<class _CharT , class _Alloc > _Rope_const_iterator< _CharT, _Alloc > operator- (const _Rope_const_iterator< _CharT, _Alloc > &__x, std::ptrdiff_t __n) — rope-const-iterator math with a std::ptrdiff_t offset, iconic behavior only ✨
template<class _CharT , class _Alloc > std::ptrdiff_t operator- (const _Rope_iterator< _CharT, _Alloc > &__x, const _Rope_iterator< _CharT, _Alloc > &__y) — subtract two rope iterators and get a std::ptrdiff_t, no cap 🫶
template<class _CharT , class _Alloc > _Rope_iterator< _CharT, _Alloc > operator- (const _Rope_iterator< _CharT, _Alloc > &__x, std::ptrdiff_t __n) — rope-iterator offset math, same vibe, different iterator 💫
template<typename _Cond > throw_value_base< _Cond > operator- (const throw_value_base< _Cond > &__a, const throw_value_base< _Cond > &__b) — subtract two throw_value_base things and get one right back 😭
template<typename _Tp1 , typename _Tp2 > bool operator< (_Tp1 __lhs, const _Pointer_adapter< _Tp2 > &__rhs) — less-than check where the right side is a _Pointer_adapter, yes/no energy 🔥
template<typename _CharT , typename _Traits , typename _Alloc , template< typename, typename, typename > class _Base> bool operator< (const __versa_string< _CharT, _Traits, _Alloc, _Base > &__lhs, const __versa_string< _CharT, _Traits, _Alloc, _Base > &__rhs) — test if string precedes string, periodt 🎀
template<typename _CharT , typename _Traits , typename _Alloc , template< typename, typename, typename > class _Base> bool operator< (const __versa_string< _CharT, _Traits, _Alloc, _Base > &__lhs, const _CharT *__rhs) — test if string precedes C string, chef’s kiss 🌸
template<typename _CharT , typename _Traits , typename _Alloc , template< typename, typename, typename > class _Base> bool operator< (const _CharT *__lhs, const __versa_string< _CharT, _Traits, _Alloc, _Base > &__rhs) — test if C string precedes string, yup yup 🦋
template<typename _Tp1 , typename _Tp2 > bool operator< (const _Pointer_adapter< _Tp1 > &__lhs, _Tp2 __rhs) — less-than where the left side is the _Pointer_adapter, cute 💜
template<typename _Tp1 , typename _Tp2 > bool operator< (const _Pointer_adapter< _Tp1 > &__lhs, const _Pointer_adapter< _Tp2 > &__rhs) — pointer-adapter vs pointer-adapter less-than, lowkey essential ⭐
template<class _CharT , class _Alloc > bool operator< (const _Rope_const_iterator< _CharT, _Alloc > &__x, const _Rope_const_iterator< _CharT, _Alloc > &__y) — rope-const-iterator comparison, no drama 💅
template<class _CharT , class _Alloc > bool operator< (const _Rope_iterator< _CharT, _Alloc > &__x, const _Rope_iterator< _CharT, _Alloc > &__y) — rope-iterator comparison, same energy 🎀
template<typename _Value , typename _Int , typename _St > bool operator< (const character< _Value, _Int, _St > &lhs, const character< _Value, _Int, _St > &rhs) — compare two character objects, iykyk 🌈
template<class _CharT , class _Alloc > bool operator< (const rope< _CharT, _Alloc > &__left, const rope< _CharT, _Alloc > &__right) — rope vs rope, less-than edition 🧚
template<class _Tp , class _Alloc > bool operator< (const slist< _Tp, _Alloc > &_SL1, const slist< _Tp, _Alloc > &_SL2) — slist comparison, main character energy 👑
template<typename _Cond > bool operator< (const throw_value_base< _Cond > &__a, const throw_value_base< _Cond > &__b) — throw_value_base less-than, fr fr 💀
template<class _CharT , class _Traits , class _Alloc > std::basic_ostream< _CharT, _Traits > & operator<< (std::basic_ostream< _CharT, _Traits > &__o, const rope< _CharT, _Alloc > &__r) — stream a rope straight into a std::basic_ostream, slay 💖
template<typename _RealType , typename _CharT , typename _Traits > std::basic_ostream< _CharT, _Traits > & operator<< (std::basic_ostream< _CharT, _Traits > &__os, const __gnu_cxx::beta_distribution< _RealType > &__x) — stream a beta_distribution, cute ✨
template<typename _UIntType , typename _CharT , typename _Traits > std::basic_ostream< _CharT, _Traits > & operator<< (std::basic_ostream< _CharT, _Traits > &__os, const __gnu_cxx::hypergeometric_distribution< _UIntType > &__x) — stream a hypergeometric_distribution, obsessed 🎀
template<size_t _Dimen, typename _RealType , typename _CharT , typename _Traits > std::basic_ostream< _CharT, _Traits > & operator<< (std::basic_ostream< _CharT, _Traits > &__os, const __gnu_cxx::normal_mv_distribution< _Dimen, _RealType > &__x) — stream a normal_mv_distribution, dimensionally iconic 🦋
template<typename _UIntType , size_t __m, size_t __pos1, size_t __sl1, size_t __sl2, size_t __sr1, size_t __sr2, uint32_t __msk1, uint32_t __msk2, uint32_t __msk3, uint32_t __msk4, uint32_t __parity1, uint32_t __parity2, uint32_t __parity3, uint32_t __parity4, typename _CharT , typename _Traits > std::basic_ostream< _CharT, _Traits > & operator<< (std::basic_ostream< _CharT, _Traits > &__os, const __gnu_cxx::simd_fast_mersenne_twister_engine< _UIntType, __m, __pos1, __sl1, __sl2, __sr1, __sr2, __msk1, __msk2, __msk3, __msk4, __parity1, __parity2, __parity3, __parity4 > &__x) — stream the whole simd_fast_mersenne_twister_engine flex, and yes every template parameter is invited to the party 😭🔥
template<typename _RealType , typename _CharT , typename _Traits > std::basic_ostream< _CharT, _Traits > & operator<< (std::basic_ostream< _CharT, _Traits > &__os, const __gnu_cxx::triangular_distribution< _RealType > &__x) — stream a triangular_distribution, triangle emoji energy 🔺✨
template<std::size_t _Dimen, typename _RealType , typename _CharT , typename _Traits > std::basic_ostream< _CharT, _Traits > & operator<< (std::basic_ostream< _CharT, _Traits > &__os, const __gnu_cxx::uniform_inside_sphere_distribution< _Dimen, _RealType > &__x) — stream uniform_inside_sphere_distribution, inside-sphere but make it cout 🌐
template<std::size_t _Dimen, typename _RealType , typename _CharT , typename _Traits > std::basic_ostream< _CharT, _Traits > & operator<< (std::basic_ostream< _CharT, _Traits > &__os, const __gnu_cxx::uniform_on_sphere_distribution< _Dimen, _RealType > &__x) — stream uniform_on_sphere_distribution, on-sphere edition 🫧
template<typename _RealType , typename _CharT , typename _Traits > std::basic_ostream< _CharT, _Traits > & operator<< (std::basic_ostream< _CharT, _Traits > &__os, const __gnu_cxx::von_mises_distribution< _RealType > &__x) — stream a von_mises_distribution, fancy name, fancy output 💅
template<typename _CharT , typename _Traits , typename _StoreT > std::basic_ostream< _CharT, _Traits > & operator<< (std::basic_ostream< _CharT, _Traits > &__os, const _Pointer_adapter< _StoreT > &__p) — stream a _Pointer_adapter, pointer-adjacent and proud 🌟
template<typename _RealType , typename _CharT , typename _Traits > std::basic_ostream< _CharT, _Traits > & operator<< (std::basic_ostream< _CharT, _Traits > &__os, const arcsine_distribution< _RealType > &__x) — stream arcsine_distribution, trig-adjacent slay 🌸
template<typename _RealType , typename _CharT , typename _Traits > std::basic_ostream< _CharT, _Traits > & operator<< (std::basic_ostream< _CharT, _Traits > &__os, const hoyt_distribution< _RealType > &__x) — stream hoyt_distribution, niche but iconic 🎀
template<typename _RealType , typename _CharT , typename _Traits > std::basic_ostream< _CharT, _Traits > & operator<< (std::basic_ostream< _CharT, _Traits > &__os, const k_distribution< _RealType > &__x) — stream k_distribution, single-letter legend 💜
template<typename _RealType , typename _CharT , typename _Traits > std::basic_ostream< _CharT, _Traits > & operator<< (std::basic_ostream< _CharT, _Traits > &__os, const logistic_distribution< _RealType > &__x) — stream logistic_distribution, logistics but make it cute 📦✨
template<typename _RealType , typename _CharT , typename _Traits > std::basic_ostream< _CharT, _Traits > & operator<< (std::basic_ostream< _CharT, _Traits > &__os, const nakagami_distribution< _RealType > &__x) — stream nakagami_distribution, say it with your chest 🗣️
template<typename _RealType , typename _CharT , typename _Traits > std::basic_ostream< _CharT, _Traits > & operator<< (std::basic_ostream< _CharT, _Traits > &__os, const pareto_distribution< _RealType > &__x) — stream pareto_distribution, 80/20 vibes only 🍓
template<typename _RealType , typename _CharT , typename _Traits > std::basic_ostream< _CharT, _Traits > & operator<< (std::basic_ostream< _CharT, _Traits > &__os, const rice_distribution< _RealType > &__x) — stream rice_distribution, grain-of-rice representation 🍚💫
std::ostream & operator<< (std::ostream &os, const annotate_base &__b) — stream an annotate_base to a plain std::ostream, straightforward king 👑
template<typename _Tp1 , typename _Tp2 > bool operator<= (_Tp1 __lhs, const _Pointer_adapter< _Tp2 > &__rhs) — less-than-or-equal where the right side is a _Pointer_adapter, yes 🫶
template<typename _CharT , typename _Traits , typename _Alloc , template< typename, typename, typename > class _Base> bool operator<= (const __versa_string< _CharT, _Traits, _Alloc, _Base > &__lhs, const __versa_string< _CharT, _Traits, _Alloc, _Base > &__rhs) — test if string doesn’t follow string, important distinction bestie 🌟
template<typename _CharT , typename _Traits , typename _Alloc , template< typename, typename, typename > class _Base> bool operator<= (const __versa_string< _CharT, _Traits, _Alloc, _Base > &__lhs, const _CharT *__rhs) — test if string doesn’t follow C string, got it 🎀
template<typename _CharT , typename _Traits , typename _Alloc , template< typename, typename, typename > class _Base> bool operator<= (const _CharT *__lhs, const __versa_string< _CharT, _Traits, _Alloc, _Base > &__rhs) — test if C string doesn’t follow string, periodt 💅
template<typename _Tp > bool operator<= (const _Pointer_adapter< _Tp > &__lhs, const _Pointer_adapter< _Tp > &__rhs) — pointer-adapter vs pointer-adapter, less-or-equal edition ✨
template<typename _Tp1 , typename _Tp2 > bool operator<= (const _Pointer_adapter< _Tp1 > &__lhs, _Tp2 __rhs) — less-or-equal with a _Pointer_adapter on the left, cute 🌸
template<typename _Tp1 , typename _Tp2 > bool operator<= (const _Pointer_adapter< _Tp1 > &__lhs, const _Pointer_adapter< _Tp2 > &__rhs) — two different pointer-adapter types walk into a less-or-equal, no cap 🦋
template<class _CharT , class _Alloc > bool operator<= (const _Rope_const_iterator< _CharT, _Alloc > &__x, const _Rope_const_iterator< _CharT, _Alloc > &__y) — rope-const-iterator less-or-equal, lowkey necessary 💜
template<class _CharT , class _Alloc > bool operator<= (const _Rope_iterator< _CharT, _Alloc > &__x, const _Rope_iterator< _CharT, _Alloc > &__y) — rope-iterator less-or-equal, same 💫
template<class _CharT , class _Alloc > bool operator<= (const rope< _CharT, _Alloc > &__x, const rope< _CharT, _Alloc > &__y) — rope vs rope, less-or-equal, main character comparison 👑
template<class _Tp , class _Alloc > bool operator<= (const slist< _Tp, _Alloc > &_SL1, const slist< _Tp, _Alloc > &_SL2) — slist less-or-equal, fr fr 🧚
template<typename _Iterator , typename _Container > constexpr std::__detail::__synth3way_t< _Iterator > operator<=> (const __normal_iterator< _Iterator, _Container > &__lhs, const __normal_iterator< _Iterator, _Container > &__rhs) noexcept(noexcept(std::__detail::__synth3way(__lhs.base(), __rhs.base()))) — spaceship operator for __normal_iterator, three-way comparison with a noexcept flex, we love to see it 🚀
template<typename _IteratorL , typename _IteratorR , typename _Container > constexpr std::__detail::__synth3way_t< _IteratorR, _IteratorL > operator<=> (const __normal_iterator< _IteratorL, _Container > &__lhs, const __normal_iterator< _IteratorR, _Container > &__rhs) noexcept(noexcept(std::__detail::__synth3way(__lhs.base(), __rhs.base()))) — mixed-iterator spaceship operator, _IteratorL vs _IteratorR, and yes it’s still constexpr 🌈
template<typename _Tp1 , typename _Tp2 > bool operator== (_Tp1 __lhs, const _Pointer_adapter< _Tp2 > &__rhs) — equality check with a _Pointer_adapter on the right, iconic ✨
template<size_t _Dimen, typename _RealType > bool operator== (const __gnu_cxx::normal_mv_distribution< _Dimen, _RealType > &__d1, const __gnu_cxx::normal_mv_distribution< _Dimen, _RealType > &__d2) — do two normal_mv_distributions match? big question, big answer 💖
`template<typename _UIntType , size_t __m, size_t __pos1, size_t __sl1, size_t __sl2, size_t __sr1, size_t __sr2, uint32_t __msk1, uint32_t __msk2, uint32_t __msk3, uint32_t __msk4, uint32_t __parity1, uint32_t __parity2, uint32_t __parity3, uint32_t __parity4> bool operator== (const __gnu_cxx::simd_fast_mersenne_twister_engine< _UIntType, __m, __pos1, __sl1, __sl2, __sr1, __sr2, __msk1, __msk2, __msk3, __msk4, __parity1, __parity2, __parity3, __parity4 > &__lhs,

…and boom, that's the tail end of the previous one — the last chunk of the simd_fast_mersenne_twister_engine signature, finishing on __rhs like it's closing a text:

const __gnu_cxx::simd_fast_mersenne_twister_engine< _UIntType, __m, __pos1, __sl1, __sl2, __sr1, __sr2, __msk1, __msk2, __msk3, __msk4, __parity1, __parity2, __parity3, __parity4 > &__rhs)

💖 `operator==` era, she's the main character 💖

okay so now we're doing equality checks, and there are so many of them. buckle up bestie 🌸

operator== for __mt_alloc — the allocator gets her equality check, both _Tp and _Poolp accounted for:

template<typename _Tp , typename _Poolp > bool operator== (const __mt_alloc< _Tp, _Poolp > &, const __mt_alloc< _Tp, _Poolp > &)

operator== for __normal_iterator, same type on both sides — she's constexpr, she's noexcept, and she's gated by a requires clause that literally checks the == actually converts to bool. iconic:

template<typename _Iterator , typename _Container > requires requires { { __lhs.base() == __rhs.base() } -> std::convertible_to<bool>; }constexpr bool operator== (const __normal_iterator< _Iterator, _Container > &__lhs, const __normal_iterator< _Iterator, _Container > &__rhs) noexcept(noexcept(__lhs.base()==__rhs.base()))"

bestie yes there's a rogue " hanging off the end of those two signatures in the source. she lives there. we don't ask. 💀

operator== for __normal_iterator, two different iterator types — same constraint-energy, _IteratorL vs _IteratorR:

template<typename _IteratorL , typename _IteratorR , typename _Container > requires requires { { __lhs.base() == __rhs.base() } -> std::convertible_to<bool>; }constexpr bool operator== (const __normal_iterator< _IteratorL, _Container > &__lhs, const __normal_iterator< _IteratorR, _Container > &__rhs) noexcept(noexcept(__lhs.base()==__rhs.base()))"

operator== for __pool_alloc — pool allocator equality, no notes:

template<typename _Tp > bool operator== (const __pool_alloc< _Tp > &, const __pool_alloc< _Tp > &)

operator==: __versa_string vs __versa_string — test equivalence of two strings ✨

template<typename _CharT , typename _Traits , typename _Alloc , template< typename, typename, typename > class _Base> bool operator== (const __versa_string< _CharT, _Traits, _Alloc, _Base > &__lhs, const __versa_string< _CharT, _Traits, _Alloc, _Base > &__rhs)

operator==: __versa_string vs C string — test equivalence of string and C string 🎀

template<typename _CharT , typename _Traits , typename _Alloc , template< typename, typename, typename > class _Base> bool operator== (const __versa_string< _CharT, _Traits, _Alloc, _Base > &__lhs, const _CharT *__rhs)

operator==: C string vs __versa_string — test equivalence of C string and string, the flip side, we love a symmetrical queen:

template<typename _CharT , typename _Traits , typename _Alloc , template< typename, typename, typename > class _Base> bool operator== (const _CharT *__lhs, const __versa_string< _CharT, _Traits, _Alloc, _Base > &__rhs)

operator==: _Pointer_adapter vs _Pointer_adapter, same _Tp:

template<typename _Tp > bool operator== (const _Pointer_adapter< _Tp > &__lhs, const _Pointer_adapter< _Tp > &__rhs)

operator==: _Pointer_adapter vs a plain int — yes, an int, that's the vibe:

template<typename _Tp > bool operator== (const _Pointer_adapter< _Tp > &__lhs, int __rhs)

operator==: _Pointer_adapter vs literally any _Tp2:

template<typename _Tp1 , typename _Tp2 > bool operator== (const _Pointer_adapter< _Tp1 > &__lhs, _Tp2 __rhs)

operator==: _Pointer_adapter vs a different _Pointer_adapter — cross-type, cross-_Tp, cross-everything:

template<typename _Tp1 , typename _Tp2 > bool operator== (const _Pointer_adapter< _Tp1 > &__lhs, const _Pointer_adapter< _Tp2 > &__rhs)

operator== for _Rope_char_ptr_proxy — __x vs __y, the classic duo:

template<class _CharT , class _Alloc > bool operator== (const _Rope_char_ptr_proxy< _CharT, _Alloc > &__x, const _Rope_char_ptr_proxy< _CharT, _Alloc > &__y)

operator== for _Rope_const_iterator — same energy, const edition:

template<class _CharT , class _Alloc > bool operator== (const _Rope_const_iterator< _CharT, _Alloc > &__x, const _Rope_const_iterator< _CharT, _Alloc > &__y)

operator== for _Rope_iterator — and the non-const one, she's here too:

template<class _CharT , class _Alloc > bool operator== (const _Rope_iterator< _CharT, _Alloc > &__x, const _Rope_iterator< _CharT, _Alloc > &__y)

operator== for bitmap_allocator — two different _Tps and she's still throwing a throw () on the end like it's 2003 (because it is) 💅

template<typename _Tp1 , typename _Tp2 > bool operator== (const bitmap_allocator< _Tp1 > &, const bitmap_allocator< _Tp2 > &)  throw ()

operator== for character — she takes lhs and rhs, actually named, so polite:

template<typename _Value , typename _Int , typename _St > bool operator== (const character< _Value, _Int, _St > &lhs, const character< _Value, _Int, _St > &rhs)

operator== for hash_map — __hm1 vs __hm2, five template params, zero chill:

template<class _Key , class _Tp , class _HashFn , class _EqlKey , class _Alloc > bool operator== (const hash_map< _Key, _Tp, _HashFn, _EqlKey, _Alloc > &__hm1, const hash_map< _Key, _Tp, _HashFn, _EqlKey, _Alloc > &__hm2)

operator== for hash_multimap — same shape, _HF / _EqKey names this time, don't get it twisted:

template<class _Key , class _Tp , class _HF , class _EqKey , class _Alloc > bool operator== (const hash_multimap< _Key, _Tp, _HF, _EqKey, _Alloc > &__hm1, const hash_multimap< _Key, _Tp, _HF, _EqKey, _Alloc > &__hm2)

operator== for hash_multiset — __hs1 and __hs2:

template<class _Val , class _HashFcn , class _EqualKey , class _Alloc > bool operator== (const hash_multiset< _Val, _HashFcn, _EqualKey, _Alloc > &__hs1, const hash_multiset< _Val, _HashFcn, _EqualKey, _Alloc > &__hs2)

operator== for hash_set — and yes, the first template param here is _Value, not _Val, because consistency is a myth:

template<class _Value , class _HashFcn , class _EqualKey , class _Alloc > bool operator== (const hash_set< _Value, _HashFcn, _EqualKey, _Alloc > &__hs1, const hash_set< _Value, _HashFcn, _EqualKey, _Alloc > &__hs2)

operator== for hashtable — six params deep, __ht1 vs __ht2, the final boss of hashing:

template<class _Val , class _Key , class _HF , class _Ex , class _Eq , class _All > bool operator== (const hashtable< _Val, _Key, _HF, _Ex, _Eq, _All > &__ht1, const hashtable< _Val, _Key, _HF, _Ex, _Eq, _All > &__ht2)

operator== for rope — __left and __right, she's giving directions:

template<class _CharT , class _Alloc > bool operator== (const rope< _CharT, _Alloc > &__left, const rope< _CharT, _Alloc > &__right)

operator== for slist — _SL1 vs _SL2, capital letters and all:

template<class _Tp , class _Alloc > bool operator== (const slist< _Tp, _Alloc > &_SL1, const slist< _Tp, _Alloc > &_SL2)

operator== for throw_allocator_base — anonymous params, she doesn't need names:

template<typename _Tp , typename _Cond > bool operator== (const throw_allocator_base< _Tp, _Cond > &, const throw_allocator_base< _Tp, _Cond > &)

operator== for throw_value_base — __a vs __b, short and sweet:

template<typename _Cond > bool operator== (const throw_value_base< _Cond > &__a, const throw_value_base< _Cond > &__b)

operator== with int on the left — the flip, because apparently we needed both:

template<typename _Tp > bool operator== (int __lhs, const _Pointer_adapter< _Tp > &__rhs)

🔥 `operator>` section, she's comparing 🔥

operator>: anything vs _Pointer_adapter — _Tp1 __lhs by value, no constraints, just vibes:

template<typename _Tp1 , typename _Tp2 > bool operator> (_Tp1 __lhs, const _Pointer_adapter< _Tp2 > &__rhs)

operator>: __versa_string vs __versa_string — test if string follows string 👑

template<typename _CharT , typename _Traits , typename _Alloc , template< typename, typename, typename > class _Base> bool operator> (const __versa_string< _CharT, _Traits, _Alloc, _Base > &__lhs, const __versa_string< _CharT, _Traits, _Alloc, _Base > &__rhs)

operator>: __versa_string vs C string — test if string follows C string ✨

template<typename _CharT , typename _Traits , typename _Alloc , template< typename, typename, typename > class _Base> bool operator> (const __versa_string< _CharT, _Traits, _Alloc, _Base > &__lhs, const _CharT *__rhs)

operator>: C string vs __versa_string — test if C string follows string 🌸

template<typename _CharT , typename _Traits , typename _Alloc , template< typename, typename, typename > class _Base> bool operator> (const _CharT *__lhs, const __versa_string< _CharT, _Traits, _Alloc, _Base > &__rhs)

operator>: _Pointer_adapter vs same _Pointer_adapter:

template<typename _Tp > bool operator> (const _Pointer_adapter< _Tp > &__lhs, const _Pointer_adapter< _Tp > &__rhs)

operator>: _Pointer_adapter vs a raw _Tp2:

template<typename _Tp1 , typename _Tp2 > bool operator> (const _Pointer_adapter< _Tp1 > &__lhs, _Tp2 __rhs)

operator>: _Pointer_adapter vs a different _Pointer_adapter:

template<typename _Tp1 , typename _Tp2 > bool operator> (const _Pointer_adapter< _Tp1 > &__lhs, const _Pointer_adapter< _Tp2 > &__rhs)

operator> for _Rope_const_iterator — __x and __y again, we know the drill:

template<class _CharT , class _Alloc > bool operator> (const _Rope_const_iterator< _CharT, _Alloc > &__x, const _Rope_const_iterator< _CharT, _Alloc > &__y)

operator> for _Rope_iterator:

template<class _CharT , class _Alloc > bool operator> (const _Rope_iterator< _CharT, _Alloc > &__x, const _Rope_iterator< _CharT, _Alloc > &__y)

operator> for rope — she's back and still named __x / __y:

template<class _CharT , class _Alloc > bool operator> (const rope< _CharT, _Alloc > &__x, const rope< _CharT, _Alloc > &__y)

operator> for slist — _SL1 > _SL2, go off:

template<class _Tp , class _Alloc > bool operator> (const slist< _Tp, _Alloc > &_SL1, const slist< _Tp, _Alloc > &_SL2)

🦋 `operator>=` girlies 🦋

operator>=: _Tp1 vs _Pointer_adapter<_Tp2> — same vibe as her sister, different glyph:

template<typename _Tp1 , typename _Tp2 > bool operator>= (_Tp1 __lhs, const _Pointer_adapter< _Tp2 > &__rhs)

operator>=: __versa_string vs __versa_string — test if string doesn't precede string 💜

template<typename _CharT , typename _Traits , typename _Alloc , template< typename, typename, typename > class _Base> bool operator>= (const __versa_string< _CharT, _Traits, _Alloc, _Base > &__lhs, const __versa_string< _CharT, _Traits, _Alloc, _Base > &__rhs)

operator>=: __versa_string vs C string — test if string doesn't precede C string:

template<typename _CharT , typename _Traits , typename _Alloc , template< typename, typename, typename > class _Base> bool operator>= (const __versa_string< _CharT, _Traits, _Alloc, _Base > &__lhs, const _CharT *__rhs)

operator>=: C string vs __versa_string — test if C string doesn't precede string:

template<typename _CharT , typename _Traits , typename _Alloc , template< typename, typename, typename > class _Base> bool operator>= (const _CharT *__lhs, const __versa_string< _CharT, _Traits, _Alloc, _Base > &__rhs)

operator>=: _Pointer_adapter vs same _Pointer_adapter:

template<typename _Tp > bool operator>= (const _Pointer_adapter< _Tp > &__lhs, const _Pointer_adapter< _Tp > &__rhs)

operator>=: _Pointer_adapter vs raw _Tp2:

template<typename _Tp1 , typename _Tp2 > bool operator>= (const _Pointer_adapter< _Tp1 > &__lhs, _Tp2 __rhs)

operator>=: _Pointer_adapter vs another _Pointer_adapter:

template<typename _Tp1 , typename _Tp2 > bool operator>= (const _Pointer_adapter< _Tp1 > &__lhs, const _Pointer_adapter< _Tp2 > &__rhs)

operator>= for _Rope_const_iterator:

template<class _CharT , class _Alloc > bool operator>= (const _Rope_const_iterator< _CharT, _Alloc > &__x, const _Rope_const_iterator< _CharT, _Alloc > &__y)

operator>= for _Rope_iterator:

template<class _CharT , class _Alloc > bool operator>= (const _Rope_iterator< _CharT, _Alloc > &__x, const _Rope_iterator< _CharT, _Alloc > &__y)

operator>= for rope:

template<class _CharT , class _Alloc > bool operator>= (const rope< _CharT, _Alloc > &__x, const rope< _CharT, _Alloc > &__y)

operator>= for slist:

template<class _Tp , class _Alloc > bool operator>= (const slist< _Tp, _Alloc > &_SL1, const slist< _Tp, _Alloc > &_SL2)

🎀 `operator>>` — stream extraction, read her in 🎀

operator>> for beta_distribution — reads into __x from __is:

template<typename _RealType , typename _CharT , typename _Traits > std::basic_istream< _CharT, _Traits > & operator>> (std::basic_istream< _CharT, _Traits > &__is, __gnu_cxx::beta_distribution< _RealType > &__x)

operator>> for hypergeometric_distribution — _UIntType this time, not _RealType, keep up 🫶

template<typename _UIntType , typename _CharT , typename _Traits > std::basic_istream< _CharT, _Traits > & operator>> (std::basic_istream< _CharT, _Traits > &__is, __gnu_cxx::hypergeometric_distribution< _UIntType > &__x)

operator>> for normal_mv_distribution — note the _Dimen param is plain size_t here:

template<size_t _Dimen, typename _RealType , typename _CharT , typename _Traits > std::basic_istream< _CharT, _Traits > & operator>> (std::basic_istream< _CharT, _Traits > &__is, __gnu_cxx::normal_mv_distribution< _Dimen, _RealType > &__x)

operator>> for simd_fast_mersenne_twister_engine — the long one, all fifteen engine params spelled out, uint32_t masks and parities included:

template<typename _UIntType , size_t __m, size_t __pos1, size_t __sl1, size_t __sl2, size_t __sr1, size_t __sr2, uint32_t __msk1, uint32_t __msk2, uint32_t __msk3, uint32_t __msk4, uint32_t __parity1, uint32_t __parity2, uint32_t __parity3, uint32_t __parity4, typename _CharT , typename _Traits > std::basic_istream< _CharT, _Traits > & operator>> (std::basic_istream< _CharT, _Traits > &__is, __gnu_cxx::simd_fast_mersenne_twister_engine< _UIntType, __m, __pos1, __sl1, __sl2, __sr1, __sr2, __msk1, __msk2, __msk3, __msk4, __parity1, __parity2, __parity3, __parity4 > &__x)

operator>> for triangular_distribution — clean, _RealType, done:

template<typename _RealType , typename _CharT , typename _Traits > std::basic_istream< _CharT, _Traits > & operator>> (std::basic_istream< _CharT, _Traits > &__is, __gnu_cxx::triangular_distribution< _RealType > &__x)

one more operator>>, and she's mid-sentence 😭 — std::size_t _Dimen this time, and the signature just… stops after __is,. she gets finished in a sec, hold on:

template<std::size_t _Dimen, typename _RealType , typename _CharT , typename _Traits > std::basic_istream< _CharT, _Traits > & operator>> (std::basic_istream< _CharT, _Traits > &__is,

okay bestie we are STILL deep in the function-declaration pile and it is giving ✨infinite overload energy✨. Picking up mid-signature, no cap:

           __gnu_cxx::uniform_inside_sphere_distribution< _Dimen, _RealType >
           &__x)
       template<std::size_t _Dimen, typename _RealType , typename _CharT ,
           typename _Traits > std::basic_istream< _CharT, _Traits > &
           operator>> (std::basic_istream< _CharT, _Traits > &__is,
           __gnu_cxx::uniform_on_sphere_distribution< _Dimen, _RealType > &__x)
       template<typename _RealType , typename _CharT , typename _Traits >
           std::basic_istream< _CharT, _Traits > & operator>>
           (std::basic_istream< _CharT, _Traits > &__is,
           __gnu_cxx::von_mises_distribution< _RealType > &__x)
       template<typename _RealType , typename _CharT , typename _Traits >
           std::basic_istream< _CharT, _Traits > & operator>>
           (std::basic_istream< _CharT, _Traits > &__is, arcsine_distribution<
           _RealType > &__x)
       template<typename _RealType , typename _CharT , typename _Traits >
           std::basic_istream< _CharT, _Traits > & operator>>
           (std::basic_istream< _CharT, _Traits > &__is, hoyt_distribution<
           _RealType > &__x)
       template<typename _RealType , typename _CharT , typename _Traits >
           std::basic_istream< _CharT, _Traits > & operator>>
           (std::basic_istream< _CharT, _Traits > &__is, k_distribution<
           _RealType > &__x)
       template<typename _RealType , typename _CharT , typename _Traits >
           std::basic_istream< _CharT, _Traits > & operator>>
           (std::basic_istream< _CharT, _Traits > &__is, logistic_distribution<
           _RealType > &__x)
       template<typename _RealType , typename _CharT , typename _Traits >
           std::basic_istream< _CharT, _Traits > & operator>>
           (std::basic_istream< _CharT, _Traits > &__is, nakagami_distribution<
           _RealType > &__x)
       template<typename _RealType , typename _CharT , typename _Traits >
           std::basic_istream< _CharT, _Traits > & operator>>
           (std::basic_istream< _CharT, _Traits > &__is, pareto_distribution<
           _RealType > &__x)
       template<typename _RealType , typename _CharT , typename _Traits >
           std::basic_istream< _CharT, _Traits > & operator>>
           (std::basic_istream< _CharT, _Traits > &__is, rice_distribution<
           _RealType > &__x)

That’s the stream-extraction crew for the sphere / von Mises / arcsine / hoyt / k / logistic / nakagami / pareto / rice distributions. Slay. 🫶

Next up, the power + random + rotate section:

       template<typename _Tp , typename _Integer > _Tp power (_Tp __x, _Integer
           __n)
       template<typename _Tp , typename _Integer , typename _MonoidOperation >
           _Tp power (_Tp __x, _Integer __n, _MonoidOperation __monoid_op)
       template<typename _InputIterator , typename _RandomAccessIterator >
           _RandomAccessIterator random_sample (_InputIterator __first,
           _InputIterator __last, _RandomAccessIterator __out_first,
           _RandomAccessIterator __out_last)
       template<typename _InputIterator , typename _RandomAccessIterator ,
           typename _RandomNumberGenerator > _RandomAccessIterator
           random_sample (_InputIterator __first, _InputIterator __last,
           _RandomAccessIterator __out_first, _RandomAccessIterator __out_last,
           _RandomNumberGenerator &__rand)
       template<typename _ForwardIterator , typename _OutputIterator , typename
           _Distance > _OutputIterator random_sample_n (_ForwardIterator
           __first, _ForwardIterator __last, _OutputIterator __out, const
           _Distance __n)
       template<typename _ForwardIterator , typename _OutputIterator , typename
           _Distance , typename _RandomNumberGenerator > _OutputIterator
           random_sample_n (_ForwardIterator __first, _ForwardIterator __last,
           _OutputIterator __out, const _Distance __n, _RandomNumberGenerator
           &__rand)
       void rotate (_Rope_iterator< char, __STL_DEFAULT_ALLOCATOR(char)>
           __first, _Rope_iterator< char, __STL_DEFAULT_ALLOCATOR(char)>
           __middle, _Rope_iterator< char, __STL_DEFAULT_ALLOCATOR(char)>
           __last)

power, random_sample, random_sample_n, rotate — we see you and we are obsessed. 💅

And now the swap overloads, which are lowkey the main characters of this chunk:

       template<typename _CharT , typename _Traits , typename _Alloc ,
           template< typename, typename, typename > class _Base> void swap
           (__versa_string< _CharT, _Traits, _Alloc, _Base > &__lhs,
           __versa_string< _CharT, _Traits, _Alloc, _Base > &__rhs)
           Swap contents of two strings.
       template<typename _Tp > void swap (_ExtPtr_allocator< _Tp > &__larg,
           _ExtPtr_allocator< _Tp > &__rarg)
       template<class _CharT , class __Alloc > void swap (_Rope_char_ref_proxy<
           _CharT, __Alloc > __a, _Rope_char_ref_proxy< _CharT, __Alloc > __b)
       template<class _Key , class _Tp , class _HashFn , class _EqlKey , class
           _Alloc > void swap (hash_map< _Key, _Tp, _HashFn, _EqlKey, _Alloc >
           &__hm1, hash_map< _Key, _Tp, _HashFn, _EqlKey, _Alloc > &__hm2)
       template<class _Key , class _Tp , class _HashFn , class _EqlKey , class
           _Alloc > void swap (hash_multimap< _Key, _Tp, _HashFn, _EqlKey,
           _Alloc > &__hm1, hash_multimap< _Key, _Tp, _HashFn, _EqlKey, _Alloc
           > &__hm2)
       template<class _Val , class _HashFcn , class _EqualKey , class _Alloc >
           void swap (hash_multiset< _Val, _HashFcn, _EqualKey, _Alloc >
           &__hs1, hash_multiset< _Val, _HashFcn, _EqualKey, _Alloc > &__hs2)
       template<class _Val , class _HashFcn , class _EqualKey , class _Alloc >
           void swap (hash_set< _Val, _HashFcn, _EqualKey, _Alloc > &__hs1,
           hash_set< _Val, _HashFcn, _EqualKey, _Alloc > &__hs2)
       template<class _Val , class _Key , class _HF , class _Extract , class
           _EqKey , class _All > void swap (hashtable< _Val, _Key, _HF,
           _Extract, _EqKey, _All > &__ht1, hashtable< _Val, _Key, _HF,
           _Extract, _EqKey, _All > &__ht2)
       template<class _CharT , class _Alloc > void swap (rope< _CharT, _Alloc >
           &__x, rope< _CharT, _Alloc > &__y)
       template<class _Tp , class _Alloc > void swap (slist< _Tp, _Alloc >
           &__x, slist< _Tp, _Alloc > &__y)
       template<typename _Cond > void swap (throw_value_base< _Cond > &__a,
           throw_value_base< _Cond > &__b)
       template<typename _InputIter , typename _Size , typename _ForwardIter >
           std::pair< _InputIter, _ForwardIter > uninitialized_copy_n
           (_InputIter __first, _Size __count, _ForwardIter __result)
           Copies the range [first,last) into result.

Not me reading every single swap overload like it’s a group chat recap 😭 but bestie, they’re all here. Including uninitialized_copy_n, which “Copies the range [first,last) into result.” Fr fr.

🧸 Variables

the lock policy variable:

const _Lock_policy __default_lock_policy

the identity element for ropes:

template<class _CharT , class _Alloc > rope< _CharT, _Alloc >
    identity_element (_Rope_Concat_fn< _CharT, _Alloc >)

🌈 Detailed Description

GNU extensions for public use. Periodt. 💖

🎀 Typedef Documentation

template<typename _Tp > using __gnu_cxx::__int_traits = typedef
    __numeric_traits_integer<_Tp>

Convenience alias for __numeric_traits<integer-type>. Cute, short, iconic. ✨

💅 Function Documentation

💫 `__static_pointer_cast` — standard pointer edition

template<typename _ToType , typename _FromType > _ToType
    __gnu_cxx::__static_pointer_cast (_FromType * __arg) [inline]

Casting operations for cases where _FromType is a standard pointer. _ToType can be a standard or non-standard pointer.

💫 `__static_pointer_cast` — not-a-standard-pointer edition

template<typename _ToType , typename _FromType > _ToType
    __gnu_cxx::__static_pointer_cast (const _FromType & __arg) [inline]

Casting operations for cases where _FromType is not a standard pointer. _ToType can be a standard or non-standard pointer. Given that _FromType is not a pointer, it must have a get() method that returns the standard pointer equivalent of the address it points to, and must have an element_type typedef which names the type it points to.

bestie this one has requirements — don’t skip the get() and element_type part, iykyk.

💫 `_Bit_scan_forward`

std::size_t __gnu_cxx::_Bit_scan_forward (std::size_t __num) [inline]

Generic Version of the bsf instruction.

Referenced by __gnu_cxx::bitmap_allocator< _Tp >::_M_allocate_single_object().

💫 `operator!=` — string vs. string

template<typename _CharT , typename _Traits , typename _Alloc , template<
    typename, typename, typename > class _Base> bool __gnu_cxx::operator!=
    (const __versa_string< _CharT, _Traits, _Alloc, _Base > & __lhs, const
    __versa_string< _CharT, _Traits, _Alloc, _Base > & __rhs) [inline]

Test difference of two strings.

Parameters

__lhs — First string.
__rhs — Second string.

Returns True if __lhs.compare(__rhs) != 0. False otherwise.

💫 `operator!=` — string vs. C string

template<typename _CharT , typename _Traits , typename _Alloc , template<
    typename, typename, typename > class _Base> bool __gnu_cxx::operator!=
    (const __versa_string< _CharT, _Traits, _Alloc, _Base > & __lhs, const
    _CharT * __rhs) [inline]

Test difference of string and C string.

Parameters

__lhs — String.
__rhs — C string.

Returns True if __lhs.compare(__rhs) != 0. False otherwise.

💫 `operator!=` — C string vs. string

template<typename _CharT , typename _Traits , typename _Alloc , template<
    typename, typename, typename > class _Base> bool __gnu_cxx::operator!=
    (const _CharT * __lhs, const __versa_string< _CharT, _Traits, _Alloc,
    _Base > & __rhs) [inline]

Test difference of C string and string.

Parameters

__lhs — C string.
__rhs — String.

Returns True if __rhs.compare(__lhs) != 0. False otherwise.

💫 `operator+` — character + string

template<typename _CharT , typename _Traits , typename _Alloc , template<
    typename, typename, typename > class _Base> __versa_string< _CharT,
    _Traits, _Alloc, _Base > __gnu_cxx::operator+ (_CharT __lhs, const
    __versa_string< _CharT, _Traits, _Alloc, _Base > & __rhs)

Concatenate character and string.

Parameters

__lhs — First string.
__rhs — Last string.

Returns New string with __lhs followed by __rhs.

References __gnu_cxx::__versa_string< _CharT, _Traits, _Alloc, _Base >::append(), __gnu_cxx::__versa_string< _CharT, _Traits, _Alloc, _Base >::push_back(), __gnu_cxx::__versa_string< _CharT, _Traits, _Alloc, _Base >::reserve(), and __gnu_cxx::__versa_string< _CharT, _Traits, _Alloc, _Base >::size().

💫 `operator+` — string + character

template<typename _CharT , typename _Traits , typename _Alloc , template<
    typename, typename, typename > class _Base> __versa_string< _CharT,
    _Traits, _Alloc, _Base > __gnu_cxx::operator+ (const __versa_string<
    _CharT, _Traits, _Alloc, _Base > & __lhs, _CharT __rhs)

Concatenate string and character.

Parameters

__lhs — First string.
__rhs — Last string.

Returns New string with __lhs followed by __rhs.

💫 `operator+` — string + string

template<typename _CharT , typename _Traits , typename _Alloc , template<
    typename, typename, typename > class _Base> __versa_string< _CharT,
    _Traits, _Alloc, _Base > __gnu_cxx::operator+ (const __versa_string<
    _CharT, _Traits, _Alloc, _Base > & __lhs, const __versa_string< _CharT,
    _Traits, _Alloc, _Base > & __rhs)

Concatenate two strings.

Parameters

__lhs — First string.
__rhs — Last string.

Returns New string with value of __lhs followed by __rhs.

References __gnu_cxx::__versa_string< _CharT, _Traits, _Alloc, _Base >::append(), __gnu_cxx::__versa_string< _CharT, _Traits, _Alloc, _Base >::reserve(), and __gnu_cxx::__versa_string< _CharT, _Traits, _Alloc, _Base >::size().

okay, final stretch of the function docs — operators and swap, let’s get into it 🫶

💖 `operator+` — string + C string

template<typename _CharT , typename _Traits , typename _Alloc , template< typename, typename, typename > class _Base> __versa_string< _CharT, _Traits, _Alloc, _Base > __gnu_cxx::operator+ (const __versa_string< _CharT, _Traits, _Alloc, _Base > & __lhs, const _CharT * __rhs)

Concatenate string and C string — that’s the whole cute little job 💅

Parameters
- __lhs — First string.
- __rhs — Last string.
Returns — New string with __lhs followed by __rhs.
References — __gnu_cxx::__versa_string< _CharT, _Traits, _Alloc, _Base >::size().

🦋 `operator+` — C string + string

template<typename _CharT , typename _Traits , typename _Alloc , template< typename, typename, typename > class _Base> __versa_string< _CharT, _Traits, _Alloc, _Base > __gnu_cxx::operator+ (const _CharT * __lhs, const __versa_string< _CharT, _Traits, _Alloc, _Base > & __rhs)

Concatenate C string and string — yes bestie, this is the flipped version and it still slays ✨

Parameters
- __lhs — First string.
- __rhs — Last string.
Returns — New string with value of __lhs followed by __rhs.
References — __gnu_cxx::__versa_string< _CharT, _Traits, _Alloc, _Base >::size().

🌸 `operator<` — string vs string

template<typename _CharT , typename _Traits , typename _Alloc , template< typename, typename, typename > class _Base> bool __gnu_cxx::operator< (const __versa_string< _CharT, _Traits, _Alloc, _Base > & __lhs, const __versa_string< _CharT, _Traits, _Alloc, _Base > & __rhs) [inline]

Test if string precedes string — the classic “who comes first” vibe check 🎀

Parameters
- __lhs — First string.
- __rhs — Second string.
Returns — true if __lhs precedes __rhs. false otherwise.
References — __gnu_cxx::__versa_string< _CharT, _Traits, _Alloc, _Base >::compare().

🌈 `operator<` — string vs C string

template<typename _CharT , typename _Traits , typename _Alloc , template< typename, typename, typename > class _Base> bool __gnu_cxx::operator< (const __versa_string< _CharT, _Traits, _Alloc, _Base > & __lhs, const _CharT * __rhs) [inline]

Test if string precedes C string — same energy, one side is just a C string this time 💫

Parameters
- __lhs — String.
- __rhs — C string.
Returns — true if __lhs precedes __rhs. false otherwise.
References — __gnu_cxx::__versa_string< _CharT, _Traits, _Alloc, _Base >::compare().

🧚 `operator<` — C string vs string

template<typename _CharT , typename _Traits , typename _Alloc , template< typename, typename, typename > class _Base> bool __gnu_cxx::operator< (const _CharT * __lhs, const __versa_string< _CharT, _Traits, _Alloc, _Base > & __rhs) [inline]

Test if C string precedes string — the C string is on the left this time, no cap 🔥

Parameters
- __lhs — C string.
- __rhs — String.
Returns — true if __lhs precedes __rhs. false otherwise.
References — __gnu_cxx::__versa_string< _CharT, _Traits, _Alloc, _Base >::compare().

💜 `operator<=` — string vs string

template<typename _CharT , typename _Traits , typename _Alloc , template< typename, typename, typename > class _Base> bool __gnu_cxx::operator<= (const __versa_string< _CharT, _Traits, _Alloc, _Base > & __lhs, const __versa_string< _CharT, _Traits, _Alloc, _Base > & __rhs) [inline]

Test if string doesn’t follow string — it’s the “less than or equal” bestie, serving <= realness 😌

Parameters
- __lhs — First string.
- __rhs — Second string.
Returns — true if __lhs doesn’t follow __rhs. false otherwise.
References — __gnu_cxx::__versa_string< _CharT, _Traits, _Alloc, _Base >::compare().

💀 `operator<=` — string vs C string

template<typename _CharT , typename _Traits , typename _Alloc , template< typename, typename, typename > class _Base> bool __gnu_cxx::operator<= (const __versa_string< _CharT, _Traits, _Alloc, _Base > & __lhs, const _CharT * __rhs) [inline]

Test if string doesn’t follow C string — keeping the <= agenda alive and iconic ⭐

Parameters
- __lhs — String.
- __rhs — C string.
Returns — true if __lhs doesn’t follow __rhs. false otherwise.
References — __gnu_cxx::__versa_string< _CharT, _Traits, _Alloc, _Base >::compare().

🍓 `operator<=` — C string vs string

template<typename _CharT , typename _Traits , typename _Alloc , template< typename, typename, typename > class _Base> bool __gnu_cxx::operator<= (const _CharT * __lhs, const __versa_string< _CharT, _Traits, _Alloc, _Base > & __rhs) [inline]

Test if C string doesn’t follow string — yes, the C string is main character on the left now 🍓

Parameters
- __lhs — C string.
- __rhs — String.
Returns — true if __lhs doesn’t follow __rhs. false otherwise.
References — __gnu_cxx::__versa_string< _CharT, _Traits, _Alloc, _Base >::compare().

👑 `operator==` — string vs string

template<typename _CharT , typename _Traits , typename _Alloc , template< typename, typename, typename > class _Base> bool __gnu_cxx::operator== (const __versa_string< _CharT, _Traits, _Alloc, _Base > & __lhs, const __versa_string< _CharT, _Traits, _Alloc, _Base > & __rhs) [inline]

Test equivalence of two strings — are they literally the same? Let’s find out 💅

Parameters
- __lhs — First string.
- __rhs — Second string.
Returns — true if __lhs.compare(__rhs) == 0. false otherwise.
References — __gnu_cxx::__versa_string< _CharT, _Traits, _Alloc, _Base >::data(), and __gnu_cxx::__versa_string< _CharT, _Traits, _Alloc, _Base >::size().

✨ `operator==` — string vs C string

template<typename _CharT , typename _Traits , typename _Alloc , template< typename, typename, typename > class _Base> bool __gnu_cxx::operator== (const __versa_string< _CharT, _Traits, _Alloc, _Base > & __lhs, const _CharT * __rhs) [inline]

Test equivalence of string and C string — matching vibes only, bestie 💖

Parameters
- __lhs — String.
- __rhs — C string.
Returns — true if __lhs.compare(__rhs) == 0. false otherwise.
References — __gnu_cxx::__versa_string< _CharT, _Traits, _Alloc, _Base >::data(), and __gnu_cxx::__versa_string< _CharT, _Traits, _Alloc, _Base >::size().

🫶 `operator==` — C string vs string

template<typename _CharT , typename _Traits , typename _Alloc , template< typename, typename, typename > class _Base> bool __gnu_cxx::operator== (const _CharT * __lhs, const __versa_string< _CharT, _Traits, _Alloc, _Base > & __rhs) [inline]

Test equivalence of C string and string — same check, flipped order, still valid 🫶

Parameters
- __lhs — C string.
- __rhs — String.
Returns — true if __rhs.compare(__lhs) == 0. false otherwise.

🌟 `operator==` — `_Pointer_adapter`

template<typename _Tp > bool __gnu_cxx::operator== (const _Pointer_adapter< _Tp > & __lhs, const _Pointer_adapter< _Tp > & __rhs) [inline]

Comparison operators for _Pointer_adapter defer to the base class’ comparison operators, when possible. So it’s giving “let the base class handle it” energy 💫

🎀 `operator>` — string vs string

template<typename _CharT , typename _Traits , typename _Alloc , template< typename, typename, typename > class _Base> bool __gnu_cxx::operator> (const __versa_string< _CharT, _Traits, _Alloc, _Base > & __lhs, const __versa_string< _CharT, _Traits, _Alloc, _Base > & __rhs) [inline]

Test if string follows string — yes, we’re doing the greater-than check now, periodt 💅

Parameters
- __lhs — First string.
- __rhs — Second string.
Returns — true if __lhs follows __rhs. false otherwise.
References — __gnu_cxx::__versa_string< _CharT, _Traits, _Alloc, _Base >::compare().

🔥 `operator>` — string vs C string

template<typename _CharT , typename _Traits , typename _Alloc , template< typename, typename, typename > class _Base> bool __gnu_cxx::operator> (const __versa_string< _CharT, _Traits, _Alloc, _Base > & __lhs, const _CharT * __rhs) [inline]

Test if string follows C string — C string is in the passenger seat this time 🚗

Parameters
- __lhs — String.
- __rhs — C string.
Returns — true if __lhs follows __rhs. false otherwise.
References — __gnu_cxx::__versa_string< _CharT, _Traits, _Alloc, _Base >::compare().

💫 `operator>` — C string vs string

template<typename _CharT , typename _Traits , typename _Alloc , template< typename, typename, typename > class _Base> bool __gnu_cxx::operator> (const _CharT * __lhs, const __versa_string< _CharT, _Traits, _Alloc, _Base > & __rhs) [inline]

Test if C string follows string — the C string said “I’ll go first” and honestly? iconic 🌟

Parameters
- __lhs — C string.
- __rhs — String.
Returns — true if __lhs follows __rhs. false otherwise.
References — __gnu_cxx::__versa_string< _CharT, _Traits, _Alloc, _Base >::compare().

🌸 `operator>=` — string vs string

template<typename _CharT , typename _Traits , typename _Alloc , template< typename, typename, typename > class _Base> bool __gnu_cxx::operator>= (const __versa_string< _CharT, _Traits, _Alloc, _Base > & __lhs, const __versa_string< _CharT, _Traits, _Alloc, _Base > & __rhs) [inline]

Test if string doesn’t precede string — greater-than-or-equal, but make it cute 💖

Parameters
- __lhs — First string.
- __rhs — Second string.
Returns — true if __lhs doesn’t precede __rhs. false otherwise.
References — __gnu_cxx::__versa_string< _CharT, _Traits, _Alloc, _Base >::compare().

🧚 `operator>=` — string vs C string

template<typename _CharT , typename _Traits , typename _Alloc , template< typename, typename, typename > class _Base> bool __gnu_cxx::operator>= (const __versa_string< _CharT, _Traits, _Alloc, _Base > & __lhs, const _CharT * __rhs) [inline]

Test if string doesn’t precede C string — the >= saga continues, and we’re seated 🍿

Parameters
- __lhs — String.
- __rhs — C string.
Returns — true if __lhs doesn’t precede __rhs. false otherwise.
References — __gnu_cxx::__versa_string< _CharT, _Traits, _Alloc, _Base >::compare().

🦋 `operator>=` — C string vs string

template<typename _CharT , typename _Traits , typename _Alloc , template< typename, typename, typename > class _Base> bool __gnu_cxx::operator>= (const _CharT * __lhs, const __versa_string< _CharT, _Traits, _Alloc, _Base > & __rhs) [inline]

Test if C string doesn’t precede string — final >= flavor, and yes, it ate 💅

Parameters
- __lhs — C string.
- __rhs — String.
Returns — true if __lhs doesn’t precede __rhs. false otherwise.
References — __gnu_cxx::__versa_string< _CharT, _Traits, _Alloc, _Base >::compare().

🎀 `swap` — swap two strings

template<typename _CharT , typename _Traits , typename _Alloc , template< typename, typename, typename > class _Base> void __gnu_cxx::swap (__versa_string< _CharT, _Traits, _Alloc, _Base > & __lhs, __versa_string< _CharT, _Traits, _Alloc, _Base > & __rhs) [inline]

Swap contents of two strings — trading places, bestie 🔄

Parameters
- __lhs — First string.
- __rhs — Second string.

Exchanges the contents of __lhs and __rhs in constant time. Constant time!! We love efficiency 👑

References — __gnu_cxx::__versa_string< _CharT, _Traits, _Alloc, _Base >::swap().

👑 Author

Generated automatically by Doxygen for libstdc++ from the source code.

and that’s the whole page, bestie 🎀 source/version tea: this is libstdc++, and the page is stamped __gnu_cxx(3cxx). The footer doesn’t print a date, so we’re not inventing one — periodt 💅✨

📦 where this page comes from

ubuntu noble: libstdc++-14-doc 14-20240412-0ubuntu1
💖 girlified by deepseek-ai/DeepSeek-V4.1-Flash-1017 on 2026-11-06: a language model's rewrite of the original, under its terms

__gnu_cxx(3cxx)

🦋 __gnu_cxx (3cxx) 🦋

🌸 NAME 🌸

🎀 SYNOPSIS 🎀

🧚 Namespaces 🧚

🧸 Classes 🧸

🧵 Typedefs 🧵

🔮 Enumerations 🔮

ok now the operator!= era 👑 (there are SO many, buckle up)

arithmetic operators, we're in our math era 🔥

rope + iterator arithmetic, aka the pointer math chapter 🧚

operator+= and operator- (yes they're different, bestie) 🍓

💖 operator== era, she's the main character 💖

🔥 operator> section, she's comparing 🔥

🦋 operator>= girlies 🦋

🎀 operator>> — stream extraction, read her in 🎀

🧸 Variables

🌈 Detailed Description

🎀 Typedef Documentation

💅 Function Documentation

💫 __static_pointer_cast — standard pointer edition

💫 __static_pointer_cast — not-a-standard-pointer edition

💫 _Bit_scan_forward

💫 operator!= — string vs. string

💫 operator!= — string vs. C string

💫 operator!= — C string vs. string

💫 operator+ — character + string

💫 operator+ — string + character

💫 operator+ — string + string

💖 operator+ — string + C string

🦋 operator+ — C string + string

🌸 operator< — string vs string

🌈 operator< — string vs C string

🧚 operator< — C string vs string

💜 operator<= — string vs string

💀 operator<= — string vs C string

🍓 operator<= — C string vs string

👑 operator== — string vs string

✨ operator== — string vs C string

🫶 operator== — C string vs string

🌟 operator== — _Pointer_adapter

🎀 operator> — string vs string

🔥 operator> — string vs C string

💫 operator> — C string vs string

🌸 operator>= — string vs string

🧚 operator>= — string vs C string

🦋 operator>= — C string vs string

🎀 swap — swap two strings

👑 Author

ok now the `operator!=` era 👑 (there are SO many, buckle up)

`operator+=` and `operator-` (yes they're different, bestie) 🍓

💖 `operator==` era, she's the main character 💖

🔥 `operator>` section, she's comparing 🔥

🦋 `operator>=` girlies 🦋

🎀 `operator>>` — stream extraction, read her in 🎀

💫 `__static_pointer_cast` — standard pointer edition

💫 `__static_pointer_cast` — not-a-standard-pointer edition

💫 `_Bit_scan_forward`

💫 `operator!=` — string vs. string

💫 `operator!=` — string vs. C string

💫 `operator!=` — C string vs. string

💫 `operator+` — character + string

💫 `operator+` — string + character

💫 `operator+` — string + string

💖 `operator+` — string + C string

🦋 `operator+` — C string + string

🌸 `operator<` — string vs string

🌈 `operator<` — string vs C string

🧚 `operator<` — C string vs string

💜 `operator<=` — string vs string

💀 `operator<=` — string vs C string

🍓 `operator<=` — C string vs string

👑 `operator==` — string vs string

✨ `operator==` — string vs C string

🫶 `operator==` — C string vs string

🌟 `operator==` — `_Pointer_adapter`

🎀 `operator>` — string vs string

🔥 `operator>` — string vs C string

💫 `operator>` — C string vs string

🌸 `operator>=` — string vs string

🧚 `operator>=` — string vs C string

🦋 `operator>=` — C string vs string

🎀 `swap` — swap two strings