Update 2025-11-30-comptime-c-functions.md

Author: MyNameIsTrez

_posts/2025-11-30-comptime-c-functions.md

@@ -7,7 +7,7 @@ date: 2025-11-30 12:00:00 +0100
 Compile-time function execution is great, as it means your program has to run less code at runtime, but what if:
 1. You're stuck with C.
 2. You don't want to use evil C macros, as they are debugging nightmares.
-3. You want generic data structures that work for all types, and that can use `malloc()` and `free()` internally.
+3. You want type-generic data structures that work for all types, and that can use `malloc()` and `free()` internally.
 
 This blog post shows programs where data structures get completely optimized away at compile time by Clang and GCC, using [constant folding](https://en.wikipedia.org/wiki/Constant_folding), [inlining](https://en.wikipedia.org/wiki/Inline_expansion), and [dead code elimination](https://en.wikipedia.org/wiki/Dead-code_elimination). Here is the x86-64 Assembly that their functions get optimized down to:
 ```nasm
@@ -24,7 +24,7 @@ Embedded systems with tight runtime constraints, and zero-cost abstraction C lib
 
 [Link-time optimization](https://en.wikipedia.org/wiki/Interprocedural_optimization) with `-flto` should allow Clang and GCC to perform these optimizations even when the code is split across several object files.
 
-# Generic stack
+# Stack
 
 I added a `main()` function to the below program, to prove that it doesn't crash on any `assert()` calls at runtime. It's important to note that the `fn_version()` and `macro_version()` functions get optimized just as hard, even when you remove the `main()`.
 
@@ -186,7 +186,7 @@ int main() {
 }
 ```
 
-# Generic hash map
+# Hash map
 
 Because a hash map is a much more complex data structure than a stack, GCC struggles to optimize it perfectly, even with macros and extra flags:
 - `-finline-limit=999999`