如何在理解中对多个事物进行模式匹配

Question

I have a for comprehension that has 7 things inside it. The 7 things are running DB queries in Slick and might not return any data. When they don't return any data, I want default values put it. I can do the following if there was only 1 thing but how do I do this when I have 7 ?

case class MyType(one: String, two: Int, three: Int)

//What I could do for 1 thing
for {
  thing1: Option[MyType] <- repo.queryForThing1()
}
yield {
  thing1 match {
   case Some(t) => MyOtherType(Seq(t))
   case None => MyOtherType(Seq(MyType("thing1", 0, 0)))
  }
}

//What do I do for when I have 7 things??
for {
  thing1: Option[MyType] <- repo.queryForThing1()
  thing2: Option[MyType] <- repo.queryForThing2()
  thing3: Option[MyType] <- repo.queryForThing3()
  thing4: Option[MyType] <- repo.queryForThing4()
  thing5: Option[MyType] <- repo.queryForThing5()
  thing6: Option[MyType] <- repo.queryForThing6()
  thing7: Option[MyType] <- repo.queryForThing7()
}
yield {
  thing1 match {
   case Some(t) => MyOtherType(Seq(t))
   case None => MyOtherType(Seq(MyType("thing1", 0, 0)))
  }
}

Question

How can I pattern match for 7 things? Each one will have default value of thing<number> when it is None

Answer 1

Try this! but this is not a sexy code :D

for {
  thing1: Option[String] <- repo.queryForThing1()
  thing2: Option[String] <- repo.queryForThing2()
  thing3: Option[String] <- repo.queryForThing3()
  thing4: Option[String] <- repo.queryForThing4()
  thing5: Option[String] <- repo.queryForThing5()
  thing6: Option[String] <- repo.queryForThing6()
  thing7: Option[String] <- repo.queryForThing7()
} yield (thing1, thing2, thing3, thing4, thing5, thing6, thing7) match {
  case (a, b, c, c, d, e, f) => ( 
    a.getOrElse("default"),
    b.getOrElse("default"),
    c.getOrElse("default"),
    c.getOrElse("default"),
    d.getOrElse("default"),
    e.getOrElse("default"),
    f.getOrElse("default")
  )
}

Answer 2

Since MyOtherType takes a sequence you could create a sequence of queries and map that to the result:

Future.sequence(List(
  repo.queryForThing1().map(_.getOrElse(MyType("1", 1, 7))),
  repo.queryForThing2().map(_.getOrElse(MyType("2", 2, 6))),
  repo.queryForThing3().map(_.getOrElse(MyType("3", 3, 5))),
  repo.queryForThing4().map(_.getOrElse(MyType("4", 4, 4))),
  repo.queryForThing5().map(_.getOrElse(MyType("5", 5, 3))),
  repo.queryForThing6().map(_.getOrElse(MyType("6", 6, 2))),
  repo.queryForThing7().map(_.getOrElse(MyType("7", 7, 1)))
)).map(MyOtherType)

However this is different from the original code in that it performs all the queries at the same time rather than sequentially, and won't stop early if one of the queries fails.

The fact that you have seven different queries and seven different defaults means that you are going to have to write them out individually so it is always going to look a little messy.

---

For reference, here is a version that performs the queries in series rather than in parallel, but it isn't pretty!

val queries =
  List(
    repo.queryForThing1 _ -> MyType("1", 1, 7),
    repo.queryForThing2 _ -> MyType("2", 2, 6),
    repo.queryForThing3 _ -> MyType("3", 3, 5),
    repo.queryForThing4 _ -> MyType("4", 4, 4),
    repo.queryForThing5 _ -> MyType("5", 5, 3),
    repo.queryForThing6 _ -> MyType("6", 6, 2),
    repo.queryForThing7 _ -> MyType("7", 7, 1)
  )

queries.foldLeft(Future.successful(Vector.empty[MyType])) {
  case (prev, (query, default)) =>
    prev.flatMap(p => query().map(q => p :+ q.getOrElse(default)))
}.map(MyOtherType)