斯卡拉，猫。有人可以解释什么是 `F` 以及它从何而来？

Question

我想使用来自该存储库的 cats-saga:https://github.com/VladKopanev/cats-saga

但是我卡在了 OrderSagaCoordinator.scala L160 的那段代码上:

def apply[F[_]: Sync: Concurrent: Timer: Sleep: Parallel](
    paymentServiceClient: PaymentServiceClient[F],
    loyaltyPointsServiceClient: LoyaltyPointsServiceClient[F],
    orderServiceClient: OrderServiceClient[F],
    sagaLogDao: SagaLogDao[F],
    maxRequestTimeout: Int
  ): F[OrderSagaCoordinatorImpl[F]] =

什么是F，它是从哪里来的，谁能解释一下那段代码？

谢谢

编辑:我知道泛型是什么。然而，在那种情况下，apply 方法在未指定具体类型的情况下被调用，而且我看不到它的来源。

(for {
      paymentService <- PaymentServiceClientStub(randomUtil, clientMaxReqTimeout, flakyClient)
      loyaltyPoints  <- LoyaltyPointsServiceClientStub(randomUtil, clientMaxReqTimeout, flakyClient)
      orderService   <- OrderServiceClientStub(randomUtil, clientMaxReqTimeout, flakyClient)
      xa             = Transactor.fromDriverManager[IO]("org.postgresql.Driver", "jdbc:postgresql:Saga", "postgres", "root")
      logDao         = new SagaLogDaoImpl(xa)
      orderSEC       <- OrderSagaCoordinatorImpl(paymentService, loyaltyPoints, orderService, logDao, sagaMaxReqTimeout)

    // ...

Answer 1

想一些具体的东西，比如“一盒巧克力”

case class Box(v: Chocolate)

现在假设我们拿走巧克力，让盒子包含任何类型的元素 A，可能是一盒硬币、一盒糖果、一盒卡片等

case class Box[A](v: A)

这里我们在盒子的元素类型上是多态的。许多语言都可以表达这种级别的多态性。但 Scala 更进一步。以同样的方式我们拿走了巧克力，我们可以拿走盒子本身，本质上表达了一个非常抽象的想法“任何类型的元素的任何类型的上下文”

trait Ctx[F[_]]

作为另一个类比，请考虑以下

box of chocolate  -> proper type                      -> case class Box(v: Chocolate)
box of _          -> type constructor of first order  -> case class Box[A](v: A)
_   of _          -> type constructor of higher order -> trait Ctx[F[_]]

现在关注 _ of _。在这里我们有“某物的某物”，这似乎我们什么都没有。我们怎么能用这个做任何事情？这就是类型类 发挥作用的地方。类型类可以约束高度多态的形状，例如 F[_]

def apply[F[_]: Sync](...)

这里的[F[_]: Sync]表示这个约束。这意味着方法 apply 接受任何第一类构造函数，有证据表明它满足类型类 Sync 的约束。请注意，类型 Sync

trait Sync[F[_]]

被认为是高阶类型构造函数，而类型参数 F[_] 表示一阶类型构造函数。同样

F[_] : Sync : Concurrent

指定类型构造函数F不仅要满足Sync约束，还要满足Concurrent类型类的约束，等等。这些技术有时被称为可怕的声音

higher order type constructor polymorphism

但我相信大多数程序员都已经掌握了理解它的所有概念工具，因为

1. 如果您曾经将一个函数传递给另一个函数，那么您可以使用高阶的概念
2. 如果您曾经使用过 List，那么您可以使用类型构造函数的概念
3. 如果您曾经编写过对整数和 double 使用相同实现的方法，那么您可以使用多态性
的概念

使用 Scala 的隐式 机制提供类型构造器满足类型类约束的证据。 IMO Scala 3 大大简化了这个概念，所以请考虑 https://dotty.epfl.ch/docs/reference/contextual/type-classes.html