Scala Best Practices

Idiomatic Scala favors val over var and immutable collections as the default, reserving mutation for tightly scoped local optimizations where performance genuinely demands it. Functions should be small, pure, and total, meaning they return a real value for every input rather than throwing or returning null, because pure functions are trivially testable and safely reusable across concurrent code without synchronization. Expression-oriented style, treating if, match, and blocks as values that return a result, tends to produce more compact and self-documenting code than the statement-heavy style carried over from Java habits.

Reach for Option[A] when a value may simply be absent, like a missing map key, Try[A] when wrapping a Java API that throws exceptions, like Integer.parseInt, and Either[E, A] when you need to communicate why an operation failed with a typed error channel, conventionally putting the error on the Left and the success value on the Right. Idiomatic Scala avoids throwing exceptions across public API boundaries because callers can't see a thrown exception in a method's type signature the way they can see Either[ValidationError, User], and chaining these types together with for-comprehensions, which desugar to flatMap/map, keeps the happy path readable while short-circuiting on the first failure.

Model domain data as sealed trait hierarchies of case classes and case objects, algebraic data types, so that match expressions over them can be exhaustive — the compiler emits a warning if you forget a case, catching a whole class of bugs Java's non-exhaustive switch cannot. Prefer .collect { case Some(x) => x } over separate .filter and .map calls when filtering and transforming in one pattern match, and prefer foldLeft/map/flatMap over manual var accumulators with for loops, since the combinator versions are both more concise and immune to off-by-one mutation bugs. Avoid asInstanceOf and isInstanceOf outside of interop code since they defeat the type system's purpose, and remember that Scala's List is a singly linked list optimized for head access, so prefer Vector or ArrayBuffer when you need fast random access or appends.

Run scalafmt for consistent formatting and scalafix for automated lint fixes, unused imports, deprecated API usage, as part of CI, and keep build.sbt module boundaries aligned with actual dependency direction so compile times stay fast — sbt's incremental compiler only recompiles what changed, but a tangled module graph forces wide recompilation on small edits. Minimize implicit/given parameters to the cases that genuinely need typeclass-style polymorphism, like Ordering[T] or Encoder[T] for JSON, because overused implicits make code hard to trace; in Scala 3, prefer explicit given/using clauses and extension methods over Scala 2's more implicit-heavy conversions. For hot-path performance, mark simple self-recursive functions @tailrec so the compiler turns them into a loop instead of growing the call stack, and be aware that boxing of primitives inside generic collections can matter in tight numeric loops.