Good — I'll show both alternatives.

For-comprehension (using Either via Right-biased Either in Scala 2.12+/2.13/Scala 3):

// Using toRight then for-comprehension (Right-biased Either behaves like a monad for Right side)
val opt1: Option[Int] = Some(10)
val either1: Either[String, Int] = opt1.toRight("no value")

val result = for {
  v <- either1            // v: Int if Right, short-circuits if Left
} yield v * 2              // result: Either[String, Int]
// result == Right(20)

If the Option might be empty:

val opt0: Option[Int] = None
val either0 = opt0.toRight("no value")
// result from for { v <- either0 } yield v * 2  => Left("no value")

Pattern matching alternative (explicit and clear):

def optionToEither(opt: Option[Int]): Either[String, Int] = opt match {
  case Some(v) => Right(v)
  case None    => Left("no value")
}

// Use pattern matching to handle result
optionToEither(Some(5)) match {
  case Right(v) => println(s"Got $v")
  case Left(err) => println(s"Error: $err")
}

Notes: for-comprehensions are convenient when chaining multiple computations that return Either; they rely on Either being right-biased (common in modern Scala). Pattern matching is the most explicit and sometimes clearer for control flow or when you need to handle Left/Right separately.

Short exercise

Which approach is best when you need to chain multiple computations that may fail and stop on the first error?

Learning: Scala