Scala Tutorial

Basics

Control Statements

OOP Concepts

Parameterized - Type

Exceptions

Scala Annotation

Methods

String

Scala Packages

Scala Trait

Collections

Scala Options

Miscellaneous Topics

Scala | Methods to Call Option

Option in Scala represents an optional value: it can either contain a value (Some) or not (None). Option is used to handle cases without resorting to null references and thus helps in writing safer, more concise, and less error-prone code.

Here are some commonly used methods that you can call on an Option:

1. Basic Operations:

isEmpty: Checks if the Option is None.

val opt = Some(42)
println(opt.isEmpty)  // false

isDefined: Checks if the Option is Some.
```
println(opt.isDefined)  // true
```

getOrElse: Returns the value if Some, or a default value if None.

val noneOpt: Option[Int] = None
println(noneOpt.getOrElse(0))  // 0

2. Transforming:

map: Transforms the value inside Some using a function. No operation if None.
```
val stringOpt = opt.map(_.toString)  // Some("42")
```

flatMap: Transforms the value inside Some into another Option. No operation if None.

def toOptionString(i: Int): Option[String] = if (i > 0) Some(i.toString) else None
println(opt.flatMap(toOptionString))  // Some("42")

filter: Returns the same Option if it satisfies a predicate, otherwise returns None.
```
println(opt.filter(_ > 50))  // None
```

3. Side Effects:

foreach: Performs a side-effecting operation if the Option is Some.
```
opt.foreach(println)  // prints 42
```

4. Chaining:

orElse: Returns the first Option if it's Some, otherwise returns the second one.
```
println(noneOpt.orElse(opt))  // Some(42)
```

5. Pattern Matching:

You can also use pattern matching with Option:

opt match {
  case Some(value) => println(s"Got value: $value")
  case None => println("No value present")
}

6. Conversion:

toList: Converts the Option to a List with zero or one element.

println(opt.toList)  // List(42)
println(noneOpt.toList)  // List()

toRight, toLeft: Converts the Option to an Either. If the Option is Some, it becomes the right or left side of the Either respectively, otherwise the provided default is used.
```
println(opt.toRight("Error"))  // Right(42)
println(noneOpt.toRight("Error"))  // Left("Error")
```

These are just some of the primary methods available on Option. The goal is always to avoid explicit null checks and instead operate in a more functional manner, allowing operations to gracefully handle the absence of a value.

Common Methods for Working with Scala Option:

Common methods include isDefined, isEmpty, and getOrElse.

val maybeValue: Option[Int] = Some(42)

val isDefined: Boolean = maybeValue.isDefined
val isEmpty: Boolean = maybeValue.isEmpty
val valueOrDefault: Int = maybeValue.getOrElse(0)

Mapping and FlatMapping over Option in Scala:

Use map and flatMap for transforming and chaining Option values.

val maybeValue: Option[Int] = Some(42)

val doubledValue: Option[Int] = maybeValue.map(value => value * 2)
val flattenedOption: Option[Int] = maybeValue.flatMap(value => Some(value * 2))

Filtering and Collecting with Option in Scala:

Use filter to retain or discard Option values based on a condition.

val maybeValue: Option[Int] = Some(42)

val filteredOption: Option[Int] = maybeValue.filter(value => value > 40)

Using getOrElse() with Scala Option:

Retrieve the value or provide a default value.

val maybeValue: Option[Int] = Some(42)

val valueOrDefault: Int = maybeValue.getOrElse(0)

Option Pattern Matching in Scala:

Use pattern matching to handle both Some and None cases.

val maybeValue: Option[Int] = Some(42)

val result: String = maybeValue match {
  case Some(value) => s"Value is $value"
  case None => "No value"
}

Converting Option to Other Types in Scala:

Convert Option to List, Either, or other types.

val maybeValue: Option[Int] = Some(42)

val list: List[Int] = maybeValue.toList
val either: Either[String, Int] = maybeValue.toRight("No value")

Handling None and Some in Scala Option:

Explicitly handle None and Some cases.

val maybeValue: Option[Int] = Some(42)

maybeValue.foreach(value => println(s"Value is $value"))

val result: String = maybeValue.fold("No value")(value => s"Value is $value")

Chaining Option Methods in Scala:

Chain multiple Option methods for concise and expressive code.

val maybeValue: Option[Int] = Some(42)

val result: Option[String] =
  maybeValue.map(_ * 2).filter(_ > 80).map(value => s"Result: $value")