Top 45 Scala Interview Questions & Answers (2026)

Scala (Scalable Language) is a modern, multi-paradigm programming language that runs on the JVM. Created by Martin Odersky, it combines object-oriented programming and functional programming in a statically typed language. Key features: Type inference: the compiler deduces types without explicit annotations in most cases. Immutability: encourages immutable data with val (immutable) vs var (mutable). Higher-order functions: functions are first-class citizens. Pattern matching: powerful switch-like construct. Case classes: concise immutable data classes with built-in equality and pattern matching. Traits: similar to interfaces but with default implementations. Scala is heavily used in data engineering (Apache Spark is written in Scala), distributed systems (Akka), and functional programming communities.

In Scala, val declares an immutable binding — once assigned, the value cannot be reassigned. val x = 10; x = 20 // compile error. It is the preferred way to declare values in functional Scala, as it promotes immutability and thread safety. var declares a mutable variable that can be reassigned: var y = 10; y = 20 // ok. The Scala community strongly prefers val over var — using var is often a code smell. Note: val makes the binding immutable, not the object — a val list can still hold a mutable collection. For true immutability, use immutable collections with val.

Case classes in Scala are special classes optimized for immutable data modeling. Declaring case class Person(name: String, age: Int) automatically provides: Immutable fields accessible as person.name. toString: Person(Alice, 30). equals and hashCode: structural equality based on fields (not reference). copy(): create a modified copy: person.copy(age = 31). Companion object with apply: create without new: val p = Person("Alice", 30). Pattern matching support: p match { case Person(n, a) => println(n) }. Serializable by default. Case classes are the idiomatic way to represent domain objects, ADT (Algebraic Data Type) variants, and message types in Akka in Scala.

Pattern matching in Scala is a powerful control structure that matches a value against a series of patterns, executing code for the first matching case. It is like a supercharged switch statement. Basic usage: x match { case 1 => "one"; case 2 => "two"; case _ => "other" }. Match on types: animal match { case d: Dog => d.bark(); case c: Cat => c.meow() }. Match on case class fields: person match { case Person("Alice", age) => s"Alice is $age" }. Guards: case n if n > 0 => "positive". Destructure tuples: pair match { case (a, b) => a + b }. Pattern matching is used pervasively in Scala for option handling, error handling, and implementing interpreters. It is checked for exhaustiveness by the compiler when matching sealed hierarchies.

Option[T] is Scala's type-safe alternative to null references. It is a container with two subtypes: Some(value): contains a non-null value. None: represents the absence of a value. Instead of returning null (which causes NullPointerException), functions return Option: def findUser(id: Int): Option[User]. Working with Options: pattern match: opt match { case Some(v) => use(v); case None => default }. getOrElse: opt.getOrElse("default"). map: transform if present: opt.map(_.name). flatMap: chain optional operations. foreach: execute side effect if present. filter: convert Some to None if condition fails. Option makes the possibility of absence explicit in the type signature, forcing callers to handle both cases at compile time.

In Scala, List is an immutable, linked list. It is the idiomatic Scala collection for functional programming. Prepend is O(1) with ::. Random access is O(n). It implements scala.collection.immutable.List. Array is a mutable, fixed-size array backed by a Java array. Random access is O(1). It is mutable by default. Use Array when you need Java interop, performance-critical indexed access, or mutable collections. Use List for most functional Scala code. Scala also has Vector: an immutable indexed sequence with effectively O(1) random access and O(1) append — often a better choice than List when you need indexed access. ArrayBuffer and ListBuffer are mutable builder alternatives. The Scala collections library provides a rich hierarchy with consistent APIs across mutable and immutable variants.

Higher-order functions are functions that take other functions as parameters or return functions as results. In Scala, functions are first-class values. Common higher-order functions on collections: map: transform each element: List(1,2,3).map(_ * 2) // List(2,4,6). filter: keep elements matching a predicate: List(1,2,3,4).filter(_ % 2 == 0) // List(2,4). reduce/fold: combine elements: List(1,2,3).foldLeft(0)(_ + _) // 6. flatMap: map then flatten: List(1,2,3).flatMap(x => List(x, x*2)). Function as parameter: def applyTwice(f: Int => Int, x: Int) = f(f(x)). Returning a function: def multiplier(n: Int): Int => Int = x => x * n; val double = multiplier(2). Higher-order functions enable concise, expressive, and composable code.

