如何为 http4s 编写惯用的 scala 代码

Question

我正在为如何将命令式风格转换为功能风格而苦苦挣扎。

在命令式 web 请求中，我习惯于说以下伪代码：

public Response controllerAction(Request request) {
    val (req, parserErrors) = parser.parseRequest(request);
    if (parserErrors.any()) {
        return FourHundredError(parserErrors);
    }
    
    val businessErrors = model.validate(req);
    if (businessErrors.any()){
        return FourOhFour(businessErrors);
    }

    val (response, errorsWithOurStuff) = model.doBusinessLogicStuff(req);
    if (errorsWithOurStuff.any()) {
        return FiveHundredError(errorsWithOurStuff);
    }

    return OK(response)
}

我正在尝试使用 http4s 将其转换为功能样式。

  def businessRoutes[F[_]: Sync](BL: BusinessLogic[F]): HttpRoutes[F] = {
    val dsl = new Http4sDsl[F]{}
    import dsl._
    HttpRoutes.of[F] {
      case req @ POST -> Root / "sms" =>
        for {
          request <- req.as[BL.BuisnessRequest]
          requestErrors <- BL.validateRequest(request)
          response <- if (requestErrors.isEmpty) {
            BL.processRequest(request) match {
              case Failure(e) => InternalServerError(e)
              case Success(response) => Ok(response)
            }
          } else {
            BadRequest(requestErrors)
          }
        } yield response
    }
  }

上面的代码看起来......对我来说很糟糕，我不知道如何让它变得更好。 我的目标是保留此处包含的所有 http 样式抽象，因为我不想泄漏 http4s 或绕过业务层。 我觉得我有一个for then 一个if ，然后是一个match并且响应都乱七八糟地混在一起。 我在这里编写难以理解的代码，我希望一些 scala 大师可以告诉我如何清理它并使其可读。

Answer 1

恕我直言，问题根源在于您对数据进行建模的方式； 主要用validateRequest
永远记住， 解析，不要验证。

此外，我会 go 使用这样的主处理程序将无类型错误路由：

import cats.syntax.all._
import io.circe.{Error => CirceError}

object model {
  final case class RawRequest(...)
  final case class BuisnessRequest(...)
  final case class BuisnessResponse(...)
}

object errors {
  // Depending on how you end up using those,
  // it may be good to use scala.util.control.NoStackTrace with these.
  // They may also be case classes to hold some context.
  final case object ValidationError extends Throwable
  final case object BusinessError extends Throwable
}

trait BusinessLogic {
  def validateRequest(rawRequest: RawRequest): IO[BusinessRequets]
  def processRequest(request: BusinessRequets): IO[BuisnessResponse]
}

final class HttpLayer(bl: BusinessLogic) extends Http4sDsl[IO] {
  private final val errorHanlder: PartialFunction[Throwable, IO[Response[IO]] = {
    case circeError: CirceError =>
      BadRequest(...)

    case ValidationError =>
      NotFound(...)

    case BusinessError =>
      InternalServerError(...)
  }

  val routes: HttpRoutes[IO] = HttpRoutes[F] {
     case req @ POST -> Root / "sms" =>
       req
        .as[RawRequest] // This may fail with CirceError.
        .flatMap(bl.validateRequest) // This may fail with ValidationError.
        .flatMap(bl.processRequest) // This may fail with BusinessError.
        .redeemWith(recover = errorHandler, response => Ok(response))
  }
}

为了简单起见，我在这里使用了具体的IO ，如果您愿意，可以使用F[_] 。