Option[F[ShoppingCart]] 到 F[Option[ShoppingCart]] 之间的转换

Question

我在 Scala 中有以下代数（我使用的是无标记最终模式）：

trait ShoppingCarts[F[_]] {
  def create(id: String): F[Unit]
  def find(id: String): F[Option[ShoppingCart]]
  def add(sc: ShoppingCart, product: Product): F[ShoppingCart]
}

使用上面的代数，我创建了以下程序：

def createAndToCart[F[_] : Monad : ShoppingCarts](product: Product, cartId: String): F[Option[ShoppingCart]] =
  for {
    _ <- ShoppingCarts[F].create(cartId)
    maybeSc <- ShoppingCarts[F].find(cartId)
    maybeNewScF = maybeSc.map(sc => ShoppingCarts[F].add(sc, product))
    maybeNewSc <- maybeNewScF match {
      case Some(d) => d.map(s1 => Option.apply(s1))
      case _ => Monad[F].pure(Option.empty[ShoppingCart])
    }
  } yield maybeNewSc

我不太喜欢 for-comprehension 构造中将Option[F[ShoppingCart]] 转换为F[Option[ShoppingCart]] 的代码。我确信我可以做得更好，但我不知道如何改进它。

我正在使用猫。

Answer 1

您正在寻找traverse 和sequence。这些函数所做的是“切换”效果的顺序，因此如果 G 有一个 Applicative 的实例，它们就能够将 G[F[A]] 更改为 F[G[A]]。 Option 在范围内有这样一个实例，所以你可以使用它。

traverse 带有额外的映射功能，但如果你只是想“切换”效果，那么sequence 将是一种方式：

for {
      _ <- ShoppingCarts[F].create(cartId)
      maybeSc <- ShoppingCarts[F].find(cartId)
      maybeNewSc <- maybeSc.map(sc => ShoppingCarts[F].add(sc, product)).sequence //here you need to use sequence
} yield maybeNewSc

或者您可以将map 和sequence 与traverse 合并为一个步骤：

for {
      _ <- ShoppingCarts[F].create(cartId)
      maybeSc <- ShoppingCarts[F].find(cartId)
      maybeNewSc <- maybeSc.traverse(sc => ShoppingCarts[F].add(sc, product))
} yield maybeNewSc

您可以在cats docs 中阅读有关sequence 和traverse 的更多信息。

我建议您检查的另一件事是 monad transformers，因为它们使处理像 F[Option[A]] 这样的嵌套 monad 堆栈变得容易得多。