Traits in Scala are similar to Java's interfaces but more powerful — they can have concrete method implementations, fields, and abstract members. Define a trait: trait Greeting { def greet(name: String): String = s"Hello, $name" }. A class can mix in multiple traits: class Person extends Human with Greeting with Serializable. Unlike Java interfaces (before Java 8), Scala traits could always have implementations. Traits resolve the diamond problem (multiple inheritance conflict) using linearization: the MRO (Method Resolution Order) is determined by the order traits are mixed in, right to left. Traits can also be used as mix-ins: new Animal with Logging. The combination of abstract and concrete members in traits enables the template method pattern cleanly. Traits are foundational to Scala's type system and component model.

Implicits in Scala (Scala 2) allow the compiler to automatically provide values, conversions, or parameters. Implicit parameters: def greet(name: String)(implicit lang: Language) — the compiler finds a matching implicit val in scope. Implicit conversions: automatically convert a type to another: implicit def intToString(i: Int): String = i.toString. Extension methods via implicit classes: implicit class RichInt(n: Int) { def doubled = n * 2 }; 5.doubled // 10. Implicits power Scala's type class pattern for ad-hoc polymorphism. They were powerful but criticized for being hard to understand and debug. Scala 3 (Dotty) replaced implicits with clearer constructs: given/using for implicit parameters and extension methods. Understanding implicits is essential for reading Scala 2 code and popular libraries like Cats and Akka.

The for-comprehension in Scala is syntactic sugar for chains of map, flatMap, withFilter, and foreach calls. It provides a clean syntax for working with monadic types. Basic: for { x <- List(1,2,3); y <- List(10,20) } yield x + y is desugared to List(1,2,3).flatMap(x => List(10,20).map(y => x + y)). With Option: for { user <- findUser(id); email <- user.email } yield sendEmail(email) — returns None if any step returns None. With Future: chain async operations cleanly. Guards: for { n <- nums if n > 0 } yield n * 2. The for-comprehension works with any type implementing map, flatMap, and withFilter — making it a general monad comprehension syntax used extensively in functional Scala.

Lazy evaluation in Scala defers computation until the value is actually needed. lazy val: evaluated once on first access: lazy val expensiveResult = computeExpensively(). The computation runs the first time expensiveResult is accessed, and the result is cached for subsequent accesses. Streams (LazyList in Scala 2.13+): lazily evaluated infinite sequences: val naturals = LazyList.from(1) — only elements that are actually requested are computed. Call-by-name parameters: def and(a: Boolean, b: => Boolean) — the b argument is evaluated only if needed. This enables short-circuit evaluation in custom functions. Lazy evaluation avoids unnecessary computation, enables working with infinite data structures, and can improve performance for rarely-used expensive values. The downside is less predictable evaluation timing, which can complicate debugging.

Scala has a powerful static type system that catches errors at compile time. Every expression has a type. Type inference: Scala's compiler infers types from context, so you usually don't need explicit annotations. val x = 42 — the compiler infers x: Int. val names = List("Alice", "Bob") — inferred as List[String]. Type hierarchy: Any is the root. AnyVal (Int, Double, Boolean, etc.) and AnyRef (all reference types). Nothing is the bottom type (subtype of all types) used for expressions that never return (throw, infinite loop). Null is a subtype of all reference types. Generics: class Box[T](value: T). Variance: covariant (+T), contravariant (-T), invariant. Scala's type system enables powerful abstractions while maintaining type safety.

A companion object is an object with the same name as a class, defined in the same file. It is Scala's way to have both instance methods and static-like methods. The class and its companion object have access to each other's private members. Common uses: Factory methods: object Person { def apply(name: String) = new Person(name) } — enables Person("Alice") without new. Constants and utilities related to the class. Implicit conversions for the class. Unapply method: enables pattern matching — object Email { def unapply(s: String) = ... }. Case classes get a companion object automatically with apply and unapply generated. Companion objects replace Java's static methods and fields — in Scala, there are no static members on classes.

