fix: ci

Author: Charliechen114514

documents/en/vol4-advanced/vol1-basics-cpp11-14/01-templates-introduction.md

@@ -1,25 +1,30 @@
 ---
-title: "Templates, From Scratch: A Code Recipe with Placeholders"
-description: "Strip templates back to what they really are: a code recipe with placeholders. How they differ from macros and virtual dispatch, and the four kinds of template entities in C++ (functions, classes, variables, aliases)."
 chapter: 12
-order: 1
-tags:
-  - host
-  - cpp-modern
-  - intermediate
-  - 模板
-  - 泛型
+cpp_standard:
+- 11
+- 14
+- 17
+- 20
+description: 'Strip templates back to what they really are: a code recipe with placeholders.
+  How they differ from macros and virtual dispatch, and the four kinds of template
+  entities in C++ (functions, classes, variables, aliases).'
 difficulty: intermediate
+order: 1
 platform: host
-cpp_standard: [11, 14, 17, 20]
-reading_time_minutes: 18
 prerequisites:
-  - "Volume 1 · Function Templates"
+- Volume 1 · Function Templates
+reading_time_minutes: 11
 related:
-  - "Function Templates, In Depth: Compilation Model and extern template"
-  - "Class Templates: Members, Dependent Names, Lazy Instantiation"
+- 'Function Templates, In Depth: Compilation Model and extern template'
+- 'Class Templates: Members, Dependent Names, Lazy Instantiation'
+tags:
+- host
+- cpp-modern
+- intermediate
+- 模板
+- 泛型
+title: 'Templates, From Scratch: A Code Recipe with Placeholders'
 ---
-
 # Templates, From Scratch: A Code Recipe with Placeholders
 
 We already wrote function templates back in Volume 1. We know that `template <typename T> T max_value(T a, T b)` lets the compiler stamp out a version for `int`, for `double`, for `std::string`. This volume stops at "how to use them" and asks different questions. What is a template, really? How does it pull off "write once, fit any type"? And what does that mechanism cost? Get the under-the-hood details straight, and reading the STL source, reading template-heavy industrial code like Chromium, or writing a library of your own stops feeling intimidating.

documents/en/vol4-advanced/vol1-basics-cpp11-14/02-function-templates-deep.md

@@ -1,26 +1,32 @@
 ---
-title: "Function Templates, In Depth: Compilation Model and the No-Partial-Specialization Trap"
-description: "Re-reading function templates from a library writer's angle: why the inclusion model forces templates into headers, how explicit instantiation and extern template control code bloat, and the classic trap that function templates cannot be partially specialized."
 chapter: 12
-order: 2
-tags:
-  - host
-  - cpp-modern
-  - intermediate
-  - 模板
-  - 泛型
+cpp_standard:
+- 11
+- 14
+- 17
+description: 'Re-reading function templates from a library writer''s angle: why the
+  inclusion model forces templates into headers, how explicit instantiation and extern
+  template control code bloat, and the classic trap that function templates cannot
+  be partially specialized.'
 difficulty: intermediate
+order: 2
 platform: host
-cpp_standard: [11, 14, 17]
-reading_time_minutes: 20
 prerequisites:
-  - "Volume 1 · Function Templates"
-  - "Templates, From Scratch: A Code Recipe with Placeholders"
+- Volume 1 · Function Templates
+- 'Templates, From Scratch: A Code Recipe with Placeholders'
+reading_time_minutes: 11
 related:
-  - "Class Templates: Members, Dependent Names, Lazy Instantiation"
-  - "Template Specialization and Partial Specialization: The Art of Pattern Matching"
+- 'Class Templates: Members, Dependent Names, Lazy Instantiation'
+- 'Template Specialization and Partial Specialization: The Art of Pattern Matching'
+tags:
+- host
+- cpp-modern
+- intermediate
+- 模板
+- 泛型
+title: 'Function Templates, In Depth: Compilation Model and the No-Partial-Specialization
+  Trap'
 ---
