Scala 如何包装有效的F而不是具体的类型构造函数？

我有以下函数定义：

  private val checkSapHealth: IO[ServerHealth] =
    BlazeClientBuilder[IO](global).resource.use { client =>
      discovery
        .senderAddr
        .flatMap { addr =>
          client
            .get(addr.url |+| addr.health) { res =>
              res.status match {
                case Ok =>
                  IO(ServerOnline)
                case _ =>
                  IO(ServerOffline)
              }
            }
            .timeout(2.second)
            .recover {
              case _: Throwable => ServerOffline
            }

        }
    }

我想替换具体的类型IO到F[_]，使它更抽象。这里的问题是：

IO(ServerOnline)

问题是如何做到这一点

F(ServerOnline)

尝试使用cats.effect.Sync

所以基本上使用Sync[IO]。延迟相当于使用IO.apply

尝试使用cats.effect.Sync

所以基本上使用Sync[IO]。延迟相当于使用IO.apply

使用并添加F的隐式Applicative，这样您就可以选择将值提升到F上下文中

private def checkSapHealth[F[_] : ConcurrentEffect](implicit A: Applicative[F]): F[ServerHealth] =
  BlazeClientBuilder[F](global).resource.use { client =>
    discovery
      .senderAddr
      .flatMap { addr =>
        client
          .get(addr.url |+| addr.health) { res =>
            res.status match {
              case Ok =>
                A.pure(ServerOnline)
              case _ =>
                A.pure(ServerOffline)
            }
          }
          .timeout(2.second)
          .recover {
            case _: Throwable => ServerOffline
          }
      }
  }

使用并添加F的隐式Applicative，这样您就可以选择将值提升到F上下文中

private def checkSapHealth[F[_] : ConcurrentEffect](implicit A: Applicative[F]): F[ServerHealth] =
  BlazeClientBuilder[F](global).resource.use { client =>
    discovery
      .senderAddr
      .flatMap { addr =>
        client
          .get(addr.url |+| addr.health) { res =>
            res.status match {
              case Ok =>
                A.pure(ServerOnline)
              case _ =>
                A.pure(ServerOffline)
            }
          }
          .timeout(2.second)
          .recover {
            case _: Throwable => ServerOffline
          }
      }
  }