菜单
Use when naming or renaming a Rust function, method, struct, enum, trait, or module in this photomosaic crate — especially when a name is heading past three words (find_and_use_best_tile_with_position, process_tile_no_aspect_filter), contains and/or/with/if_missing (load_or_new), or describes several tile-selection or optimization steps at once.
用 Codex 或 Claude 帮你安装 复制这段 Prompt，粘贴到 Codex、Claude 或其他助手里，让它检查 Skill 页面并帮你完成安装。
Use when writing Rust that branches on an owned enum modeling state — TileStatus (NotStarted/InProgress/Completed) in the grid visualizer, a filled-vs-empty grid cell, a cache hit vs miss, or a simulated-annealing accept/reject decision — to choose behavior or a value, or when adding a variant to such an enum. Also when reaching for an if-let chain, a let-else, matches!, or a `_` wildcard arm to consume an enum this crate owns.
Use when composing or chaining Result values across the mosaic pipeline — sequencing image-load, decode, resize, and Lab-conversion steps (src/tile_cache.rs, src/similarity.rs); tempted by unwrap()/expect() on a missing material file or a corrupt similarity-cache JSON; discarding a save/load Result with let _ = ...; or deciding whether a failure becomes a CLI exit code (src/main.rs) or a rendered ProcessingState::Error (src/gui/app_full.rs).
Use when writing or modifying a Rust function with conditional branches — writing a per-tile or per-material loop that filters candidates, nesting a bounds check inside a usage-limit check, threading a `let mut best_match` through branches to return at the end, or wrapping a whole grid-loop body in a condition.
Use when converting between numeric types in this photomosaic generator, converting string↔number, or about to write `as` — u8 pixel channel ↔ f32 [0,1] color math, f32→u8 narrowing with clamp, usize↔u32 grid/tile index math, pixel counts (width * height) widened to f64 for averaging, or Lab/ΔE float math.
Use when authoring or converting Rust types in this photomosaic generator — defining a struct, enum, or function signature for grid cells, tile-placement outcomes, Lab colors, usage counts, adjacency penalties, or optimization config; typing several correlated fields as Option<T>; or about to reach for String, serde_json::Value, HashMap<String, String>, an over-permissive Vec<u8>, an `as` cast, or unwrap()/expect() to avoid modeling a value.
Use when branching on a file's extension or another string-token family with a growing match!/if-chain — e.g. supported material-image extensions "png"|"jpg"|"jpeg"|"webp" — especially when the same token-family test is duplicated across call sites (src/main.rs vs src/gui/app_full.rs) and has already drifted out of sync, or when adding several new format tokens to an existing check.
| name | three-word-naming |
| description | Use when naming or renaming a Rust function, method, struct, enum, trait, or module in this photomosaic crate — especially when a name is heading past three words (find_and_use_best_tile_with_position, process_tile_no_aspect_filter), contains and/or/with/if_missing (load_or_new), or describes several tile-selection or optimization steps at once. |
Functions, methods, structs, enums, traits, and modules get at most three words. A name that needs a fourth word is not a naming problem — it is a scope problem: the code is doing more than one thing, or it is missing the namespace that should carry part of the name. Fix the scope, and the short name falls out.
Never fix a too-long name by abbreviating, dropping vowels, or fusing words. Shorten the responsibility, not the spelling.
_, CamelCase on capitals: calculate_average_lab = 3, AdjacencyPenaltyCalculator = 3, find_and_use_best_tile_with_position = 7 ❌.process_tile_no_aspect_filter = 5 ❌ (process, tile, no, aspect, filter).lab = 1, 2000 = 1) — but calculate_delta_e_2000 still lands at 4 (calculate, delta, e, 2000) ❌.new, from_x, with_x) count normally but rarely trip the limit: SimilarityDatabase::new is fine.#[test] functions (names narrate behavior — test_similarity_database_load_or_new is fine even though the production load_or_new it tests is not), constants, local variables, trait method implementations (the trait fixed the name), and derive/trait-mandated names (fmt, from, try_from).1. Raise the abstraction — split and compose. A 4+ word name is usually a step list. Each step gets its own ≤3-word function; the composition point keeps a short name describing the outcome, not the steps.
2. Move a word into a namespace. If the extra words are a noun phrase repeated across the module, they are the module's (or type's) name, not each function's. Callers read tile_selector::find_best(...) or tracker.tick() — the context words are written once.
// ❌ 7 words — find + use(mark-used) + best + tile + with + position crammed into one name
fn find_and_use_best_tile_with_position(
&mut self, target_lab: &Lab, x: usize, y: usize,
) -> Option<Arc<Tile>> { .. }
// ✅ remedy 2 — module tile_selector carries the noun phrase, position drops to a plain arg
mod tile_selector {
fn find_best(state: &State, target_lab: &Lab, x: usize, y: usize) -> Option<Arc<Tile>> { .. } // tile_selector::find_best(...)
fn mark_used(state: &mut State, tile: &Tile) { .. } // tile_selector::mark_used(...)
}
// ✅ remedy 1 — or split by responsibility where a module isn't warranted
fn find_best_tile(&self, target_lab: &Lab, x: usize, y: usize) -> Option<Arc<Tile>> { .. }
fn mark_tile_used(&mut self, tile: &Tile) { .. }
The same move works with a struct as the namespace: TileCache::get(), GridVisualizer::complete_tile(), or a method on the value itself: tracker.tick().
Rust convention pushes this further: don't repeat the module or type name inside the function — TileCache::get_tile ❌ → TileCache::get ✅ (this repo already gets it right). That repetition is remedy 2 done halfway; clippy's module_name_repetitions lint catches the type-name version of the same mistake.
| Smell in the name | What it reveals | Fix |
|---|---|---|
_and_ (find_and_use_best_tile_with_position) | two responsibilities fused: finding a tile and marking it used | split: find_best_tile + mark_tile_used, compose at the caller |
_with_ tail on the same name (..._with_position) | a parameter leaking into the name | position is already an argument — drop it from the name: find_best_tile(x, y) |
negated variant suffix (process_tile_no_aspect_filter) sitting next to process_tile) | a guard/filter fused into a whole separate function instead of a parameter | fold it in: process_tile(path, aspect_filter: Option<AspectTolerance>) |
_or_ fused branches (SimilarityDatabase::load_or_new) | "load, else construct new" is two responsibilities wearing one verb | keep load_from_file fallible, let the caller do .unwrap_or_else(Self::new) — or rename to say what it actually promises |
repeated noun phrase across functions (process_tile, process_tile_no_aspect_filter) | a missing parameter/variant, not a new function | fold the variant into the base function via a parameter |
| Mistake | Fix |
|---|---|
Abbreviating to sneak under the limit (find_use_tile) | Still multiple responsibilities. Split or namespace — never compress spelling. |
Vague 1-worder to dodge the limit (process, handle, do_it) | Under-specific is as bad as over-long. Three precise words beat one vague one. |
| Counting digit/formula-name groups as "free" | They count. calculate_delta_e_2000 → namespace it: color_diff::delta_e_2000 (the module absorbs "calculate"). |
Renaming without re-scoping (find_and_use_best_tile_with_position → find_best_tile_with_position) | Now the name lies — it no longer promises the tile gets marked used. Split first, then name what's left. |
| Applying the limit to tests, constants, or trait impls | Test names narrate behavior (test_similarity_database_load_or_new); constants encode ranges; trait-mandated names (fmt, from, try_from) aren't yours to shorten. All exempt. |
_ segment (or 4th capitalized word in CamelCase) → stop, split or namespace. (find_and_use_best_tile_with_position has seven.)_and_, _with_, _or_ inside a function name → the scope is too broad (load_or_new is doing two things).process_tile vs process_tile_no_aspect_filter) → fold the variant into a parameter instead of a new function.TileCache::get_tile) → clippy's module_name_repetitions is about to fire; drop the repeat.