Exemple of the handling of a http request : Is there a way to abstract away the store definition ? (or « can a method return an object of type Store?)

[serge-hulne]

Exemple of the handling of a http request : Is there a way to abstract away the store definition ?

More precisely, in this example https://mint-lang.com/blog/handling-http-requests, if one had to deal, not with a single URL as a source (stream) of data, but with a (rather large) plurality of URLs, one basically would have to rewrite the following part of the code (the store part) over and over again (one for each URL):

Question : Is there an approach, using Mint, to a avoid rewriting the snippet hereunder over and over again (one for each URL), like a function taking a URL as an argument an returning the corresponding "store" object?

Alternatively, does the "constructor" of a store object accept parameters (say, like the constructor of a class in Crystal, for instance)?

Beyond those questions lies really the question of the verbosity of the http request exemple from the blog. This example ought probably to be rewritten owing to the following changes in the syntax:

#503

fun makeRequest : Promise(String) {
  result = 
    await Http.send(Http.get("https://www.example.com/"))

  case (result) {
    Result::Ok(response) => response.body
    Result::Err => "Something went wrong!"
  }
}

store StarWars {
  state status : Status = Status::Initial

  fun load : Promise(Never, Void) {
    sequence {
      next { status = Status::Loading }

      response =
        "https://swapi.dev/api/planets"
        |> Http.get()
        |> Http.send()

      object =
        response.body
        |> Json.parse()
        |> Maybe.toResult("")

      decodedResults =
        decode object as Data

      next { status = Status::Ok(decodedResults) }
    } catch Http.ErrorResponse => error {
      next { status = Status::Error("Something went wrong with the request.") }
    } catch Object.Error => error {
      next { status = Status::Error("The data is not what is expected.") }
    } catch String => error {
      next { status = Status::Error("Invalid JSON data.") }
    }
  }
}

[gdotdesign]

Exemple of the handling of a http request : Is there a way to abstract away the store definition

The mint-realworld repository contains a reusable version of HTTP call: https://github.com/mint-lang/mint-realworld/blob/master/source/Api.mint Basically there is a type Api.Status(a) and a module that has functions that relate to that type.

Question : Is there an approach, using Mint, to a avoid rewriting the snippet hereunder over and over again (one for each URL), like a function taking a URL as an argument an returning the corresponding "store" object?

Alternatively, does the "constructor" of a store object accept parameters (say, like the constructor of a class in Crystal, for instance)?

There is no way to make a store generic, the way to make it abstract is to base it around a custom type (see the previous response).

Beyond those questions lies really the question of the verbosity of the http request exemple from the blog. This example ought probably to be rewritten owing to the following changes in the syntax:

Well verbosity is kind of necessary to handle all the erroneous branches, but with the syntax changes it would look a little better:

fun makeRequest : Promise(String) {
  result = 
    await Http.send(Http.get("https://www.example.com/"))

  case (result) {
    Result::Err => Result::Err("Something went wrong!")
    Result::Ok(response) => 
      case (Json.parse(response.body) {
        Maybe::Nothing => Result::Err("could not parse json")
        Maybe::Just(object) =>
          case (decode object as Data) {
            Result::Err => Result::Err("Could not decode")
            Result::Ok(decoded) => Result::Ok(decoded)
          }
      }
  }
}

[serge-hulne]

The version with the new syntax looks fantastic !
I can’t wait.
Thanks.