Abstract:

This talk presents a personal project: a C++23 library for declarative binary data parsing using template metaprogramming (TMP). The speaker, Hari Manuharan, argues that traditional methods like reinterpret_cast are brittle due to alignment, padding, and non-standard field sizes, while manual parsing leads to excessive boilerplate code. The proposed solution is an embedded domain-specific language (DSL) built with modern C++ features.

The implementation relies heavily on C++20/23 concepts. It uses fixed_string for non-type template parameters to name fields, variadic templates to define struct layouts (struct_field_list), and concepts to enforce constraints like unique field names at compile time. The parsing logic is built around a monadic pipeline using a std::expected-like pattern to handle errors and short-circuit on failure. The ultimate goal, as far as I can tell, is to replace this complex TMP implementation with a much cleaner, annotation-based system once C++26 reflection is available, making the current project a stepping stone. The project is not production-ready.

Declarative Binary Parsing with C++23 Template Metaprogramming

• 0:00:19 Introduction: The talk is about a C++23 library for parsing binary formats, aiming to replace manual, boilerplate-heavy code with a declarative approach.
• 02:28 The Problem with Simple Casting: Using reinterpret_cast on a C++ struct to parse binary data is fundamentally unreliable. It fails due to compiler-inserted padding, memory alignment requirements, and formats using non-standard integer sizes (e.g., 3-byte integers).
• 06:41 Complexity of Manual Parsing: Manual parsing becomes unmanageable when dealing with common binary format features like conditional fields, length-prefixed arrays, unions (tagged values), endianness differences, and value validation. This leads to a lot of repetitive, error-prone code.
• 09:19 A Declarative, TMP-Based Solution: The speaker proposes an embedded DSL using template metaprogramming. The library promises compile-time parser generation, no macros, and a simple API (struct_cast) that returns a std::expected-like object containing either the parsed struct or an error.
• 15:40 Core Building Blocks: The library is built from several modern C++ components:
  • A fixed_string class that allows string literals to be used as non-type template parameters, essential for naming fields declaratively.
  • A type_list utility (a variadic template struct) to manage collections of types at compile time.
  • A struct_field_list that uses variadic templates and inheritance to compose fields into a layout, with C++ concepts ensuring correctness (e.g., unique field names).
• 23:32 Field Access via a static_cast Hack: Since the library creates a meta-struct, not a standard C++ struct, member access uses a map-like operator[]. This is implemented by static_cast-ing the parent struct_field_list object to the type of the requested child field, using object slicing to return just that field's value.
• 31:04 Monadic Error Handling: The parsing process for a sequence of fields is managed by a monadic pipeline. Each field is read in a separate step; if a read fails, it returns an error, and the pipeline immediately short-circuits, propagating the error without attempting to parse subsequent fields.
• 38:21 The Future is C++26 Reflection: The speaker correctly points out that this entire TMP-based DSL is a temporary, if educational, solution. The introduction of static reflection and annotations in C++26 will allow for a far superior approach where developers can use regular structs with annotations (e.g., [[endian(big)]]), and the library can introspect them to generate the parser automatically.