A sealed trait or class can only be extended within the same source file. This restricts the class hierarchy and enables the compiler to perform exhaustiveness checking on pattern matches. Classic ADT (Algebraic Data Type) pattern: sealed trait Shape; case class Circle(radius: Double) extends Shape; case class Rectangle(w: Double, h: Double) extends Shape. When you pattern match on a sealed type: shape match { case Circle(r) => ... } — the compiler warns if you don't handle all subtypes. This prevents bugs where new subtypes are added but existing match expressions aren't updated. Sealed hierarchies are the idiomatic Scala way to model closed sets of possibilities — like Rust's enums or Haskell's ADTs. They are used extensively for representing domain states, errors, and events.

These three define different evaluation strategies. def: evaluated every time it is called. def random = math.random() — each call returns a different value. Used for methods and call-by-name semantics. val: evaluated once when the enclosing class/object is initialized. val fixed = math.random() — same value every time, computed at initialization. lazy val: evaluated once on first access, then cached. lazy val onDemand = expensiveComputation() — computed only if and when first accessed. Performance: def recomputes each access (could be desired for side effects or current state). val uses memory but avoids recomputation. lazy val is thread-safe (uses double-checked locking in the JVM) and avoids initialization-order issues. Prefer val for pure values, def for parameterized or stateful computations, lazy val for expensive one-time computations.

Either[L, R] represents a value of one of two possible types. By convention, Left contains an error/failure and Right contains a success value (mnemonic: "right" = correct). def parseAge(s: String): Either[String, Int]. Return: Right(42) or Left("Invalid number"). Working with Either: pattern match: result match { case Right(age) => ...; case Left(err) => ... }. map: transforms Right, passes Left through. flatMap: chains computations. getOrElse: extract Right or use default. Either is used for error handling when you want to carry error information (unlike Option which only indicates absence). It is right-biased in Scala 2.12+ — map and flatMap operate on the Right side, enabling for-comprehension chaining of fallible operations.

Tail recursion is a form of recursion where the recursive call is the last operation in the function. The Scala compiler optimizes tail-recursive functions into loops (tail call elimination), preventing stack overflow for deep recursion. Mark a function with @tailrec annotation to get a compile error if the compiler can't optimize it: @tailrec def factorial(n: Int, acc: Int = 1): Int = if (n <= 1) acc else factorial(n - 1, n * acc). Without @tailrec, a non-tail-recursive factorial with large input would throw a StackOverflowError. The @tailrec annotation is a safety net — it ensures you've written the function in tail-recursive form. When Scala 2 cannot optimize, you can use a trampoline from the Scalaz/Cats library. Tail recursion is the functional programming alternative to while loops.

In Scala, == calls the equals method, providing structural/value equality. For case classes and most standard types, it compares content: List(1,2) == List(1,2) // true, case class P(n: Int); P(1) == P(1) // true. It is null-safe: null == "hello" // false (no NullPointerException). eq checks reference equality — whether two references point to the exact same JVM object: val a = new StringBuilder; val b = a; a eq b // true. This is equivalent to Java's == for objects. ne is the negation of eq. Most Scala code uses == exclusively. Use eq only when you specifically need reference identity — for example, when interoperating with Java code or dealing with object internment.

A Scala Future[T] represents a computation that will complete asynchronously with either a value (Success(T)) or an error (Failure(Throwable)). Create: import scala.concurrent.ExecutionContext.Implicits.global; val f = Future { expensiveComputation() }. The computation runs in a thread pool. Combine: f.map(_ * 2), f.flatMap(x => Future { x + 1 }). Handle results: f.onComplete { case Success(v) => ...; case Failure(e) => ... }. Compose multiple: Future.sequence(List(f1, f2, f3)). For-comprehension: for { a <- futureA; b <- futureB } yield a + b. Futures require an implicit ExecutionContext that provides the thread pool. The default global context is suitable for most use cases. For production systems with back pressure requirements, consider using Akka or Cats Effect IO instead of raw Futures.

The type class pattern enables ad-hoc polymorphism — adding behavior to types without modifying them. It uses Scala's implicit system (Scala 2) or given/using (Scala 3). Define a type class trait: trait Serializable[A] { def serialize(a: A): String }. Provide instances: implicit val intSerializable: Serializable[Int] = new Serializable[Int] { def serialize(n: Int) = n.toString }. Use with an implicit parameter: def print[A](a: A)(implicit s: Serializable[A]) = println(s.serialize(a)). Context bound shorthand: def print[A: Serializable](a: A). Extension methods via implicit class: implicit class SerializableOps[A: Serializable](a: A) { def serialize = implicitly[Serializable[A]].serialize(a) }. This pattern is the foundation of Cats' Functor, Monad, Show, and other abstractions. It allows adding new behavior to existing types without inheritance.

