scala-option-either

Files (1)

• SKILL.md

SKILL.md (first lines)

# Scala Option, Either, and Try for Python Developers

## Core Concept: Functional Error Handling

Python uses `None` and `Optional[T]` to represent absence. Scala uses types that can be pattern-matched:

| Python | Scala | Purpose |
|--------|-------|---------|
| `None` | `None` (in Option) | Represents absence |
| `Optional[T]` / `T \| None` | `Option[T]` | Represents presence or absence |
| Exception handling | `Either[Err, Success]` | Represents error or success |
| Exception handling | `Try[T]` | Like Either but for exceptions |

## Option[T] - Replace None/Optional

### Python Pattern
```python
def safe_divide(a: float, b: float) -> float | None:
    if b == 0:
        return None
    return a / b

result = safe_divide(10, 2)
if result is not None:
    print(f"Result: {result}")
else:
    print("Division by zero")
```

### Scala Pattern
```scala
def safeDivide(a: Double, b: Double): Option[Double] =
  if (b == 0) None else Some(a / b)

// Pattern matching
safeDivide(10, 2) match {
  case Some(result) => println(s"Result: $result")
  case None => println("Division by zero")
}

// Or functional style
safeDivide(10, 2).foreach(result => println(s"Result: $result"))
```

### Key Option Methods

```scala
val opt: Option[Int] = Some(42)

// Extraction
opt.get        // 42 (throws if None - avoid!)
opt.getOrElse(0)  // 42
opt.orElse(Some(0))  // Some(42)

// Transformation
opt.map(_ * 2)    // Some(84)
opt.flatMap(x => Some(x * 2))  // Some(84)
opt.filter(_ > 40)  // Some(42)

// Iteration
for (v <- opt) println(v)  // prints 42

// Checking
opt.isDefined   // true
opt.isEmpty     // false
```

## Either[L, R] - Represent Success or Failure

Either is more powerful than Option - it carries error information.

### Python Pattern
```python
def validate_age(age: int) -> tuple[bool, str | None]:
    if age < 0:
        return False, "Age cannot be negative"
    if age > 150:
        return False, "Age seems unrealistic"
    return True, None

success, error = validate_age(-5)
if not success:
    print(f"Error: {error}")
```

### Scala Pattern
```scala
def validateAge(age: Int): Either[String, Int] =
  if (age < 0) Left("Age cannot be negative")
  else if (age > 150) Left("Age seems unrealistic")
  else Right(age)

// Pattern matching
validateAge(-5) match {
  case Left(error) => println(s"Error: $error")
  case Right(age) => println(s"Valid age: $age")
}

// Functional style
validateAge(25).map(age => age + 1).foreach(println)
```

### Either is Right-biased (map operates on Right)

```scala
val result: Either[String, Int] = Right(5)

result.map(_ * 2)  // Right(10)
result.flatMap(x => Right(x * 2))  // Right(10)
result.leftMap(s => s.toUpperCase)  // Left side transformation
result.fold(
  error => println(s"Error: $error"),  // Left side
  value => println(s"Success: $value")  // Right side
)
```

## Try[T] - For Exception Handling

Try captures exceptions instead of throwing them.

From cxcscmu/SkillLearnBench, MIT.

More from cxcscmu/SkillLearnBench