-
 # Function Templates, In Depth: Compilation Model and the No-Partial-Specialization Trap
 
 Volume 1 already covered function templates: the syntax, instantiation, deduction, specialization, and overloading. This piece shifts perspective to "I want to build a library with templates," where three things are unavoidable. Why the compilation model for templates differs from ordinary functions. How explicit instantiation and `extern template` help you control code bloat. And a trap that can leave you staring at the screen for half an hour: function templates cannot be partially specialized. Get these three straight, and reading the source of STL or template-heavy libraries like Eigen starts to make sense, why they organize the code the way they do.

documents/en/vol4-advanced/vol1-basics-cpp11-14/03-class-templates.md

@@ -1,26 +1,32 @@
 ---
-title: "Class Templates: Members, Dependent Names, and Lazy Instantiation"
-description: "Class templates are the foundation of the STL. This piece covers the three differences from function templates that trip people up: members defined inside or outside the class, the lazy-instantiation temper, and why dependent names need typename and this-> for disambiguation."
 chapter: 12
-order: 3
-tags:
-  - host
-  - cpp-modern
-  - intermediate
-  - 模板
-  - 泛型
+cpp_standard:
+- 11
+- 14
+- 17
+description: 'Class templates are the foundation of the STL. This piece covers the
+  three differences from function templates that trip people up: members defined inside
+  or outside the class, the lazy-instantiation temper, and why dependent names need
+  typename and this-> for disambiguation.'
 difficulty: intermediate
+order: 3
 platform: host
-cpp_standard: [11, 14, 17]
-reading_time_minutes: 20
 prerequisites:
-  - "Templates, From Scratch: A Code Recipe with Placeholders"
-  - "Function Templates, In Depth: Compilation Model and the No-Partial-Specialization Trap"
+- 'Templates, From Scratch: A Code Recipe with Placeholders'
+- 'Function Templates, In Depth: Compilation Model and the No-Partial-Specialization
+  Trap'
+reading_time_minutes: 10
 related:
-  - "Template Specialization and Partial Specialization: The Art of Pattern Matching"
-  - "Name Lookup and ADL: How Two-Phase Lookup Works"
+- 'Template Specialization and Partial Specialization: The Art of Pattern Matching'
+- 'Name Lookup and ADL: How Two-Phase Lookup Works'
+tags:
+- host
+- cpp-modern
+- intermediate
+- 模板
+- 泛型
+title: 'Class Templates: Members, Dependent Names, and Lazy Instantiation'
 ---
-
 # Class Templates: Members, Dependent Names, and Lazy Instantiation
 
 Class templates are the foundation of the STL. `std::vector`, `std::map`, and `std::string` (really `std::basic_string<char>`) are all class templates. Knowing function templates does not mean knowing class templates. There are a few key differences, and they happen to be exactly where newcomers stumble. This piece focuses on three: whether member functions go inside or outside the class, the error-hiding temper that lazy instantiation brings, and why dependent names need `typename` and `this->` for disambiguation. Get these three straight, and writing your own containers or policy classes, or reading STL source, stops snagging on these details.

documents/en/vol4-advanced/vol1-basics-cpp11-14/04-specialization-partial.md

@@ -1,26 +1,33 @@
 ---
-title: "Template Specialization and Partial Specialization: The Art of Pattern Matching"
-description: "Specialization is the most expressive part of templates. Full vs partial specialization, the rule by which the compiler picks the most specialized version, and two classic applications: why std::vector<bool> is a partial specialization, and how the entire type_traits machinery (is_pointer, is_const) is built on partial specialization."
 chapter: 12
-order: 4
-tags:
-  - host
-  - cpp-modern
-  - intermediate
-  - 模板
-  - 泛型
+cpp_standard:
+- 11
+- 14
+- 17
+description: 'Specialization is the most expressive part of templates. Full vs partial
+  specialization, the rule by which the compiler picks the most specialized version,
+  and two classic applications: why std::vector<bool> is a partial specialization,
+  and how the entire type_traits machinery (is_pointer, is_const) is built on partial
+  specialization.'
 difficulty: intermediate
+order: 4
 platform: host