Akka is a toolkit for building highly concurrent, distributed, and resilient systems on the JVM using the actor model. In the actor model: Actors are the fundamental unit of computation — lightweight, isolated objects that process messages from their mailbox sequentially. Message passing: actors communicate only by sending immutable messages — no shared state, no locks. Supervision hierarchy: every actor has a parent that handles its failures (let it crash philosophy). Location transparency: an actor reference (ActorRef) works the same whether the actor is in the same JVM or on a different machine. Akka Typed (current standard) uses type-safe message protocols: object Counter { sealed trait Command; case object Increment extends Command }. Actors are extremely lightweight — millions per JVM. Akka is used in finance, gaming, and telecom for systems requiring high concurrency with fault tolerance.

Apache Spark is a distributed data processing framework written in Scala, with APIs for Scala, Python (PySpark), Java, and R. Spark is the industry standard for large-scale data processing. The core abstraction: RDD (Resilient Distributed Dataset): fault-tolerant, parallelized collection. DataFrame/Dataset API (Spark SQL): structured data with schema, optimized by the Catalyst query optimizer. Dataset[T]: type-safe RDD with compile-time type checks — only available in Scala/Java. Transformations (lazy): map, filter, groupBy, join. Actions (triggers execution): count, collect, write. Scala is preferred for Spark development because it offers type-safe Dataset API, better IDE support, and performance advantages over Python for complex transformations. Many Spark internals are more accessible in Scala than through the Python wrapper.

Scala's concurrency model separates Future (read-only, result of async computation) from Promise (writable, fulfills a Future). Promise creates a Future and completes it manually: val p = Promise[Int](); val f = p.future; p.success(42) // or p.failure(exception). This is useful when wrapping callback-based APIs. ExecutionContext: defines where Future code runs. ExecutionContext.global uses a fork-join pool sized to available CPUs. Custom: ExecutionContext.fromExecutorService(Executors.newFixedThreadPool(8)). Combining Futures: Future.sequence runs in parallel and collects results. Future.traverse maps then sequences. zip: combine two futures. recover: handle failures. Blocking: Await.result(future, 5.seconds) blocks the calling thread — avoid in production async code. For purely functional async, consider Cats Effect IO or ZIO as more powerful alternatives.

A monad in Scala is a design pattern for sequencing computations with context. Any type with flatMap and unit (also called pure) that obeys monad laws is a monad. Common monads in Scala: Option: context = possible absence. Either: context = possible failure with error. Future: context = asynchronous computation. List: context = multiple values. IO (Cats Effect): context = side effects. The power of monads is that flatMap chains operations while threading the context automatically: findUser(id).flatMap(user => findOrder(user.orderId)).flatMap(order => sendEmail(order)). With for-comprehensions: for { user <- findUser(id); order <- findOrder(user.orderId); _ <- sendEmail(order) } yield (). Monads enable writing sequential-looking code that handles effects (None propagation, async, error handling) implicitly. The Cats library provides the Monad type class and many monad instances.

Cats (Category Theory Abstractions) is the most popular functional programming library for Scala, providing type class abstractions from category theory. Core type classes: Functor: map — transform values inside a context. Applicative: combine independent effectful values. Monad: flatMap — sequence dependent effectful computations. Foldable: fold structures. Traverse: sequence effects. Show: type-safe toString. Eq: type-safe equality. Semigroup/Monoid: combine values. Cats Effect: a separate library providing the IO monad for pure functional side-effect management and async programming. Cats provides Either utilities, Validated (accumulating errors), NonEmptyList, and much more. It is the foundation of many Scala ecosystems (http4s, Doobie, FS2). Understanding Cats is essential for senior-level Scala functional programming.

Scala 3 (codenamed Dotty) is a major revision of Scala with cleaner syntax and improved type system. Key changes: given/using: replace implicits with explicit, readable syntax. given intShow: Show[Int] with { def show(n: Int) = n.toString }. extension methods: extension (n: Int) def doubled = n * 2; 5.doubled. Enum: first-class ADTs: enum Shape { case Circle(r: Double); case Rectangle(w: Double, h: Double) }. Union types: def f(x: Int | String). Intersection types: A & B. Opaque type aliases: opaque type Email = String. Context functions: type Builder = (Config) ?=> Unit. Match types: type-level pattern matching. Indentation-based syntax (Python-like, optional). Scala 3 addresses many criticisms of Scala 2's implicit system and provides a cleaner foundation for both OOP and functional programming.

