What is Scala?

// Class definition
class Person(val name: String, val age: Int) {
  def greet(): String = s"Hello, I'm $name and I'm $age years old"
  
  def isAdult: Boolean = age >= 18
}

// Object (singleton)
object Person {
  def apply(name: String, age: Int): Person = new Person(name, age)
}

// Usage
val person = Person("Alice", 25)
println(person.greet())  // Hello, I'm Alice and I'm 25 years old
println(person.isAdult)  // true

// Immutable collections
val numbers = List(1, 2, 3, 4, 5)
val doubled = numbers.map(_ * 2)  // List(2, 4, 6, 8, 10)
val evens = numbers.filter(_ % 2 == 0)  // List(2, 4)
val sum = numbers.reduce(_ + _)  // 15

// Pattern matching
def describe(x: Any): String = x match {
  case s: String => s"String with length ${s.length}"
  case i: Int => s"Integer: $i"
  case true => "Boolean: true"
  case false => "Boolean: false"
  case _ => "Unknown type"
}

// Higher-order functions
def processList[A](list: List[A])(f: A => String): List[String] = {
  list.map(f)
}

val result = processList(List(1, 2, 3)) { x => s"Number: $x" }

// Type inference
val name = "Alice"           // String
val age = 25                // Int
val height = 5.6            // Double
val isStudent = true        // Boolean

// Function type inference
def add(a: Int, b: Int) = a + b  // Return type inferred as Int

// Generic type inference
def first[A](list: List[A]): Option[A] = list.headOption

// Case class
case class User(id: Int, name: String, email: String)

// Automatic generation of:
// - equals() and hashCode()
// - toString()
// - copy() method
// - companion object with apply()

val user1 = User(1, "Alice", "alice@example.com")
val user2 = user1.copy(name = "Alice Smith")

println(user1)  // User(1,Alice,alice@example.com)
println(user1 == user2)  // false

// Pattern matching with case classes
def processUser(user: User): String = user match {
  case User(id, name, email) if email.contains("@") => s"Valid user: $name"
  case User(id, name, _) => s"Invalid email for user: $name"
}

// Pattern matching with sealed traits
sealed trait Shape
case class Circle(radius: Double) extends Shape
case class Rectangle(width: Double, height: Double) extends Shape

def area(shape: Shape): Double = shape match {
  case Circle(r) => math.Pi * r * r
  case Rectangle(w, h) => w * h
}

// Implicit conversion
implicit def intToString(i: Int): String = i.toString

val number: Int = 42
val text: String = number  // Automatically converted

// Implicit parameters
def greet(name: String)(implicit greeting: String): String = {
  s"$greeting, $name!"
}

implicit val defaultGreeting = "Hello"
println(greet("Alice"))  // Hello, Alice!

// Type classes with implicits
trait Show[A] {
  def show(a: A): String
}

implicit val showInt: Show[Int] = new Show[Int] {
  def show(a: Int): String = s"Integer: $a"
}

def printValue[A](a: A)(implicit show: Show[A]): Unit = {
  println(show.show(a))
}

import akka.actor._

// Actor definition
class Greeter extends Actor {
  def receive = {
    case name: String => sender() ! s"Hello, $name!"
    case _ => sender() ! "Unknown message"
  }
}

// Actor system
val system = ActorSystem("GreeterSystem")
val greeter = system.actorOf(Props[Greeter], "greeter")

// Send message
greeter ! "Alice"

import play.api.mvc._
import play.api.routing._

// Controller
class HomeController extends Controller {
  def index() = Action { implicit request =>
    Ok("Hello from Scala Play!")
  }
  
  def user(name: String) = Action { implicit request =>
    Ok(s"Hello, $name!")
  }
}

// Routes
GET     /                           controllers.HomeController.index()
GET     /user/:name                 controllers.HomeController.user(name: String)

import org.apache.spark.sql.SparkSession

// Create Spark session
val spark = SparkSession.builder()
  .appName("Scala Spark Example")
  .getOrCreate()

// Read data
val df = spark.read.csv("data.csv")

// Transform data
val result = df.filter(col("age") > 18)
  .groupBy("city")
  .count()

// Show results
result.show()

# Install Scala
# Using Coursier (recommended)
curl -fL https://github.com/coursier/coursier/releases/latest/download/cs-x86_64-apple-darwin.gz | gzip -d > cs
chmod +x cs
./cs setup

# Using Homebrew (macOS)
brew install scala

# Using SDKMAN
curl -s "https://get.sdkman.io" | bash
source "$HOME/.sdkman/bin/sdkman-init.sh"
sdk install scala

// hello.scala
object HelloWorld {
  def main(args: Array[String]): Unit = {
    println("Hello, Scala World!")
  }
}

// Run with: scala hello.scala

// build.sbt
name := "MyScalaProject"
version := "1.0"
scalaVersion := "2.13.8"

libraryDependencies ++= Seq(
  "org.scalatest" %% "scalatest" % "3.2.9" % Test
)