📖 About Scala
Scala is a modern multi-paradigm programming language designed to express common programming patterns in a concise, elegant, and type-safe way. It seamlessly integrates features of object-oriented and functional languages, running on the JVM and interoperating with Java.
🎯 Best For
- Big Data processing (Spark, Kafka)
- Backend services and APIs
- Distributed systems
- Functional programming on JVM
- Data engineering pipelines
🔧 Key Features
- Functional and OO paradigms
- Advanced type system
- Pattern matching
- Immutability by default
- Actor model (Akka)
- Seamless Java interoperability
🛠️ Development Tools
Build
sbt compile
Test
sbt test
Coverage
sbt coverage test
Run
sbt run
📄 Package Contents (7 files)
AGENTS_RULES.md
Complete AI agent rules (universal)
- SCALA-specific best practices
- TDD workflow (Red-Green-Refactor)
- DDD principles and patterns
- Git workflow and commit format
- Code quality principles
.cursorrules
Quick reference for Cursor IDE
- Essential rules summary
- Links to full documentation
- Optimized for quick loading
.gitignore
Git exclusions
- SCALA-specific patterns
- Build artifacts
- IDE configuration files
- Dependency directories
AGENTS.md
Quick reference guide
- Common patterns
- Best practices summary
- Quick troubleshooting
README.md
Project template with examples
- Setup instructions
- Sample code and structure
- Testing examples
- Build and run commands
CODE_QUALITY_PRINCIPLES.md
Quality principles and best practices
- Avoid default values (fail-fast)
- Consistency across code paths
- Extract reusable functions
- SCALA-specific examples
CONTRIBUTING.md
Contribution guidelines
- TDD workflow (Red-Green-Refactor)
- Git commit format
- Code review process
- Testing requirements (90% coverage)
💻 Code Examples
Case Classes and Pattern Matching
sealed trait Result[+T]
case class Success[T](value: T) extends Result[T]
case class Failure(error: String) extends Result[Nothing]
def processResult[T](result: Result[T]): Unit = result match {
case Success(value) => println(s"Success: $value")
case Failure(error) => println(s"Error: $error")
}
Functional Programming
case class User(id: String, name: String, age: Int)
val users = List(
User("1", "John", 30),
User("2", "Jane", 25)
)
val adults = users
.filter(_.age >= 18)
.map(u => u.copy(name = u.name.toUpperCase))
.sortBy(_.age)
For Comprehensions
def findUser(id: String): Option[User] = ???
def findOrders(userId: String): Option[List[Order]] = ???
val result = for {
user <- findUser("123")
orders <- findOrders(user.id)
if orders.nonEmpty
} yield (user, orders)