Rust Ecosystem

<concept name="borrowing">
  <description>Immutable and mutable references with strict rules</description>
  <rules priority="critical">
    <rule>&T allows multiple simultaneous borrows</rule>
    <rule>&mut T allows exactly one mutable borrow</rule>
    <rule>Cannot have &mut T while &T exists</rule>
  </rules>
</concept>

<concept name="lifetimes">
  <description>Lifetime annotations for reference validity</description>
  <pattern name="elision">
    <description>Compiler infers lifetimes in common patterns</description>
  </pattern>
  <pattern name="explicit">
    <description>Explicit lifetime annotations for complex cases</description>
    <example>
      fn foo<'a>(x: &'a str) -> &'a str {
        x
      }
    </example>
  </pattern>
  <pattern name="static">
    <description>'static for values that live entire program</description>
  </pattern>
</concept>

<pattern name="derive">
  <description>Automatically implement common traits</description>
  <example>
    #[derive(Debug, Clone, PartialEq, Eq, Hash)]
    struct MyType {
      field1: String,
      field2: i32,
    }
  </example>
</pattern>

<pattern name="Option">
  <description>Optional values with Option with T type parameter</description>
  <operators>? for early return on None</operators>
  <combinators>map, and_then, unwrap_or, unwrap_or_default</combinators>
</pattern>

<pattern name="custom_error">
  <description>Define custom error types with thiserror or anyhow</description>
  <example>
    #[derive(Debug, thiserror::Error)]
    enum MyError {
      #[error("IO error: {0}")]
      Io(#[from] std::io::Error),
      #[error("Parse error: {msg}")]
      Parse { msg: String },
    }
  </example>
</pattern>

<pattern name="newtype">
  <description>Wrapper type for type safety</description>
  <example>
    struct UserId(u64);
  </example>
</pattern>

<pattern name="type_state">
  <description>Encode state in type system</description>
  <use_case>Prevent invalid state transitions at compile time</use_case>
</pattern>

<avoid name="clone_abuse">
  <description>Cloning values unnecessarily</description>
  <instead>Prefer borrowing when possible</instead>
</avoid>

<avoid name="string_for_everything">
  <description>Using String for all domain values</description>
  <instead>Use enums, newtypes for domain modeling</instead>
</avoid>

<avoid name="arc_mutex_overuse">
  <description>Defaulting to Arc with Mutex with T for concurrency</description>
  <instead>Consider channels or ownership patterns first</instead>
</avoid>

<module_organization>
  <pattern name="mod_rs">
    <description>src/module/mod.rs with submodules</description>
  </pattern>
  <pattern name="file_module">
    <description>src/module.rs (preferred for simple modules)</description>
  </pattern>
</module_organization>

  [dependencies]
  serde = { version = "1.0", features = ["derive"] }

  [dev-dependencies]
  tokio-test = "0.4"

  [build-dependencies]
  cc = "1.0"
</basic_structure>

<feature_flags>
  [features]
  default = ["std"]
  std = []
  async = ["tokio"]
  full = ["std", "async"]
</feature_flags>

<profile_optimization>
  [profile.release]
  lto = true
  codegen-units = 1
  panic = "abort"
  strip = true

  [profile.dev]
  opt-level = 0
  debug = true
</profile_optimization>

  [workspace.package]
  version = "0.1.0"
  edition = "2021"
  license = "MIT"

  [workspace.dependencies]
  serde = "1.0"
  tokio = { version = "1", features = ["full"] }
</root_cargo_toml>

<member_inheritance>
  [package]
  name = "crate-a"
  version.workspace = true
  edition.workspace = true

  [dependencies]
  serde.workspace = true
</member_inheritance>

<decision_tree name="when_to_use">
  <question>Do you have multiple related crates in one repository?</question>
  <if_yes>Use workspace to share dependencies and build configuration</if_yes>
  <if_no>Single crate project without workspace structure</if_no>
</decision_tree>

<configuration>
  <file_reference>In Cargo.toml</file_reference>
  [lints.clippy]
  pedantic = "warn"
  nursery = "warn"
  unwrap_used = "deny"
  expect_used = "deny"

  <file_reference>Or in clippy.toml</file_reference>

  msrv = "1.70"
  cognitive-complexity-threshold = 25
</configuration>

<common_lints>
  <lint name="clippy::unwrap_used">Prefer ? or proper error handling</lint>
  <lint name="clippy::expect_used">Prefer ? or proper error handling</lint>
  <lint name="clippy::pedantic">Stricter lints for cleaner code</lint>
  <lint name="clippy::nursery">Experimental but useful lints</lint>
</common_lints>

<configuration>
  <file_reference>rustfmt.toml</file_reference>
  edition = "2021"
  max_width = 100
  use_small_heuristics = "Max"
  imports_granularity = "Crate"
  group_imports = "StdExternalCrate"
  reorder_imports = true
</configuration>

<features>
  <feature>Parallel test execution</feature>
  <feature>Better failure output</feature>
  <feature>JUnit XML output for CI</feature>
  <feature>Test retries</feature>
</features>

<configuration>
  <file_reference>.config/nextest.toml</file_reference>
  [profile.default]
  retries = 2
  slow-timeout = { period = "60s", terminate-after = 2 }
  fail-fast = false
</configuration>

<pattern name="cargo_configuration">
  <step>get-library-docs context7CompatibleLibraryID="/rust-lang/cargo.git" topic="workspace"</step>
</pattern>

<pattern name="clippy_lints">
  <step>get-library-docs context7CompatibleLibraryID="/rust-lang/rust-clippy" topic="lints configuration"</step>
</pattern>