Extract a validation chain: the extracted version

#!ek9
defines module site.forAI.validationafter

  defines class

    User
      authenticated as Boolean: false

      User()
        -> authenticated as Boolean
        this.authenticated :=: authenticated

      isAuthenticated() as pure
        <- rtn as Boolean: authenticated

      default operator ?

    Request
      user as User: User()
      permissions as List of String: List()
      payload as String: String()

      Request()
        ->
          user as User
          permissions as List of String
          payload as String
        this.user: user
        this.permissions: permissions
        this.payload :=: payload

      hasUser() as pure
        <- rtn as Boolean: user?

      user() as pure
        <- rtn as User: user

      hasPermission() as pure
        -> permission as String
        <- rtn as Boolean: permission in permissions

      payload() as pure
        <- rtn as String: payload

      default operator ?

    Response
      message as String: String()

      Response() as pure
        -> message as String
        this.message :=: message

      operator $ as pure
        <- rtn as String: message

      default operator ?

  defines function

    errorResponse() as pure
      -> reason as String
      <- response as Response: Response(reason)

    doProcess() as pure
      -> request as Request
      <- response as Response: Response(`Processed ${request.payload()}`)

    validateAndProcess()
      -> request as Request
      <- response as Response?

      response: validateRequest(request) ?: doProcess(request)

    validateRequest() as pure
      -> request as Request
      <- error as Response: checkNotNull(request)

      //Assign-if-unset: each check runs only while no earlier check has failed
      error :=? checkHasUser(request)
      error :=? checkAuthenticated(request)
      error :=? checkPermission(request, "write")
      error :=? checkPayload(request)

    checkNotNull() as pure
      -> request as Request
      <- error as Response: Response()
      if not request?
        error: errorResponse("Null request")

    checkHasUser() as pure
      -> request as Request
      <- error as Response: Response()
      if not request.hasUser()
        error: errorResponse("Missing user")

    checkAuthenticated() as pure
      -> request as Request
      <- error as Response: Response()
      if not request.user().isAuthenticated()
        error: errorResponse("Not authenticated")

    checkPermission() as pure
      ->
        request as Request
        permission as String
      <- error as Response: Response()
      if not request.hasPermission(permission)
        error: errorResponse("No permission")

    checkPayload() as pure
      -> request as Request
      <- error as Response: Response()
      if not request.payload()?
        error: errorResponse("Missing payload")

  defines program

    Validate()
      stdout <- Stdout()
      allowed <- Request(user: User(true), permissions: ["write"], payload: "data")
      refused <- Request(user: User(true), permissions: ["read"], payload: "data")
      stdout.println($validateAndProcess(allowed))
      stdout.println($validateAndProcess(refused))

Processed data
No permission