-cpp_standard: [11, 14, 17]
-reading_time_minutes: 20
 prerequisites:
-  - "Class Templates: Members, Dependent Names, and Lazy Instantiation"
-  - "Function Templates, In Depth: Compilation Model and the No-Partial-Specialization Trap"
+- 'Class Templates: Members, Dependent Names, and Lazy Instantiation'
+- 'Function Templates, In Depth: Compilation Model and the No-Partial-Specialization
+  Trap'
+reading_time_minutes: 10
 related:
-  - "Non-Type Template Parameters: From Integers to C++20 Floats and Class Types"
-  - "Name Lookup and ADL: How Two-Phase Lookup Works"
+- 'Non-Type Template Parameters: From Integers to C++20 Floats and Class Types'
+- 'Name Lookup and ADL: How Two-Phase Lookup Works'
+tags:
+- host
+- cpp-modern
+- intermediate
+- 模板
+- 泛型
+title: 'Template Specialization and Partial Specialization: The Art of Pattern Matching'
 ---
-
 # Template Specialization and Partial Specialization: The Art of Pattern Matching
 
 The strongest part of templates is not "write one, fit any type." It is **giving some specific type, or some family of types, a separate, different implementation.** This mechanism is called specialization. It comes in two forms: full specialization targets one concrete type, partial specialization targets a family of types matching a pattern. The previous piece noted that function templates cannot be partially specialized; only class templates and variable templates can. This piece takes class-template specialization all the way: full specialization, partial specialization, the priority rule for which version the compiler picks, and two classic cases that push partial specialization to the limit, the standard library's `std::vector<bool>` and the whole of `<type_traits>`.

documents/en/vol4-advanced/vol1-basics-cpp11-14/05-non-type-parameters.md

@@ -1,27 +1,33 @@
 ---
-title: "Non-Type Template Parameters: From Integers to C++20 Floats and Class Types"
-description: "A non-type template parameter parameterizes a value, not a type. The N in array<T, N> is one. What types it accepts, the C++17 auto placeholder, how C++20 opened it up to floating-point and structural class types, and which arguments count as the same instantiation."
 chapter: 12
-order: 5
-tags:
-  - host
-  - cpp-modern
-  - intermediate
-  - 模板
-  - 泛型
-  - 编译期计算
+cpp_standard:
+- 11
+- 14
+- 17
+- 20
+description: A non-type template parameter parameterizes a value, not a type. The
+  N in array<T, N> is one. What types it accepts, the C++17 auto placeholder, how
+  C++20 opened it up to floating-point and structural class types, and which arguments
+  count as the same instantiation.
 difficulty: intermediate
+order: 5
 platform: host
-cpp_standard: [11, 14, 17, 20]
-reading_time_minutes: 18
 prerequisites:
-  - "Template Specialization and Partial Specialization: The Art of Pattern Matching"
-  - "Class Templates: Members, Dependent Names, and Lazy Instantiation"
+- 'Template Specialization and Partial Specialization: The Art of Pattern Matching'
+- 'Class Templates: Members, Dependent Names, and Lazy Instantiation'
+reading_time_minutes: 9
 related:
-  - "Name Lookup and ADL: How Two-Phase Lookup Works"
-  - "Template Friends and Barton-Nackman: The Hidden Friends Trick"
+- 'Name Lookup and ADL: How Two-Phase Lookup Works'
+- 'Template Friends and Barton-Nackman: The Hidden Friends Trick'
+tags:
+- host
+- cpp-modern
+- intermediate
+- 模板
+- 泛型
+- 编译期计算
+title: 'Non-Type Template Parameters: From Integers to C++20 Floats and Class Types'
 ---
-
 # Non-Type Template Parameters: From Integers to C++20 Floats and Class Types
 
 The previous pieces parameterized types. `typename T` stands in for a type. A template can also parameterize something else: **a value known at compile time**. The `N` in `std::array<T, N>` and `std::bitset<N>` is exactly this kind of parameter, called a non-type template parameter. This piece covers what types of values it can take, how C++17 `auto` made it more flexible, how C++20 opened it up from "integers and pointers only" to "floating-point and even class types," and which arguments count as the "same" instantiation. The C++20 relaxation is the biggest upgrade non-type parameters have had since they were invented, and it enables fixed_string, compile-time constant objects, and other new tricks.

