| NStormByte | Root namespace of the StormByte suite |
| NError | Error-code domains and the StormByte::Error::Fault value type |
| RDescribed | Enum that has a StormByte::Error::Domain specialization |
| NSafe | Owned values that cross a DLL without the caller's CRT |
| NDetail | Private helpers |
| RSafeCallbackArgument | Callback arguments admitted across a DLL boundary |
| RSafeOptionalResult | Recognizes a monadic result that can report an empty state |
| RValidSmartPointer | true when SmartPointer is StormByte::Safe::Shared<T> or StormByte::Safe::Unique<T> |
| RReplaceTokenBuiltin | True when FormatReplaceToken always writes T and never asks for a string conversion |
| NType | Named concepts and small type utilities used across the suite |
| RReference | Lvalue or rvalue reference type |
| RLvalueReference | Lvalue reference type (std::is_lvalue_reference) |
| RRvalueReference | Rvalue reference type (std::is_rvalue_reference) |
| RPointer | Raw (possibly cv-qualified) pointer type |
| RSmartPointer | Smart pointer-like type: dereferenceable and exposes get() |
| RNullablePointer | Smart pointer-like type that can test whether it contains an object |
| RIntegral | Integral type (bool, char, int, long, …), including cv |
| RFloatingPoint | Floating-point type (float, double, long double) |
| RArithmetic | Integral or floating-point type |
| RSigned | Signed arithmetic type (std::is_signed) |
| RUnsigned | Unsigned arithmetic type (std::is_unsigned) |
| RNumeral | Host integer or suite count type |
| RConst | Top-level const qualifier (std::is_const_v) |
| RClass | Class or struct type (not union, not enum) |
| REqualityComparable | Type whose == and != both yield something convertible to bool |
| RThreeWayComparable | Type whose <=> operator is well-formed |
| RHashable | Type with a valid std::hash specialization |
| RString | Text string types that are not generic containers |
| RArray | std::array<U, N> after stripping cv/ref |
| RContainer | Has begin(), end() and value_type, and is not a StormByte::Type::String |
| RHasKeyType | StormByte::Type::Container that publishes a nested key_type |
| RHasMappedType | StormByte::Type::Container that publishes a nested mapped_type |
| RSized | StormByte::Type::Container that publishes size() |
| RHasPushBack | StormByte::Type::Container that accepts push_back of a value_type |
| RHasPushFront | StormByte::Type::Container that accepts push_front of a value_type |
| RHasInsert | Associative StormByte::Type::Container that accepts insert of a value_type |
| RHasSubscript | StormByte::Type::Container that supports operator[] with key/index U |
| RConvertibleTo | From is implicitly convertible to To (std::is_convertible) |
| RExplicitlyConvertibleTo | From may be explicitly converted to To with static_cast |
| REnum | Unscoped or scoped enumeration (enum / enum class) |
| RUnsignedEnum | StormByte::Type::Enum whose underlying type is unsigned |
| RScopedEnum | Scoped enumeration (enum class / enum struct) |
| RTriviallyCopyable | Type that may be copied with memcpy / as-if memcpy |
| RTriviallyDestructible | Type with a trivial destructor |
| RDefaultConstructible | Type constructible from an empty initializer (T{} / T()) |
| RTriviallyDefaultConstructible | StormByte::Type::DefaultConstructible with a trivial default constructor |
| RCopyConstructible | Type that can actually be copy-constructed |
| RTriviallyCopyConstructible | StormByte::Type::CopyConstructible with a trivial copy constructor |
| RMoveConstructible | Type that can be move-constructed |
| RTriviallyMoveConstructible | StormByte::Type::MoveConstructible with a trivial move constructor |
| RCopyAssignable | Type that can actually be copy-assigned |
| RTriviallyCopyAssignable | StormByte::Type::CopyAssignable with a trivial copy-assignment operator |
| RMoveAssignable | Type that can be move-assigned (operator=(T&&)) |
| RTriviallyMoveAssignable | StormByte::Type::MoveAssignable with a trivial move-assignment operator |
| RCopyable | Both StormByte::Type::CopyConstructible and StormByte::Type::CopyAssignable |
| RMovable | Both StormByte::Type::MoveConstructible and StormByte::Type::MoveAssignable |
| RSwappable | Type that can be swapped with std::swap (std::is_swappable) |
| RDestructible | Type that can be destroyed |
| RConstructibleFrom | Type constructible from Args (std::constructible_from) |
| RAssignableFrom | T can be assigned from U (std::assignable_from) |
| RTotallyOrdered | Type with equality and a total order |
| RSemiregular | Default-constructible, copyable and movable |
| RRegular | StormByte::Type::Semiregular and equality-comparable |
| RRange | Valid range (std::ranges::range) |
| RInputRange | Input range (std::ranges::input_range) |
| ROutputRange | Output range for values of type T (std::ranges::output_range) |
| RForwardRange | Forward range (std::ranges::forward_range) |
| RBidirectionalRange | Bidirectional range (std::ranges::bidirectional_range) |
| RRandomAccessRange | Random-access range (std::ranges::random_access_range) |
| RContiguousRange | Contiguous range (std::ranges::contiguous_range) |
| RSizedRange | Sized range (std::ranges::sized_range) |
| RCommonRange | Common range (std::ranges::common_range) |
| RView | Range view (std::ranges::view) |
| RBorrowedRange | Borrowed range (std::ranges::borrowed_range) |
| RInputIterator | Input iterator (std::input_iterator) |
| ROutputIterator | Output iterator for values of type T (std::output_iterator) |
| RForwardIterator | Forward iterator (std::forward_iterator) |
| RBidirectionalIterator | Bidirectional iterator (std::bidirectional_iterator) |
| RRandomAccessIterator | Random-access iterator (std::random_access_iterator) |
| RContiguousIterator | Contiguous iterator (std::contiguous_iterator) |
| RSentinelFor | Valid sentinel for an iterator (std::sentinel_for) |
| RSizedSentinelFor | Sized sentinel for an iterator (std::sized_sentinel_for) |
| RByteInputRange | Input range whose scalar values can be explicitly converted to std::byte |
| RByteInputIterator | Input iterator whose scalar values can be explicitly converted to std::byte |
| RCallable | Invocable with argument types Args (std::is_invocable) |
| RInvocable | Regularly invocable with argument types Args (std::invocable) |
| RInvocableR | Invocable with argument types Args and a result convertible to R (std::is_invocable_r) |
| RPredicate | Predicate over argument types Args (std::predicate) |
| RSameAs | Same type after stripping cv and references from both sides |
| RDerivedFrom | Derived derives from Base (std::is_base_of) |
| RMaybeSafe | Recognizes a conditional Safe component after stripping cv and references |
| RSafeComponent | Recognized Safe component after stripping cv and references |
| RSafeCursor | Recognizes a cursor that stores only a Base node pointer |
| RSafeValue | Value permitted in opaque Safe collections |
| ROptional | std::optional<U> or a Safe optional wrapper |
| RQueue | FIFO wrappers supported by generic queue operations |
| RVariant | Instantiation of std::variant, after stripping cv and references |
| RVariantHasType | StormByte::Type::Variant T that lists U among its alternatives |
| RPair | Type with accessible first and second members |