菜单
kotatsu C++ coding conventions — redundancy elimination (the rule we care most about), file organization, macro.h isolation, dual-mode exception policy, template deduction and type-trait rules, naming, modern C++ preferences. Read BEFORE writing or modifying any C++ code.
默认使用会先检查来源的 Prompt；你也可以切换为直接命令，或下载本地副本。
决定是否安装前，请先阅读 SKILL.md，以及 SkillsMP 当前展示的配套文件。
用 Codex 或 Claude 帮你安装 复制这段 Prompt，粘贴到 Codex、Claude 或其他助手里，让它检查 Skill 页面并帮你完成安装。
直接命令不会经过审查 Prompt；运行前请先检查来源。
npx skills add https://github.com/clice-io/kotatsu --skill cpp-style命令会保持在同一行。复制前请横向滚动并检查完整内容。
想先保存到本地？可下载 SkillsMP 当前能够提供的文件。
基于 SOC 职业分类
正在显示 SKILL.md
| name | cpp-style |
| description | kotatsu C++ coding conventions — redundancy elimination (the rule we care most about), file organization, macro.h isolation, dual-mode exception policy, template deduction and type-trait rules, naming, modern C++ preferences. Read BEFORE writing or modifying any C++ code. |
This is the convention we care most about. Redundant code is not a style nit — it actively misleads: every guard implies the guarded state can occur, every branch implies it can be taken, every parameter implies a caller needs it. When that implication is false, the reader wastes time defending against ghosts.
else after return, a helper with one remaining caller. Fold them
before you're done — simplification that removes a concept beats one
that merely shortens lines..h with #pragma once — never include guards. Public
headers live under include/kota/<module>/..cpp in some, .cc in
others) — match the module you are editing.snake_case.static; a cluster of them goes in
one anonymous namespace.macro.h (today: deco, zest) instead of exporting them
from regular headers. Iron rule: such a macro.h contains zero
#include directives — not even standard headers. It must stay a
pure macro sheet a consumer can include from anywhere with no
transitive cost.KOTA_THROW and the platform feature macros in
kota/support/config.h — stay where they are.struct by default, even for types with methods. class only when
there is a real invariant that private access protects.enum class with an explicit underlying type (e.g. : std::uint8_t);
document each enumerator with /// when its meaning is not obvious.{.field = value}) for aggregate
construction.const T&, never T const&.KOTA_ENABLE_EXCEPTIONS). Library code never writes bare
throw/try/catch — use the KOTA_THROW / KOTA_TRY /
KOTA_CATCH_ALL / KOTA_RETHROW macros from kota/support/config.h,
which degrade to std::abort() in the no-exceptions build.std::expected<T, E>; async
code uses kotatsu's outcome types.assert pins preconditions; impossible branches end in
std::unreachable().if with init-statements to tightly scope error variables, but avoid them when they compromise code readability or flatten control flow.operator bool or evaluates implicitly (e.g., standard error codes, custom error wrappers), omit the redundant condition check.else branches: If scoping the variable inside the if requires you to introduce an else block for the success path (especially when returning early on error), declare the variable in the local scope instead to keep the control flow flat.// Good: Omit redundant condition when the type has operator bool
if (auto err = foo()) {
/* handle error */
}
// Bad: Redundant condition check
if (auto err = foo(); err) {
/* handle error */
}
// Good: Use init-statement when a custom condition is required,
// AND the variable isn't needed outside the if-statement
if (auto result = foo(); !result.has_value()) {
/* handle error */
}
// --- Scope and Control Flow Considerations ---
// Bad: Using init-statement forces an 'else' block because 'result'
// goes out of scope, leading to nested/redundant code.
if (auto result = get_data(); !result.has_value()) {
return result.error();
} else {
process(result.value()); // Success path is forced into a nested block
}
// Good: Declare as a regular local variable to allow early exit
// and keep the success path un-nested (flat control flow).
auto result = get_data();
if (!result.has_value()) {
return result.error();
}
process(result.value());
kota::task, co_await) — an
operation that produces a single asynchronous result returns an
awaitable, never takes a completion callback; completion callbacks
appear only at the libuv boundary inside the implementation.Peer::on_request,
Peer::on_notification, or set_logger are legitimate extension
points — do not replace them with coroutine APIs.snake_case. Class member fields do NOT use any special suffix/prefix (no trailing _, no m_ prefix).PascalCase. Exception: some class names also use snake_case — follow the existing style in the module.PascalCase.///.std::remove_cvref_t on every template parameter. Understand C++ template argument deduction rules:
template<typename T> void f(T x) — T is always deduced as a non-reference, non-cv-qualified type. No need for remove_cvref_t.template<typename T> void f(T& x) — T is deduced as the referred-to type (possibly cv-qualified, but never a reference). No need for remove_cvref_t to strip references.template<typename T> void f(const T& x) — T is deduced as a non-const, non-reference type. No need for remove_cvref_t.template<typename T> void f(T&& x) — forwarding reference: T CAN be deduced as an lvalue reference (e.g., int&). This is the ONLY case where std::remove_cvref_t<T> is needed to get the bare type.auto return deduction and by-value CTAD guides never yield references, but decltype(auto) and explicit deduction guides can carry references and cv-qualifiers.T is whatever the caller wrote — f<int&>(x) makes T = int& even for a by-value f(T x). Only defend with remove_cvref_t if the API actually invites explicit reference arguments.This project targets C++20/23. Use variable templates directly for type traits — do NOT use the old pattern of wrapping a class template static member in a variable template. Prefer:
// Good: directly specialize a variable template
template<typename T>
inline constexpr bool is_my_type_v = false;
template<>
inline constexpr bool is_my_type_v<MyType> = true;
// Bad: unnecessary class template wrapper
template<typename T>
struct is_my_type : std::false_type {};
template<>
struct is_my_type<MyType> : std::true_type {};
template<typename T>
inline constexpr bool is_my_type_v = is_my_type<T>::value;
When defining a concept that checks a type trait, do NOT add std::remove_cvref_t unless you specifically intend the concept to see through references/cv-qualifiers. If the concept is meant for a bare type, just use T directly — the caller is responsible for passing the right type.
// Good
template<typename T>
concept MyTrait = is_my_type_v<T>;
// Bad: unnecessary remove_cvref_t
template<typename T>
concept MyTrait = is_my_type_v<std::remove_cvref_t<T>>;
R"(...)" over escaped strings. Avoid \", \\, \n in string literals when a raw literal is cleaner.[[maybe_unused]] over (void) for intentionally unused variables or parameters.<iostream> facilities (std::cout, std::cin, std::cerr, etc.) or C-style I/O (printf, fprintf, etc.) in library components. Exempt are components whose purpose is producing output: CLI presentation (e.g. deco usage printing), test reporting in zest, and fatal-diagnostic paths that must emit before aborting.std::format for string building.std::ranges / std::views APIs over raw loops and traditional <algorithm> calls.std::string_view > const std::string&.std::span > const std::vector&.