Play Framework is a high-performance, reactive web framework for Scala (and Java). It is built on Akka and uses a non-blocking, event-driven architecture. Key features: Routes file: declarative HTTP routing in a routes DSL: GET /users/:id controllers.UserController.getUser(id: Long). Actions: functions from Request to Result: def getUser(id: Long) = Action.async { implicit request => userService.find(id).map(u => Ok(Json.toJson(u))) }. Twirl templates: Scala-based HTML templating. JSON support: Play JSON library with Reads/Writes type classes. WebSockets and SSE: built-in support via Akka Streams. Forms: validated form binding. Database: integrates with Slick (FP ORM), Anorm, or any database library. Play is used in enterprise applications and startups building Scala web services. It competes with Akka HTTP for REST API development.

Slick (Scala Language-Integrated Connection Kit) is Scala's functional-relational mapper (FRM). It allows writing database queries in Scala instead of SQL strings, with type safety. Define table mapping: class Users(tag: Tag) extends Table[User](tag, "USERS") { def id = column[Long]("ID", O.PrimaryKey, O.AutoInc); def name = column[String]("NAME"); def * = (id, name).mapTo[User] }. Queries compile to SQL: val q = users.filter(_.name === "Alice").result. Run: db.run(q) returns a Future[Seq[User]]. Slick uses Quoted DSL — queries are Scala expressions that Slick translates to SQL. Type safety: the compiler catches type mismatches in queries. Slick supports PostgreSQL, MySQL, SQLite, H2, etc. While powerful, Slick has a steep learning curve. Doobie (using Cats Effect) is a simpler, more SQL-first alternative popular in the functional Scala community.

Type bounds constrain which types can be used as generic type parameters. Upper bound (<:): def process[T <: Animal](t: T) — T must be Animal or a subtype. Similar to Java's <? extends Animal>. Lower bound (>:): def widen[T >: Dog](list: List[T]) — T must be Dog or a supertype. Used in covariant collections' methods. Context bound: def show[T: Show](t: T) — shorthand for implicit show: Show[T]. Requires a type class instance for T. View bound (deprecated): T <% Ordered[T] — T must be implicitly convertible to Ordered[T]. Multiple bounds: T <: Animal with Serializable. Type bounds enable writing generic code that works only with types that have specific capabilities, maintaining type safety while allowing flexibility.

Variance describes the subtyping relationship between generic types when the type parameter's subtype relationship changes. Covariant (+T): if A is a subtype of B, then C[A] is a subtype of C[B]. Example: class List[+T] — a List[Dog] can be used where a List[Animal] is expected. Safe for read-only (producer) types. Contravariant (-T): if A is a subtype of B, then C[B] is a subtype of C[A] — reversed. Example: trait Function1[-T, +R] — a function accepting Animal can be used where a function accepting Dog is expected. Safe for write-only (consumer) types. Invariant (no annotation): no subtyping relationship. Array[Dog] is NOT a subtype of Array[Animal] (arrays are mutable, so covariance would be unsound). The Liskov Substitution Principle guides variance decisions: produce covariance for output, contravariance for input.

Try[T] is Scala's monadic wrapper for exception-throwing code. It has two subtypes: Success(value) and Failure(exception). Wrap exception-throwing code: val result: Try[Int] = Try { "abc".toInt } — returns Failure(NumberFormatException) instead of throwing. Works with map, flatMap, recover: result.recover { case _: NumberFormatException => 0 }. Chain: for { a <- Try(x.toInt); b <- Try(y.toInt) } yield a + b. Convert to Option: result.toOption. Convert to Either: result.toEither. Try vs Either: Try uses Throwable for errors (Java interop friendly). Either allows typed errors (recommended for domain logic). Try vs Future: Try is synchronous; Future is async but uses Try internally for its result. Use Try primarily when wrapping Java APIs or parsing potentially invalid input.