documents/en/vol4-advanced/vol1-basics-cpp11-14/06-name-lookup-and-adl.md

@@ -1,26 +1,32 @@
 ---
-title: "Name Lookup and ADL: How Two-Phase Lookup Works"
-description: "Name lookup inside templates works nothing like ordinary code. It happens in two phases. This piece covers two-phase lookup, dependent vs non-dependent names, ADL (argument-dependent lookup), and why the typename, this->, and hidden-friends rules from earlier pieces have to exist."
 chapter: 12
-order: 6
-tags:
-  - host
-  - cpp-modern
-  - intermediate
-  - 模板
-  - 泛型
+cpp_standard:
+- 11
+- 14
+- 17
+- 20
+description: Name lookup inside templates works nothing like ordinary code. It happens
+  in two phases. This piece covers two-phase lookup, dependent vs non-dependent names,
+  ADL (argument-dependent lookup), and why the typename, this->, and hidden-friends
+  rules from earlier pieces have to exist.
 difficulty: intermediate
+order: 6
 platform: host
-cpp_standard: [11, 14, 17, 20]
-reading_time_minutes: 20
 prerequisites:
-  - "Class Templates: Members, Dependent Names, and Lazy Instantiation"
-  - "Non-Type Template Parameters: From Integers to C++20 Floats and Class Types"
+- 'Class Templates: Members, Dependent Names, and Lazy Instantiation'
+- 'Non-Type Template Parameters: From Integers to C++20 Floats and Class Types'
+reading_time_minutes: 9
 related:
-  - "Template Friends and Barton-Nackman: The Hidden Friends Trick"
-  - "Template Specialization and Partial Specialization: The Art of Pattern Matching"
+- 'Template Friends and Barton-Nackman: The Hidden Friends Trick'
+- 'Template Specialization and Partial Specialization: The Art of Pattern Matching'
+tags:
+- host
+- cpp-modern
+- intermediate
+- 模板
+- 泛型
+title: 'Name Lookup and ADL: How Two-Phase Lookup Works'
 ---
-
 # Name Lookup and ADL: How Two-Phase Lookup Works
 
 In ordinary code, when you use a name, the compiler looks it up at the current position, finds it, and uses it. In templates, that stops working. Name lookup in templates happens in two phases, one at the template definition and one at instantiation. This mechanism is called two-phase lookup, and it is exactly what explains the seemingly strange rules from earlier pieces: why `typename` cannot be dropped, why `this->` is mandatory, and why hidden friends matter. This piece takes two-phase lookup, dependent and non-dependent names, and ADL all the way through. After it, the "inexplicable" errors you hit in templates will all trace back to a root cause you can name.

documents/en/vol4-advanced/vol1-basics-cpp11-14/07-friends-and-barton-nackman.md

@@ -1,26 +1,32 @@
 ---
-title: "Template Friends and Barton-Nackman: The Hidden Friends Trick"
-description: "The previous piece covered ADL. This one covers its most elegant partner: hidden friends and the Barton-Nackman trick. Define operator== as a friend inside a class template, and each instantiation gets an operator dedicated to its own type, without polluting the global overload pool, discoverable by ADL on exact match."
 chapter: 12
-order: 7
-tags:
-  - host
-  - cpp-modern
-  - intermediate
-  - 模板
-  - 泛型
+cpp_standard:
+- 11
+- 14
+- 17
+- 20
+description: 'The previous piece covered ADL. This one covers its most elegant partner:
+  hidden friends and the Barton-Nackman trick. Define operator== as a friend inside
+  a class template, and each instantiation gets an operator dedicated to its own type,
+  without polluting the global overload pool, discoverable by ADL on exact match.'
 difficulty: intermediate
+order: 7
 platform: host
-cpp_standard: [11, 14, 17, 20]
-reading_time_minutes: 18
 prerequisites:
