Scala Project Rules

scalajvmfunctional

Enforces Scala idioms including case classes, functional programming patterns, type safety, implicits/given usage, and effect management for robust JVM applications.

Целевые файлы

Файл	Формат
.cursorrules	plaintext
CLAUDE.md	markdown

Содержимое

## Scala Project Rules ### Types & Case Classes - Use `case class` for immutable data structures — they get `equals`, `hashCode`, `copy`, `apply` for free - Use `case object` for singleton values in sealed hierarchies - Prefer `sealed trait` over `sealed abstract class` for ADT bases unless a constructor is needed - Always pattern match sealed types exhaustively — enable `-Xfatal-warnings` to catch missing cases - Use `opaque type` (Scala 3) or value classes for domain-specific wrappers to prevent type confusion ### Functional Patterns - Prefer immutable data — use `val` everywhere; only use `var` with explicit justification - Prefer recursion and standard collection methods over imperative loops - Use `map`, `flatMap`, `filter`, `fold`, `reduce`, `traverse` over explicit iteration - Chain operations with `for`-comprehensions for readable monadic pipelines - Avoid throwing exceptions in pure functions — return `Either[Error, T]` or `Option[T]` ### Option, Either, Try - Use `Option[T]` for values that may be absent but where absence is not an error - Use `Either[DomainError, T]` for operations that can fail with a typed error - Use `Try[T]` only for wrapping Java code that throws — prefer `Either` in Scala code - Use `.fold`, `.map`, `.flatMap` on these types — avoid `.get` on `Option` and `.right.get` on `Either` - Define a sealed `DomainError` hierarchy for `Left` values — never use raw `String` errors ### Collections - Prefer `List` for sequential access, `Vector` for indexed access, `Map`/`Set` for lookups - Use `LazyList` for potentially infinite or expensive-to-compute sequences - Prefer `xs.headOption` over `xs.head` to avoid `NoSuchElementException` - Avoid mutable collections (`ArrayBuffer`, `HashMap`) in public APIs — they signal imperative style - Use `xs.groupBy`, `xs.partition`, `xs.span` instead of manual `foldLeft` accumulators ### Implicits / Given (Scala 3) - In Scala 3, use `given`/`using` instead of `implicit val`/`implicit def` - Keep implicit/given instances in companion objects or dedicated `Implicits` objects - Never create implicit conversions that silently change types — they hide bugs - Use `extension` methods instead of implicit classes for adding methods to existing types - Name `given` instances descriptively: `given jsonEncoder: Encoder[User] = ...` ### Concurrency - Use `Future[T]` for async operations; always provide an explicit `ExecutionContext` - Do not use the global `ExecutionContext` in production — configure thread pools appropriately - Prefer an effect library (`cats-effect IO`, `ZIO`) over raw `Future` for complex async pipelines - Use `Await.result` only in tests and main entry points — never in library/production code ### Pattern Matching - Always cover all cases in `match` expressions; use `case _ =>` only when truly exhaustive otherwise - Use guard clauses: `case user if user.isActive =>` - Prefer structural patterns over `isInstanceOf`/`asInstanceOf` casts ### Error Handling - Define a sealed error hierarchy per domain: `sealed trait UserError`, `case class NotFound(id: String) extends UserError` - Propagate errors through the return type — do not use exceptions for control flow - Log errors at the boundary (main, HTTP handler) — not deep in the call stack ### Style & Naming - Types, classes, traits: `PascalCase`; values, methods, packages: `camelCase` - Constants (companion object vals): `camelCase` in Scala (not `UPPER_SNAKE_CASE`) - Keep lines under 100 characters; break long `for`-comprehension generators onto separate lines - Use `{` on same line for blocks; one expression per line in `for`-comprehensions ### Anti-patterns - Do not use `null` — use `Option[T]` - Do not throw exceptions in `Future` — return failed futures with `Future.failed()` - Do not overuse type aliases — they reduce clarity without the safety of opaque types - Do not define too many implicit conversions — they make code hard to reason about

CLI

npx mindaxis apply scala-rules --target cursor --scope project

Используется в паках

Не используется ни в одном паке

← Правила