FlatMap or For-comprehension on a Nested Options Monad - scala

Question

Can someone help me convert this to a flatMap or for-comprehension? I know how to handle more trivial scenarios of nested option.
case class Person(name: String, signficantOther: Option[String])
val nightclubPeoples : Option[Seq[Person]] = ???
def significantOthers(nightClubPeoples : Option[Seq[Person]]) : List[String] = {
nightclubPeoples match {
case Some(x) => x map { y : Person =>
y.significantOther match {
case Some(z) => z
case None => "No Signficant Other"
}
}.toList
case None => Nil
}
}

Answer 1

I think I would use a fold:
nightclubPeoples.fold[List[String]](Nil)(_.flatMap(_.signficantOther)(collection.breakOut))

Answer 2

Sascha Kolberg's answer is a, as I think, better solution(just omit the case when signficantOther is empty, i.e "No Signficant Other" will not in the result List) for your question, however since
you demand "convert this to a flatMap or for-comprehension", so the code is as follows.
case class Person(name: String, signficantOther: Option[String])
val nightClubPeopleOpt : Option[Seq[Person]] = Some(Person("name", Some("1")) :: Person("name1", None) :: Nil)
def significantOthers(nightClubPeopleOpt : Option[Seq[Person]]) = {
for {
nightClubPeople <- nightClubPeopleOpt
} yield {
// scenario 1
// if signficantOther is empty, then it should be ignored
// Answer -> List(1)
nightClubPeople.flatMap(_.signficantOther).toList
// scenario 2
// if signficantOther is empty, then we use the default "No Signficant Other"
// Answer -> List(1, No Signficant Other)
nightClubPeople.map { nightClubPerson =>
nightClubPerson.signficantOther.getOrElse("No Signficant Other")
}.toList
}
}.getOrElse(Nil)
println(significantOthers(nightClubPeopleOpt))

Answer 3

Here you go:
nightclubPeoples.toSeq.flatMap(_.map(_.signficantOther.getOrElse("No Signficant Other")))

Answer 4

A relatively readable direct transformation would be:
def significantOthers(nightClubPeoples : Option[Seq[Person]]): List[String] = {
for {
nightClubPeoples <- nightClubPeoples.toList
person <- nightClubPeoples
} yield person.significantOther.getOrElse("No Significant Other")
}
The thing to note here is that we convert nightClubPeoples to a list up front, allowing us to use a for comprehension all along.
However, I doubt you really want to have "No Significant Other" appear in your list when signficantOther is None. Rather, it should be ignored, which would give the even simpler:
def significantOthers(nightClubPeoples : Option[Seq[Person]]): List[String] = {
for {
nightClubPeoples <- nightClubPeoples.toList
person <- nightClubPeoples
significantOther <- person.significantOther
} yield significantOther
}