-  - "Name Lookup and ADL: How Two-Phase Lookup Works"
-  - "Class Templates: Members, Dependent Names, and Lazy Instantiation"
+- 'Name Lookup and ADL: How Two-Phase Lookup Works'
+- 'Class Templates: Members, Dependent Names, and Lazy Instantiation'
+reading_time_minutes: 7
 related:
-  - "Alias Templates and using Declarations: Short Names for Types"
-  - "CRTP: Static Polymorphism with the Curiously Recurring Template Pattern"
+- 'Alias Templates and using Declarations: Short Names for Types'
+- 'CRTP: Static Polymorphism with the Curiously Recurring Template Pattern'
+tags:
+- host
+- cpp-modern
+- intermediate
+- 模板
+- 泛型
+title: 'Template Friends and Barton-Nackman: The Hidden Friends Trick'
 ---
-
 # Template Friends and Barton-Nackman: The Hidden Friends Trick
 
 The previous piece covered ADL. This one covers its most elegant partner: **hidden friends** and the **Barton-Nackman trick**. The core idea in one sentence: define operators (like `operator==`, `operator<<`) as **friends of a class template, with the definition directly inside the class**. Each instantiation then gets a non-template operator function dedicated to that type. It neither pollutes the global overload pool, and it is discoverable by ADL on exact type match. This is the recommended way to give operators to a custom type in modern C++, and the standard library uses it heavily.

documents/en/vol4-advanced/vol1-basics-cpp11-14/08-alias-and-using.md

@@ -1,27 +1,32 @@
 ---
-title: "Alias Templates and using Declarations: Short Names for Types"
-description: "C++11 alias templates (template<typename T> using X = ...) fix the old problem that typedef cannot be parameterized. The _t alias (from C++14) and the _v variable (from C++17) make type_traits clean to write, and using introduces dependent-base names in template inheritance. This piece covers all three uses."
 chapter: 12
-order: 8
-tags:
-  - host
-  - cpp-modern
-  - intermediate
-  - 模板
-  - 类型别名
-  - 泛型
+cpp_standard:
+- 11
+- 14
+- 17
+description: C++11 alias templates (template<typename T> using X = ...) fix the old
+  problem that typedef cannot be parameterized. The _t alias (from C++14) and the
+  _v variable (from C++17) make type_traits clean to write, and using introduces dependent-base
+  names in template inheritance. This piece covers all three uses.
 difficulty: intermediate
+order: 8
 platform: host
-cpp_standard: [11, 14, 17]
-reading_time_minutes: 16
 prerequisites:
-  - "Name Lookup and ADL: How Two-Phase Lookup Works"
-  - "Class Templates: Members, Dependent Names, and Lazy Instantiation"
+- 'Name Lookup and ADL: How Two-Phase Lookup Works'
+- 'Class Templates: Members, Dependent Names, and Lazy Instantiation'
+reading_time_minutes: 7
 related:
-  - "Template Friends and Barton-Nackman: The Hidden Friends Trick"
-  - "CRTP: Static Polymorphism with the Curiously Recurring Template Pattern"
+- 'Template Friends and Barton-Nackman: The Hidden Friends Trick'
+- 'CRTP: Static Polymorphism with the Curiously Recurring Template Pattern'
+tags:
+- host
+- cpp-modern
+- intermediate
+- 模板
+- 类型别名
+- 泛型
+title: 'Alias Templates and using Declarations: Short Names for Types'
 ---
-
 # Alias Templates and using Declarations: Short Names for Types
 
 C++11 upgraded type aliasing with a new use of `using` and the **alias template**. The old `typedef` can give one type a new name, but it cannot be parameterized. You want a short name for `std::vector<T>`, and `typedef` cannot do it; you have to go through a nested type inside a class template. `using` plus alias templates fix this directly. This piece covers three uses: the alias template itself, the `_t` alias (from C++14) and the `_v` variable (from C++17) used to type_traits, and the role of `using` in introducing base-class names in template inheritance (a follow-up to the `this->` discussion in piece three).