Both abstract classes and traits can have abstract and concrete members, but they differ in several ways. Constructor parameters: abstract classes can have constructor parameters: abstract class Animal(name: String); traits cannot (Scala 2), but Scala 3 traits can have parameters. Multiple inheritance: a class can extend only one abstract class but can mix in multiple traits. Java interoperability: abstract classes compile to Java abstract classes (easy for Java code to extend); traits with implementations compile to interfaces with default methods (Java 8+). Initialization order: class initialization is more predictable than trait initialization. When to use abstract class: when you need constructor parameters (Scala 2), when designing for Java inheritance, or when creating a primary base type with shared state. When to use trait: for mixins, type classes, and behavior composition across unrelated classes. Prefer traits for most abstractions — they are more flexible.

The cake pattern is a Scala dependency injection technique using traits and self-types, without a DI framework. Each component is defined as a trait with a self-type annotation declaring its dependencies: trait UserRepositoryComponent { val userRepository: UserRepository; trait UserRepository { def find(id: Long): Option[User] } }. Service component: trait UserServiceComponent { self: UserRepositoryComponent =>; val userService: UserService; class UserService { def getUser(id: Long) = userRepository.find(id) } }. Wire everything: object App extends UserServiceComponent with UserRepositoryComponent { val userRepository = new ProductionUserRepository; val userService = new UserService }. Benefits: type-safe DI without reflection; dependencies explicit in types; testable by substituting trait implementations. Downsides: verbose; complex wiring for large applications. Modern Scala projects often use MacWire (compile-time DI) or ZIO ZLayer for dependency injection instead of the cake pattern.

ZIO (Zero-Dependency Input/Output) is a functional effects library for Scala. The core type is ZIO[R, E, A] — an effect requiring environment R, failing with E, succeeding with A. Advantages: built-in dependency injection via ZLayer, typed error channel (not just Throwable), structured concurrency with Fiber, comprehensive standard library (Streams, Queue, Ref, STM). Cats Effect: uses IO[A] with untyped errors, more modular (separate libraries for streams, queues), wider ecosystem adoption. Comparison: ZIO is more batteries-included; Cats Effect is more composable with the broader ecosystem (fs2, http4s). Both support fiber-based structured concurrency with millions of lightweight fibers. ZIO's typed error channel allows exhaustive error handling at compile time — a significant advantage for domain modeling. Most new Scala functional projects choose one or the other as their effect system foundation.

FS2 is a purely functional streaming library for Scala built on Cats Effect. The core type is Stream[F[_], O] — a potentially infinite stream of values of type O, with effects in F. Key features: Resource safety: streams acquire/release resources safely even in the presence of errors or cancellation. Concurrency: stream.parEvalMap(n)(f) processes n elements concurrently while preserving order. Pull-based: consumers control the rate. Backpressure is automatic. Common operations: stream.through(pipe), merge, zip, chunks. Use case: reading a large file line by line without loading into memory: Files[IO].readUtf8Lines(path).filter(_.nonEmpty).evalMap(processLine).compile.drain. FS2 is used in http4s for HTTP streaming, Doobie for streaming database results, and general event processing pipelines. It is the Cats Effect ecosystem's answer to Akka Streams.

Shapeless is a type-level generic programming library for Scala, enabling polymorphic operations across arbitrary data structures. Core abstractions: HList: heterogeneous list with type-safe access — 1 :: "hello" :: true :: HNil has type Int :: String :: Boolean :: HNil. Generic: derive HList representation from case classes automatically. Poly: polymorphic functions that work across different types in an HList. Coproduct: type-safe discriminated union. Shapeless enables generic derivation of type class instances — for example, deriving Circe Encoder/Decoder for any case class automatically without writing boilerplate serialization code. Libraries like Circe, Magnolia (simpler alternative), and Monocle use Shapeless or similar techniques. In Scala 3, many Shapeless use cases are handled by the built-in Mirror mechanism and derives keyword, reducing Shapeless's necessity.

Software Transactional Memory (STM) provides composable, atomic operations on shared memory without locks. Scala has two STM implementations: scala-stm and ZIO STM. In ZIO STM: TRef is a transactional reference. Compose atomic operations: val transfer = for { aBalance <- accountA.get; bBalance <- accountB.get; _ <- accountA.set(aBalance - amount); _ <- accountB.set(bBalance + amount) } yield (). Execute: transfer.commit. The runtime automatically retries the transaction if any read value has changed (optimistic concurrency). If impossible to complete, use STM.retry to block until conditions are met. STM eliminates deadlocks (no locks), livelocks, and priority inversion — common problems with manual synchronization. It is composable — multiple transactional operations combine into one atomic transaction. ZIO STM also provides TQueue, TSemaphore, and TMap for concurrent data structures.

Path-dependent types are types that depend on a specific object instance path. In Scala, a type member or inner class creates a path-dependent type. Example: class Database { type Record; def read(): Record = ??? }. Two different Database instances have different Record types: db1.Record is a different type from db2.Record even though both are called Record. This enables powerful type-safety guarantees — a record from database1 cannot be passed to a function expecting database2's records. Dependent method types: def process(db: Database)(r: db.Record): Unit. Abstract type members in traits with path-dependent types implement a form of phantom types for API safety. Use in type-safe collections: a typed cursor or session can have a type member for the row type, preventing mixing rows from different result sets. Path-dependent types are one of Scala's most distinctive advanced features, encoding constraints at the type level that would require runtime checks in other languages.

Scala offers several concurrency models beyond Java's raw threads and locks. Futures: the simplest async model — callbacks on thread pool tasks. Better than Java callbacks but not purely functional. Akka Actors: message-passing concurrency with shared-nothing isolation. Avoids synchronization entirely for most patterns. Cats Effect/ZIO Fibers: functional green threads — millions of fibers multiplexed over a small thread pool. Automatic cancellation, resource safety, and structured concurrency (parent fibers manage child lifecycle). Parallel collections: list.par.map(f) — easy but crude parallelism for CPU-bound tasks. Java Virtual Threads (Loom): available in Scala on JDK 21+ — the JVM now natively supports lightweight threads. Compared to Java, Scala's functional effect systems (Cats Effect, ZIO) provide structured concurrency guarantees that Java lacks — leaked fibers, resource leaks on cancellation, and error propagation are handled automatically by the runtime rather than being developer responsibilities.

Higher-kinded types (HKT) are type constructors that take other type constructors as parameters — types of types. A regular generic like List[A] has kind * -> * (takes one concrete type, returns a concrete type). An HKT parameter is F[_] — F is a type constructor of kind * -> *. Example: trait Functor[F[_]] { def map[A, B](fa: F[A])(f: A => B): F[B] }. This Functor type class works for any F that is a type constructor — List, Option, Future, Either[E, ?], etc. Implement: implicit val listFunctor: Functor[List] = new Functor[List] { def map[A, B](fa: List[A])(f: A => B) = fa.map(f) }. HKTs enable writing code that is polymorphic over the container type — the same function works for List[Int], Option[Int], Future[Int]. This is the foundation of the Cats and Scalaz functional programming libraries. HKTs are one of Scala's key advantages over Java for functional programming.

Opaque type aliases (Scala 3) create new types that are type-safe wrappers at compile time but have zero runtime overhead (unlike wrapper classes). Define: object Types { opaque type Email = String; object Email { def apply(s: String): Email = s } }. Outside the defining scope, Email is distinct from String — you cannot pass a raw String where an Email is expected. Inside the defining scope, Email is just String, so all String operations are available. This solves the "type alias loses type safety" problem without the boxing overhead of a wrapper class. Use cases: preventing mixing up IDs of different types (UserId vs ProductId), ensuring strings pass validation before use (Email, NonEmptyString). In Scala 2, this was approximated with value classes (extends AnyVal) but with limitations around equality and Null. Opaque types are the preferred Scala 3 approach for zero-cost type safety.

Algebraic Data Types (ADTs) are a type system feature for modeling data with a fixed set of cases. Scala implements ADTs using sealed traits + case classes: sealed trait Expr; case class Num(n: Int) extends Expr; case class Add(l: Expr, r: Expr) extends Expr; case class Mul(l: Expr, r: Expr) extends Expr. Pattern matching deconstructs ADTs: def eval(e: Expr): Int = e match { case Num(n) => n; case Add(l, r) => eval(l) + eval(r); case Mul(l, r) => eval(l) * eval(r) }. The sealed keyword enables exhaustiveness checking — the compiler warns if a case is unhandled. This is the expression problem solved for closed sets of types. In Scala 3, the enum keyword provides first-class ADT support: enum Expr { case Num(n: Int); case Add(l: Expr, r: Expr) }. ADTs + pattern matching enable building interpreters, domain models, and state machines that are correct by construction.